| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Data.Vec.Pull
Description
Pull/representable Vec n a = Fin n -> a
The module tries to have same API as Data.Vec.Lazy, missing bits:
withDict, toPull, fromPull, traverse (and variants),
(++), concat and split.
Synopsis
- newtype Vec (n :: Nat) a = Vec {}
- empty :: Vec 'Z a
- singleton :: a -> Vec ('S 'Z) a
- toList :: forall (n :: Nat) a. SNatI n => Vec n a -> [a]
- toNonEmpty :: forall (n :: Nat) a. SNatI n => Vec ('S n) a -> NonEmpty a
- fromList :: forall (n :: Nat) a. SNatI n => [a] -> Maybe (Vec n a)
- fromListPrefix :: forall (n :: Nat) a. SNatI n => [a] -> Maybe (Vec n a)
- reifyList :: [a] -> (forall (n :: Nat). SNatI n => Vec n a -> r) -> r
- (!) :: forall (n :: Nat) a. Vec n a -> Fin n -> a
- tabulate :: forall (n :: Nat) a. (Fin n -> a) -> Vec n a
- cons :: forall a (n :: Nat). a -> Vec n a -> Vec ('S n) a
- snoc :: forall a (n :: Nat). SNatI n => Vec n a -> a -> Vec ('S n) a
- head :: forall (n :: Nat) a. Vec ('S n) a -> a
- last :: forall (n :: Nat) a. SNatI n => Vec ('S n) a -> a
- tail :: forall (n :: Nat) a. Vec ('S n) a -> Vec n a
- init :: forall (n :: Nat) a. SNatI n => Vec ('S n) a -> Vec n a
- reverse :: forall (n :: Nat) a. SNatI n => Vec n a -> Vec n a
- foldMap :: forall m (n :: Nat) a. (Monoid m, SNatI n) => (a -> m) -> Vec n a -> m
- foldMap1 :: forall s (n :: Nat) a. (Semigroup s, SNatI n) => (a -> s) -> Vec ('S n) a -> s
- ifoldMap :: forall m (n :: Nat) a. (Monoid m, SNatI n) => (Fin n -> a -> m) -> Vec n a -> m
- ifoldMap1 :: forall s (n :: Nat) a. (Semigroup s, SNatI n) => (Fin ('S n) -> a -> s) -> Vec ('S n) a -> s
- foldr :: forall (n :: Nat) a b. SNatI n => (a -> b -> b) -> b -> Vec n a -> b
- ifoldr :: forall (n :: Nat) a b. SNatI n => (Fin n -> a -> b -> b) -> b -> Vec n a -> b
- foldl' :: forall (n :: Nat) b a. SNatI n => (b -> a -> b) -> b -> Vec n a -> b
- length :: forall (n :: Nat) a. SNatI n => Vec n a -> Int
- null :: forall (n :: Nat) a. SNatI n => Vec n a -> Bool
- sum :: forall a (n :: Nat). (Num a, SNatI n) => Vec n a -> a
- product :: forall a (n :: Nat). (Num a, SNatI n) => Vec n a -> a
- map :: forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b
- imap :: forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b
- zipWith :: forall a b c (n :: Nat). (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
- izipWith :: forall (n :: Nat) a b c. (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c
- repeat :: forall x (n :: Nat). x -> Vec n x
- bind :: forall (n :: Nat) a b. Vec n a -> (a -> Vec n b) -> Vec n b
- join :: forall (n :: Nat) a. Vec n (Vec n a) -> Vec n a
- universe :: forall (n :: Nat). SNatI n => Vec n (Fin n)
Documentation
newtype Vec (n :: Nat) a Source #
Easily fuseable Vec.
It on purpose doesn't have bad (fusion-wise) instances, like Traversable.
Generally, there aren't functions which would be bad consumers or bad producers.
Instances
| Representable (Vec n) Source # | |
| SNatI n => Foldable (Vec n) Source # | |
Defined in Data.Vec.Pull Methods fold :: Monoid m => Vec n m -> m # foldMap :: Monoid m => (a -> m) -> Vec n a -> m # foldMap' :: Monoid m => (a -> m) -> Vec n a -> m # foldr :: (a -> b -> b) -> b -> Vec n a -> b # foldr' :: (a -> b -> b) -> b -> Vec n a -> b # foldl :: (b -> a -> b) -> b -> Vec n a -> b # foldl' :: (b -> a -> b) -> b -> Vec n a -> b # foldr1 :: (a -> a -> a) -> Vec n a -> a # foldl1 :: (a -> a -> a) -> Vec n a -> a # elem :: Eq a => a -> Vec n a -> Bool # maximum :: Ord a => Vec n a -> a # minimum :: Ord a => Vec n a -> a # | |
| (SNatI m, n ~ 'S m) => Foldable1 (Vec n) Source # | |
Defined in Data.Vec.Pull Methods fold1 :: Semigroup m0 => Vec n m0 -> m0 # foldMap1 :: Semigroup m0 => (a -> m0) -> Vec n a -> m0 # foldMap1' :: Semigroup m0 => (a -> m0) -> Vec n a -> m0 # toNonEmpty :: Vec n a -> NonEmpty a # maximum :: Ord a => Vec n a -> a # minimum :: Ord a => Vec n a -> a # foldrMap1 :: (a -> b) -> (a -> b -> b) -> Vec n a -> b # foldlMap1' :: (a -> b) -> (b -> a -> b) -> Vec n a -> b # foldlMap1 :: (a -> b) -> (b -> a -> b) -> Vec n a -> b # foldrMap1' :: (a -> b) -> (a -> b -> b) -> Vec n a -> b # | |
| Applicative (Vec n) Source # | |
| Functor (Vec n) Source # | |
| Monad (Vec n) Source # | |
| Distributive (Vec n) Source # | |
| Apply (Vec n) Source # | |
| Bind (Vec n) Source # | |
| SNatI n => FoldableWithIndex (Fin n) (Vec n) Source # | Since: 0.4 |
Defined in Data.Vec.Pull | |
| FunctorWithIndex (Fin n) (Vec n) Source # | Since: 0.4 |
| Monoid a => Monoid (Vec n a) Source # | |
| Semigroup a => Semigroup (Vec n a) Source # | |
| n ~ 'Z => Boring (Vec n a) Source # | Since: 0.4.1 |
Defined in Data.Vec.Pull | |
| (Eq a, SNatI n) => Eq (Vec n a) Source # | |
| type Rep (Vec n) Source # | |
Defined in Data.Vec.Pull | |
Construction
singleton :: a -> Vec ('S 'Z) a Source #
Vec with exactly one element.
>>>L.fromPull $ singleton TrueTrue ::: VNil
Conversions
toNonEmpty :: forall (n :: Nat) a. SNatI n => Vec ('S n) a -> NonEmpty a Source #
Convert Vec to NonEmpty.
fromList :: forall (n :: Nat) a. SNatI n => [a] -> Maybe (Vec n a) Source #
Convert list [a] to Vec n aNothing if lengths don't match exactly.
>>>L.fromPull <$> fromList "foo" :: Maybe (L.Vec N.Nat3 Char)Just ('f' ::: 'o' ::: 'o' ::: VNil)
>>>L.fromPull <$> fromList "quux" :: Maybe (L.Vec N.Nat3 Char)Nothing
>>>L.fromPull <$> fromList "xy" :: Maybe (L.Vec N.Nat3 Char)Nothing
fromListPrefix :: forall (n :: Nat) a. SNatI n => [a] -> Maybe (Vec n a) Source #
Convert list [a] to Vec n aNothing if input list is too short.
>>>L.fromPull <$> fromListPrefix "foo" :: Maybe (L.Vec N.Nat3 Char)Just ('f' ::: 'o' ::: 'o' ::: VNil)
>>>L.fromPull <$> fromListPrefix "quux" :: Maybe (L.Vec N.Nat3 Char)Just ('q' ::: 'u' ::: 'u' ::: VNil)
>>>L.fromPull <$> fromListPrefix "xy" :: Maybe (L.Vec N.Nat3 Char)Nothing
reifyList :: [a] -> (forall (n :: Nat). SNatI n => Vec n a -> r) -> r Source #
Reify any list [a] to Vec n a
>>>reifyList "foo" length3
Indexing
cons :: forall a (n :: Nat). a -> Vec n a -> Vec ('S n) a Source #
Cons an element in front of a Vec.
snoc :: forall a (n :: Nat). SNatI n => Vec n a -> a -> Vec ('S n) a Source #
Add a single element at the end of a Vec.
Since: 0.2.1
Reverse
Folds
foldMap :: forall m (n :: Nat) a. (Monoid m, SNatI n) => (a -> m) -> Vec n a -> m Source #
See Foldable.
foldMap1 :: forall s (n :: Nat) a. (Semigroup s, SNatI n) => (a -> s) -> Vec ('S n) a -> s Source #
See Foldable1.
ifoldMap :: forall m (n :: Nat) a. (Monoid m, SNatI n) => (Fin n -> a -> m) -> Vec n a -> m Source #
See FoldableWithIndex.
ifoldMap1 :: forall s (n :: Nat) a. (Semigroup s, SNatI n) => (Fin ('S n) -> a -> s) -> Vec ('S n) a -> s Source #
There is no type-class for this :(
ifoldr :: forall (n :: Nat) a b. SNatI n => (Fin n -> a -> b -> b) -> b -> Vec n a -> b Source #
Right fold with an index.
foldl' :: forall (n :: Nat) b a. SNatI n => (b -> a -> b) -> b -> Vec n a -> b Source #
Strict left fold.
Special folds
Mapping
map :: forall a b (n :: Nat). (a -> b) -> Vec n a -> Vec n b Source #
>>>L.fromPull $ map not $ L.toPull $ True L.::: False L.::: L.VNilFalse ::: True ::: VNil
imap :: forall (n :: Nat) a b. (Fin n -> a -> b) -> Vec n a -> Vec n b Source #
>>>L.fromPull $ imap (,) $ L.toPull $ 'a' L.::: 'b' L.::: 'c' L.::: L.VNil(0,'a') ::: (1,'b') ::: (2,'c') ::: VNil
Zipping
zipWith :: forall a b c (n :: Nat). (a -> b -> c) -> Vec n a -> Vec n b -> Vec n c Source #
Zip two Vecs with a function.
izipWith :: forall (n :: Nat) a b c. (Fin n -> a -> b -> c) -> Vec n a -> Vec n b -> Vec n c Source #
Zip two Vecs. with a function that also takes the elements' indices.