Data.List.Unrolled

This module provides unrollable versions of functions on lists.

Classes in this module are assumed to be closed. You should not create new instances for them.

Documentation

class Append (n :: Nat) where

Append two lists. Type param l is the length of the left list.

Minimal complete definition

append

Methods

append :: [a] -> [a] -> [a]

Instances

Append ((-) n 1) => Append n

Methods

append :: [a] -> [a] -> [a]

Append 0

Methods

append :: [a] -> [a] -> [a]

class Drop (n :: Nat) where

Drop n elements from a list.

Minimal complete definition

drop

Methods

drop :: [a] -> [a]

Instances

Drop ((-) n 1) => Drop n

Methods

drop :: [a] -> [a]

Drop 0

Methods

drop :: [a] -> [a]

class Take (n :: Nat) where

Take n elements from a list

Minimal complete definition

take

Methods

take :: [a] -> [a]

Instances

Take ((-) n 1) => Take n

Methods

take :: [a] -> [a]

Take 0

Methods

take :: [a] -> [a]

splitAt :: forall (n :: Nat) a. (Take n, Drop n) => [a] -> ([a], [a])

Split list at n-th element.

class ChunksOf (n :: Nat) (c :: Nat) where

Split list into chunks of the given length c. n is length of the list.

Minimal complete definition

chunksOf

Methods

chunksOf :: [a] -> [[a]]

Instances

(Take c, Drop c, ChunksOf ((-) n 1) c) => ChunksOf n c

Methods

chunksOf :: [a] -> [[a]]

ChunksOf n 0

Methods

chunksOf :: [a] -> [[a]]

ChunksOf 0 c

Methods

chunksOf :: [a] -> [[a]]

ChunksOf 0 0

Methods

chunksOf :: [a] -> [[a]]

type family ChunksCount (len :: Nat) (clen :: Nat) where ...

Number of resulting chunks when list of length len split by chunks of length clen.

Equations

ChunksCount 0 _ = 0

ChunksCount _ 0 = 0

ChunksCount l c = If (l <=? c) 1 (1 + ChunksCount (l - c) c)

class Zip (n :: Nat) where

Zip 2 lists together. Type param n is the length of the first list.

Minimal complete definition

zip

Methods

zip :: [a] -> [b] -> [(a, b)]

Instances

Zip ((-) n 1) => Zip n

Methods

zip :: [a] -> [b] -> [(a, b)]

Zip 0

Methods

zip :: [a] -> [b] -> [(a, b)]

class Zip3 (n :: Nat) where

Zip 3 lists together. Type param n is the length of the first list.

Minimal complete definition

zip3

Methods

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

Instances

Zip3 ((-) n 1) => Zip3 n

Methods

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

Zip3 0

Methods

zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]

class ZipWith (n :: Nat) where

Zip 2 lists together using given function. Type param n is the length of the first list.

Minimal complete definition

zipWith

Methods

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

Instances

ZipWith ((-) n 1) => ZipWith n

Methods

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

ZipWith 0

Methods

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

class Unzip (n :: Nat) where

Unzip a list. Type param n is the length of the list.

Minimal complete definition

unzip

Methods

unzip :: [(a, b)] -> ([a], [b])

Instances

Unzip ((-) n 1) => Unzip n

Methods

unzip :: [(a, b)] -> ([a], [b])

Unzip 0

Methods

unzip :: [(a, b)] -> ([a], [b])

class Filter (n :: Nat) where

Filter list with given predicate. Type param n is the length of the list.

Minimal complete definition

filter

Methods

filter :: (a -> Bool) -> [a] -> [a]

Instances

Filter ((-) n 1) => Filter n

Methods

filter :: (a -> Bool) -> [a] -> [a]

Filter 0

Methods

filter :: (a -> Bool) -> [a] -> [a]

class Map (n :: Nat) where

Apply function to all elements of a list. Type param n is the length of the list.

Minimal complete definition

map

Methods

map :: (a -> b) -> [a] -> [b]

Instances

Map ((-) n 1) => Map n

Methods

map :: (a -> b) -> [a] -> [b]

Map 0

Methods

map :: (a -> b) -> [a] -> [b]

class All (n :: Nat) where

Check if all elements of the list satisfy the predicate. Type param n is the length of the list.

Minimal complete definition

all

Methods

all :: (a -> Bool) -> [a] -> Bool

Instances

All ((-) n 1) => All n

Methods

all :: (a -> Bool) -> [a] -> Bool

All 0

Methods

all :: (a -> Bool) -> [a] -> Bool

class Foldr (n :: Nat) where

Right fold of a list of length n.

Minimal complete definition

foldr

Methods

foldr :: (a -> b -> b) -> b -> [a] -> b

Instances

Foldr ((-) n 1) => Foldr n

Methods

foldr :: (a -> b -> b) -> b -> [a] -> b

Foldr 0

Methods

foldr :: (a -> b -> b) -> b -> [a] -> b

class Foldr1 (n :: Nat) where

Right fold of a list of length n with no base element.

Minimal complete definition

foldr1

Methods

foldr1 :: (a -> a -> a) -> [a] -> a

Instances

Foldr1 ((-) n 1) => Foldr1 n

Methods

foldr1 :: (a -> a -> a) -> [a] -> a

Foldr1 1

Methods

foldr1 :: (a -> a -> a) -> [a] -> a

class Foldl (n :: Nat) where

Left fold of a list of length n.

Minimal complete definition

foldl

Methods

foldl :: (b -> a -> b) -> b -> [a] -> b

Instances

Foldl ((-) n 1) => Foldl n

Methods

foldl :: (b -> a -> b) -> b -> [a] -> b

Foldl 0

Methods

foldl :: (b -> a -> b) -> b -> [a] -> b

class Foldl1 (n :: Nat) where

Right fold of a list of length n with no base element.

Minimal complete definition

foldl1

Methods

foldl1 :: (a -> a -> a) -> [a] -> a

Instances

Foldl1 ((-) n 1) => Foldl1 n

Methods

foldl1 :: (a -> a -> a) -> [a] -> a

Foldl1 1

Methods

foldl1 :: (a -> a -> a) -> [a] -> a

foldMap :: forall (n :: Nat) m a. FoldMap n m => (a -> m) -> [a] -> m

Map each element of the list of length n to a monoid, and combine the results.

type FoldMap (n :: Nat) m = (Monoid m, Foldr n)

Constraint of the foldMap function.

sum :: forall (n :: Nat) a. Sum n a => [a] -> a

Sum of the elements of the list of length n.

type Sum (n :: Nat) a = (Foldr n, Num a)

Constraint of the sum function.

class Replicate (n :: Nat) where

Fill the list of length n with the same values.

Minimal complete definition

replicate

Methods

replicate :: a -> [a]

Instances

Replicate ((-) n 1) => Replicate n

Methods

replicate :: a -> [a]

Replicate 0

Methods

replicate :: a -> [a]

class EnumFromN (n :: Nat) where

Enumeration of length n starting from given value.

Minimal complete definition

enumFromN

Methods

enumFromN

Arguments

:: Num a

=> a

Starting value.

-> [a]

Instances

EnumFromN ((-) n 1) => EnumFromN n

Methods

enumFromN :: Num a => a -> [a]

EnumFromN 0

Methods

enumFromN :: Num a => a -> [a]

class EnumFromStepN (n :: Nat) where

Enumeration of length n starting from given value with given step.

Minimal complete definition

enumFromStepN

Methods

enumFromStepN

Arguments

:: Num a

=> a

Starting value.

-> a

Step.

-> [a]

Instances

EnumFromStepN ((-) n 1) => EnumFromStepN n

Methods

enumFromStepN :: Num a => a -> a -> [a]

EnumFromStepN 0

Methods

enumFromStepN :: Num a => a -> a -> [a]