Modulebasement-0.0.16Haskell2010

Basement.Sized.List

A Nat-sized list abstraction

Using this module is limited to GHC 7.10 and above.

1 type
50 values

Packagebasement-0.0.16
Exports51
LanguageHaskell2010
LicenceBSD-3-Clause
SourceList.hs

newtypenewtype ListN (n :: Nat) a

A Typed-level sized List equivalent to [a]

Instances6Eq, Ord, Show, Generic, NormalForm, Rep

Eq a => Eq (ListN n a)Defined in basement-0.0.16 · Basement.Sized.List
Ord a => Ord (ListN n a)Defined in basement-0.0.16 · Basement.Sized.List
Show a => Show (ListN n a)Defined in basement-0.0.16 · Basement.Sized.List
Generic (ListN n a)Defined in basement-0.0.16 · Basement.Sized.List
NormalForm a => NormalForm (ListN n a)Defined in basement-0.0.16 · Basement.Sized.List
type Rep (ListN n a) = D1 ('MetaData "ListN" "Basement.Sized.List" "basement-0.0.16-HSpAMwbNqIYE6yCkmfUTGp" 'True) (C1 ('MetaCons "ListN" 'PrefixI 'True) (S1 ('MetaSel ('Just "unListN") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))Defined in basement-0.0.16 · Basement.Sized.List

valuetoListN :: (KnownNat n, NatWithinBound Int n) => [a] -> Maybe (ListN n a)

Try to create a ListN from a List, succeeding if the length is correct

valuetoListN_

:: (HasCallStack, NatWithinBound Int n, KnownNat n)
=> [a]
-> ListN n a

Create a ListN from a List, expecting a given length

If this list contains more or less than the expected length of the resulting type, then an asynchronous error is raised. use toListN for a more friendly functions

valueunListN :: ListN n a -> [a]

valuelength :: (KnownNat n, NatWithinBound Int n) => ListN n a -> CountOf a

Get the length of a list

valuecreate :: KnownNat n => (Natural -> a) -> ListN n a

Create a new list of size n, repeately calling f from 0 to n-1

valuecreateFrom

:: (KnownNat n, KnownNat start)
=> Proxy start
-> Natural -> a
-> ListN n a

Same as create but apply an offset

valueempty :: ListN 0 a

Create an empty list of a

valuesingleton :: a -> ListN 1 a

create a list of 1 element

valueuncons :: 1 <= n => ListN n a -> (a, ListN (n - 1) a)

Decompose a list into its head and tail.

valuecons :: a -> ListN n a -> ListN (n + 1) a

prepend an element to the list

valueunsnoc :: 1 <= n => ListN n a -> (ListN (n - 1) a, a)

Decompose a list into its first elements and the last.

valuesnoc :: ListN n a -> a -> ListN (n + 1) a

append an element to the list

valueindex :: ListN n ty -> Offset ty -> ty

Get the i'the element

valueindexStatic

:: (KnownNat i, CmpNat i n ~ 'LT, Offsetable a i)
=> ListN n a
-> a

Get the i'th elements

This only works with TypeApplication:

indexStatic @1 (toListN_ [1,2,3] :: ListN 3 Int)

valueupdateAt :: Offset a -> (a -> a) -> ListN n a -> ListN n a

Update the value in a list at a specific location

valuemap :: (a -> b) -> ListN n a -> ListN n b

Map all elements in a list

valuemapi :: (Natural -> a -> b) -> ListN n a -> ListN n b

Map all elements in a list with an additional index

valueelem :: Eq a => a -> ListN n a -> Bool

Check if a list contains the element a

valuefoldl :: (b -> a -> b) -> b -> ListN n a -> b

Fold all elements from left

valuefoldl' :: (b -> a -> b) -> b -> ListN n a -> b

Fold all elements from left strictly

valuefoldl1' :: 1 <= n => (a -> a -> a) -> ListN n a -> a

Fold all elements from left strictly with a first element as the accumulator

valuescanl' :: (b -> a -> b) -> b -> ListN n a -> ListN (n + 1) b

scanl is similar to foldl, but returns a list of successive reduced values from the left

scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]

valuescanl1' :: (a -> a -> a) -> ListN n a -> ListN n a

scanl1 is a variant of scanl that has no starting value argument:

scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]

valuefoldr :: (a -> b -> b) -> b -> ListN n a -> b

Fold all elements from right

valuefoldr1 :: 1 <= n => (a -> a -> a) -> ListN n a -> a

Fold all elements from right assuming at least one element is in the list.

valuereverse :: ListN n a -> ListN n a

Reverse a list

valueappend :: ListN n a -> ListN m a -> ListN (n + m) a

Append 2 list together returning the new list

valueminimum :: (Ord a, 1 <= n) => ListN n a -> a

Get the minimum element of a list

valuemaximum :: (Ord a, 1 <= n) => ListN n a -> a

Get the maximum element of a list

valuehead :: 1 <= n => ListN n a -> a

Get the head element of a list

valuetail :: 1 <= n => ListN n a -> ListN (n - 1) a

Get the tail of a list

valueinit :: 1 <= n => ListN n a -> ListN (n - 1) a

Get the list with the last element missing

valuetake :: (KnownNat m, NatWithinBound Int m, m <= n) => ListN n a -> ListN m a

Take m elements from the beggining of the list.

The number of elements need to be less or equal to the list in argument

valuedrop

:: (KnownNat d, NatWithinBound Int d, (n - m) ~ d, m <= n)
=> ListN n a
-> ListN m a

Drop elements from a list keeping the m remaining elements

valuesplitAt

:: (KnownNat d, NatWithinBound Int d, (n - m) ~ d, m <= n)
=> ListN n a
-> (ListN m a, ListN (n - m) a)

Split a list into two, returning 2 lists

valuezip :: ListN n a -> ListN n b -> ListN n (a, b)

Zip 2 lists of the same size, returning a new list of the tuple of each elements

valuezip3 :: ListN n a -> ListN n b -> ListN n c -> ListN n (a, b, c)

Zip 3 lists of the same size

valuezip4

:: ListN n a
-> ListN n b
-> ListN n c
-> ListN n d
-> ListN n (a, b, c, d)

Zip 4 lists of the same size

valuezip5

:: ListN n a
-> ListN n b
-> ListN n c
-> ListN n d
-> ListN n e
-> ListN n (a, b, c, d, e)

Zip 5 lists of the same size

valueunzip :: ListN n (a, b) -> (ListN n a, ListN n b)

Unzip a list of tuple, to 2 List of the deconstructed tuples

valuezipWith :: (a -> b -> x) -> ListN n a -> ListN n b -> ListN n x

Zip 2 lists using a function

valuezipWith3

:: a -> b -> c -> x
-> ListN n a
-> ListN n b
-> ListN n c
-> ListN n x

Zip 3 lists using a function

valuezipWith4

:: a -> b -> c -> d -> x
-> ListN n a
-> ListN n b
-> ListN n c
-> ListN n d
-> ListN n x

Zip 4 lists using a function

valuezipWith5

:: a -> b -> c -> d -> e -> x
-> ListN n a
-> ListN n b
-> ListN n c
-> ListN n d
-> ListN n e
-> ListN n x

Zip 5 lists using a function

valuereplicate :: (NatWithinBound Int n, KnownNat n) => a -> ListN n a

Create a list of n elements where each element is the element in argument

Applicative And Monadic

5 declarations

valuereplicateM

:: (NatWithinBound Int n, Monad m, KnownNat n)
=> m a
-> m (ListN n a)

performs a monadic action n times, gathering the results in a List of size n.

valuesequence :: Monad m => ListN n (m a) -> m (ListN n a)

Evaluate each monadic action in the list sequentially, and collect the results.

valuesequence_ :: Monad m => ListN n (m a) -> m ()

Evaluate each monadic action in the list sequentially, and ignore the results.

valuemapM :: Monad m => (a -> m b) -> ListN n a -> m (ListN n b)

Map each element of a List to a monadic action, evaluate these actions sequentially and collect the results

valuemapM_ :: Monad m => (a -> m b) -> ListN n a -> m ()

Map each element of a List to a monadic action, evaluate these actions sequentially and ignore the results