Data.FastVect.Sparse.Write

newtype Vect :: Int -> Type -> Typenewtype Vect len elem

A Sparse Vector Implementation backed by an List of tuples. Slow reads, fast writes.

vect ∷ Vect 1 String
vect = singleton "a"

Instances

• (Show elem, Reflectable len Int) => Show (Vect len elem)
• (Eq elem) => Eq (Vect len elem)
• (Ord elem) => Ord (Vect len elem)
• Functor (Vect len)
• Apply (Vect len)
• (Compare len NegOne GT, Reflectable len Int) => Applicative (Vect len)
• FunctorWithIndex Int (Vect len)
• Foldable (Vect len)
• FoldableWithIndex Int (Vect len)
• Traversable (Vect len)
• TraversableWithIndex Int (Vect len)
• IsVect (Vect n)

replicate :: forall len elem. Replicate Vect len elem

empty :: forall elem. Empty Vect elem

sparse :: forall elem n. Sparse Vect elem n

singleton :: forall elem. Singleton Vect elem

append :: forall m n m_plus_n elem. Append Vect m n m_plus_n elem

drop :: forall m n m_plus_n elem. Drop Vect m n m_plus_n elem

take :: forall m n m_plus_n elem. Take Vect m n m_plus_n elem

splitAt :: forall m n m_plus_n elem. SplitAt Vect m n m_plus_n elem

modify :: forall m n elem. Modify Vect m n elem

set :: forall m n elem. Set Vect m n elem

index :: forall m m_minus_one i n elem. IndexM Vect m m_minus_one i n elem

indexModulo :: forall m elem. IndexModuloM Vect m elem

head :: forall m elem. HeadM Vect m elem

fromMap :: forall len elem. Reflectable len Int => Compare len NegOne GT => Proxy len -> Map Int elem -> Maybe (Vect len elem)

toList :: forall len elem. Compare len NegOne GT => Vect len elem -> List { elem :: elem, ix :: Int }

cons :: forall len len_plus_1 elem. Cons Vect len len_plus_1 elem

snoc :: forall len len_plus_1 elem. Snoc Vect len len_plus_1 elem

Operator alias for Data.FastVect.Sparse.Write.cons (right-associative / precedence 6)