Data.List.Length

LENGTHED LIST LEFT

Type

type LengthL n = RangeL n n

The value of LengthL n a is a list which have just n members of type a. You can push and pop an element from left.

>>> :set -XDataKinds
>>> sampleLengthL = 'h' :. 'e' :. 'l' :. 'l' :. 'o' :. NilL :: LengthL 5 Char

data RangeL :: Nat -> Nat -> Type -> Type where

The value of RangeL n m a is a list of type a values whose element number is at minimum n, and at maximum m. You can push and pop an element from left.

>>> :set -XDataKinds
>>> sampleRangeL = 'h' :. 'e' :. 'l' :. 'l' :.. 'o' :.. NilL :: RangeL 3 8 Char

Constructors

NilL :: 0 <= m => RangeL 0 m a

(:.) :: (1 <= n, 1 <= m) => a -> RangeL (n - 1) (m - 1) a -> RangeL n m a infixr 6

Instances

(1 <= n, Applicative (LengthL n), Monad (LengthL (n - 1))) => Monad (LengthL n)

Defined in Data.List.Range.RangeL

Methods

(>>=) :: LengthL n a -> (a -> LengthL n b) -> LengthL n b

(>>) :: LengthL n a -> LengthL n b -> LengthL n b

return :: a -> LengthL n a

Applicative (LengthL 0) => Monad (LengthL 0)

Defined in Data.List.Range.RangeL

Methods

(>>=) :: LengthL 0 a -> (a -> LengthL 0 b) -> LengthL 0 b

(>>) :: LengthL 0 a -> LengthL 0 b -> LengthL 0 b

return :: a -> LengthL 0 a

Applicative (LengthL 0)

Defined in Data.List.Range.RangeL

Methods

pure :: a -> LengthL 0 a

(<*>) :: LengthL 0 (a -> b) -> LengthL 0 a -> LengthL 0 b

liftA2 :: (a -> b -> c) -> LengthL 0 a -> LengthL 0 b -> LengthL 0 c

(*>) :: LengthL 0 a -> LengthL 0 b -> LengthL 0 b

(<*) :: LengthL 0 a -> LengthL 0 b -> LengthL 0 a

(1 <= n, Functor (RangeL (n - 1) (m - 1))) => Functor (RangeL n m)

Defined in Data.List.Range.RangeL

Methods

fmap :: (a -> b) -> RangeL n m a -> RangeL n m b

(<$) :: a -> RangeL n m b -> RangeL n m a

Functor (RangeL 0 (m - 1)) => Functor (RangeL 0 m)

Defined in Data.List.Range.RangeL

Methods

fmap :: (a -> b) -> RangeL 0 m a -> RangeL 0 m b

(<$) :: a -> RangeL 0 m b -> RangeL 0 m a

Functor (RangeL 0 0)

Defined in Data.List.Range.RangeL

Methods

fmap :: (a -> b) -> RangeL 0 0 a -> RangeL 0 0 b

(<$) :: a -> RangeL 0 0 b -> RangeL 0 0 a

(1 <= n, Functor (RangeL n m), Applicative (RangeL (n - 1) (m - 1)), Unfoldr 0 n m) => Applicative (RangeL n m)

Defined in Data.List.Range.RangeL

Methods

pure :: a -> RangeL n m a

(<*>) :: RangeL n m (a -> b) -> RangeL n m a -> RangeL n m b

liftA2 :: (a -> b -> c) -> RangeL n m a -> RangeL n m b -> RangeL n m c

(*>) :: RangeL n m a -> RangeL n m b -> RangeL n m b

(<*) :: RangeL n m a -> RangeL n m b -> RangeL n m a

(Functor (RangeL 0 m), Applicative (RangeL 0 (m - 1)), Unfoldr 0 0 m) => Applicative (RangeL 0 m)

Defined in Data.List.Range.RangeL

Methods

pure :: a -> RangeL 0 m a

(<*>) :: RangeL 0 m (a -> b) -> RangeL 0 m a -> RangeL 0 m b

liftA2 :: (a -> b -> c) -> RangeL 0 m a -> RangeL 0 m b -> RangeL 0 m c

(*>) :: RangeL 0 m a -> RangeL 0 m b -> RangeL 0 m b

(<*) :: RangeL 0 m a -> RangeL 0 m b -> RangeL 0 m a

(1 <= n, Foldable (RangeL (n - 1) (m - 1))) => Foldable (RangeL n m)

Defined in Data.List.Range.RangeL

Methods

fold :: Monoid m0 => RangeL n m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> RangeL n m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> RangeL n m a -> m0

foldr :: (a -> b -> b) -> b -> RangeL n m a -> b

foldr' :: (a -> b -> b) -> b -> RangeL n m a -> b

foldl :: (b -> a -> b) -> b -> RangeL n m a -> b

foldl' :: (b -> a -> b) -> b -> RangeL n m a -> b

foldr1 :: (a -> a -> a) -> RangeL n m a -> a

foldl1 :: (a -> a -> a) -> RangeL n m a -> a

toList :: RangeL n m a -> [a]

null :: RangeL n m a -> Bool

length :: RangeL n m a -> Int

elem :: Eq a => a -> RangeL n m a -> Bool

maximum :: Ord a => RangeL n m a -> a

minimum :: Ord a => RangeL n m a -> a

sum :: Num a => RangeL n m a -> a

product :: Num a => RangeL n m a -> a

Foldable (RangeL 0 (m - 1)) => Foldable (RangeL 0 m)

Defined in Data.List.Range.RangeL

Methods

fold :: Monoid m0 => RangeL 0 m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> RangeL 0 m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> RangeL 0 m a -> m0

foldr :: (a -> b -> b) -> b -> RangeL 0 m a -> b

foldr' :: (a -> b -> b) -> b -> RangeL 0 m a -> b

foldl :: (b -> a -> b) -> b -> RangeL 0 m a -> b

foldl' :: (b -> a -> b) -> b -> RangeL 0 m a -> b

foldr1 :: (a -> a -> a) -> RangeL 0 m a -> a

foldl1 :: (a -> a -> a) -> RangeL 0 m a -> a

toList :: RangeL 0 m a -> [a]

null :: RangeL 0 m a -> Bool

length :: RangeL 0 m a -> Int

elem :: Eq a => a -> RangeL 0 m a -> Bool

maximum :: Ord a => RangeL 0 m a -> a

minimum :: Ord a => RangeL 0 m a -> a

sum :: Num a => RangeL 0 m a -> a

product :: Num a => RangeL 0 m a -> a

Foldable (RangeL 0 0)

Defined in Data.List.Range.RangeL

Methods

fold :: Monoid m => RangeL 0 0 m -> m

foldMap :: Monoid m => (a -> m) -> RangeL 0 0 a -> m

foldMap' :: Monoid m => (a -> m) -> RangeL 0 0 a -> m

foldr :: (a -> b -> b) -> b -> RangeL 0 0 a -> b

foldr' :: (a -> b -> b) -> b -> RangeL 0 0 a -> b

foldl :: (b -> a -> b) -> b -> RangeL 0 0 a -> b

foldl' :: (b -> a -> b) -> b -> RangeL 0 0 a -> b

foldr1 :: (a -> a -> a) -> RangeL 0 0 a -> a

foldl1 :: (a -> a -> a) -> RangeL 0 0 a -> a

toList :: RangeL 0 0 a -> [a]

null :: RangeL 0 0 a -> Bool

length :: RangeL 0 0 a -> Int

elem :: Eq a => a -> RangeL 0 0 a -> Bool

maximum :: Ord a => RangeL 0 0 a -> a

minimum :: Ord a => RangeL 0 0 a -> a

sum :: Num a => RangeL 0 0 a -> a

product :: Num a => RangeL 0 0 a -> a

(1 <= n, Traversable (RangeL (n - 1) (m - 1))) => Traversable (RangeL n m)

Defined in Data.List.Range.RangeL

Methods

traverse :: Applicative f => (a -> f b) -> RangeL n m a -> f (RangeL n m b)

sequenceA :: Applicative f => RangeL n m (f a) -> f (RangeL n m a)

mapM :: Monad m0 => (a -> m0 b) -> RangeL n m a -> m0 (RangeL n m b)

sequence :: Monad m0 => RangeL n m (m0 a) -> m0 (RangeL n m a)

Traversable (RangeL 0 (m - 1)) => Traversable (RangeL 0 m)

Defined in Data.List.Range.RangeL

Methods

traverse :: Applicative f => (a -> f b) -> RangeL 0 m a -> f (RangeL 0 m b)

sequenceA :: Applicative f => RangeL 0 m (f a) -> f (RangeL 0 m a)

mapM :: Monad m0 => (a -> m0 b) -> RangeL 0 m a -> m0 (RangeL 0 m b)

sequence :: Monad m0 => RangeL 0 m (m0 a) -> m0 (RangeL 0 m a)

Traversable (RangeL 0 0)

Defined in Data.List.Range.RangeL

Methods

traverse :: Applicative f => (a -> f b) -> RangeL 0 0 a -> f (RangeL 0 0 b)

sequenceA :: Applicative f => RangeL 0 0 (f a) -> f (RangeL 0 0 a)

mapM :: Monad m => (a -> m b) -> RangeL 0 0 a -> m (RangeL 0 0 b)

sequence :: Monad m => RangeL 0 0 (m a) -> m (RangeL 0 0 a)

(Foldable (RangeL n m), Unfoldr 0 n m) => IsList (RangeL n m a)

Defined in Data.List.Range.RangeL

Associated Types

type Item (RangeL n m a)

Methods

fromList :: [Item (RangeL n m a)] -> RangeL n m a

fromListN :: Int -> [Item (RangeL n m a)] -> RangeL n m a

toList :: RangeL n m a -> [Item (RangeL n m a)]

Eq a => Eq (RangeL n m a)

Defined in Data.List.Range.RangeL

Methods

(==) :: RangeL n m a -> RangeL n m a -> Bool

(/=) :: RangeL n m a -> RangeL n m a -> Bool

Ord a => Ord (RangeL n m a)

Defined in Data.List.Range.RangeL

Methods

compare :: RangeL n m a -> RangeL n m a -> Ordering

(<) :: RangeL n m a -> RangeL n m a -> Bool

(<=) :: RangeL n m a -> RangeL n m a -> Bool

(>) :: RangeL n m a -> RangeL n m a -> Bool

(>=) :: RangeL n m a -> RangeL n m a -> Bool

max :: RangeL n m a -> RangeL n m a -> RangeL n m a

min :: RangeL n m a -> RangeL n m a -> RangeL n m a

Show a => Show (RangeL n m a)

Defined in Data.List.Range.RangeL

Methods

showsPrec :: Int -> RangeL n m a -> ShowS

show :: RangeL n m a -> String

showList :: [RangeL n m a] -> ShowS

Unfoldr 0 n m => IsString (RangeL n m Char)

Defined in Data.List.Range.RangeL

Methods

fromString :: String -> RangeL n m Char

type Item (RangeL n m a)

Defined in Data.List.Range.RangeL

type Item (RangeL n m a) = a

AddL

class AddL n m v w

Minimal complete definition

(++.)

Instances

(1 <= n, AddL (n - 1) (m - 1) v w) => AddL n m v w

Defined in Data.List.Range.RangeL

Methods

(++.) :: RangeL n m a -> RangeL v w a -> RangeL (n + v) (m + w) a

(PushL v ((m + w) - 1), AddL 0 (m - 1) v w, LoosenLMax v w (m + w)) => AddL 0 m v w

Defined in Data.List.Range.RangeL

Methods

(++.) :: RangeL 0 m a -> RangeL v w a -> RangeL (0 + v) (m + w) a

AddL 0 0 v w

Defined in Data.List.Range.RangeL

Methods

(++.) :: RangeL 0 0 a -> RangeL v w a -> RangeL (0 + v) (0 + w) a

(++.) :: AddL n m v w => RangeL n m a -> RangeL v w a -> RangeL (n + v) (m + w) a infixr 5

To concatenate two lists whose types are RangeL n m a and RangeL v w a.

>>> :set -XDataKinds
>>> sampleAddL1 = 'f' :. 'o' :. 'o' :.. NilL :: RangeL 2 5 Char
>>> sampleAddL2 = 'b' :. 'a' :.. 'r' :.. NilL :: RangeL 1 6 Char
>>> sampleAddL1 ++. sampleAddL2
'f' :. ('o' :. ('o' :. ('b' :.. ('a' :.. ('r' :.. NilL)))))
>>> :type sampleAddL1 ++. sampleAddL2
sampleAddL1 ++. sampleAddL2 :: RangeL 3 11 Char

Unfoldr

class

class Unfoldr n v w

Minimal complete definition

unfoldrMRangeWithBase, unfoldrMRangeMaybeWithBase

Instances

(1 <= n, 1 <= v, Unfoldr (n - 1) (v - 1) (w - 1)) => Unfoldr n v w

Defined in Data.List.Range.RangeL

Methods

unfoldrMRangeWithBase :: Monad m => RangeL n w a -> m Bool -> m a -> m (RangeL v w a)

unfoldrMRangeMaybeWithBase :: Monad m => RangeL n w a -> m Bool -> m a -> m (Maybe (RangeL v w a))

(1 <= v, 1 <= w, Unfoldr 0 (v - 1) (w - 1)) => Unfoldr 0 v w

Defined in Data.List.Range.RangeL

Methods

unfoldrMRangeWithBase :: Monad m => RangeL 0 w a -> m Bool -> m a -> m (RangeL v w a)

unfoldrMRangeMaybeWithBase :: Monad m => RangeL 0 w a -> m Bool -> m a -> m (Maybe (RangeL v w a))

(1 <= w, Unfoldr 0 0 (w - 1)) => Unfoldr 0 0 w

Defined in Data.List.Range.RangeL

Methods

unfoldrMRangeWithBase :: Monad m => RangeL 0 w a -> m Bool -> m a -> m (RangeL 0 w a)

unfoldrMRangeMaybeWithBase :: Monad m => RangeL 0 w a -> m Bool -> m a -> m (Maybe (RangeL 0 w a))

Unfoldr 0 0 0

Defined in Data.List.Range.RangeL

Methods

unfoldrMRangeWithBase :: Monad m => RangeL 0 0 a -> m Bool -> m a -> m (RangeL 0 0 a)

unfoldrMRangeMaybeWithBase :: Monad m => RangeL 0 0 a -> m Bool -> m a -> m (Maybe (RangeL 0 0 a))

without monad

repeatL :: (0 <= n, Unfoldr 0 n n) => a -> LengthL n a

To repeat a value of type a to construct a list of type LengthL n a.

>>> :set -XDataKinds
>>> repeatL 'c' :: LengthL 5 Char
'c' :. ('c' :. ('c' :. ('c' :. ('c' :. NilL))))

fillL :: Unfoldr n m m => RangeL n m a -> a -> LengthL m a

To fill a list of type LengthL n a with a value of type a.

>>> :set -XDataKinds
>>> fillL ('a' :. 'b' :.. NilL) 'c' :: LengthL 5 Char
'a' :. ('b' :. ('c' :. ('c' :. ('c' :. NilL))))

unfoldr :: (0 <= n, Unfoldr 0 n n) => (s -> (a, s)) -> s -> LengthL n a

To evaluate function repeatedly to construct a list of type LengthL n a. The function recieve a state and return an element value and a new state.

>>> :set -XDataKinds
>>> unfoldr (\n -> (2 * n, n + 1)) 0 :: LengthL 5 Integer
0 :. (2 :. (4 :. (6 :. (8 :. NilL))))

unfoldrWithBase :: Unfoldr n m m => RangeL n m a -> (s -> (a, s)) -> s -> LengthL m a

It is like unfoldr. But it has already prepared values.

>>> :set -XDataKinds
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Integer
>>> unfoldrWithBase xs (\n -> (2 * n, n + 1)) 0 :: LengthL 5 Integer
123 :. (456 :. (0 :. (2 :. (4 :. NilL))))

with monad

unfoldrM :: (Monad m, 0 <= n, Unfoldr 0 n n) => m a -> m (LengthL n a)

It is like unfoldr. But it use a monad as an argument instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n <$ writeIORef r (n +1)
>>> unfoldrM count :: IO (LengthL 5 Integer)
1 :. (2 :. (3 :. (4 :. (5 :. NilL))))

unfoldrMWithBase :: (Monad m, Unfoldr n w w) => RangeL n w a -> m a -> m (LengthL w a)

It is like unfoldrM. But it has already prepared values.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n <$ writeIORef r (n + 1)
>>> unfoldrMWithBase (123 :. 456 :.. NilL) count :: IO (LengthL 5 Integer)
123 :. (456 :. (1 :. (2 :. (3 :. NilL))))

ZipL

class ZipL n m v w

Minimal complete definition

zipWithML

Instances

(1 <= n, 1 <= v, n <= w, m <= v, ZipL (n - 1) (m - 1) (v - 1) (w - 1)) => ZipL n m v w

Defined in Data.List.Range.RangeL

Methods

zipWithML :: Monad q => (a -> b -> q c) -> RangeL n m a -> RangeL v w b -> q (RangeL n m c, RangeL (v - m) (w - n) b)

(1 <= v, m <= v, LoosenLMin v w (v - m), LoosenLMax (v - m) (w - 1) w, ZipL 0 (m - 1) (v - 1) (w - 1)) => ZipL 0 m v w

Defined in Data.List.Range.RangeL

Methods

zipWithML :: Monad q => (a -> b -> q c) -> RangeL 0 m a -> RangeL v w b -> q (RangeL 0 m c, RangeL (v - m) (w - 0) b)

ZipL 0 0 v w

Defined in Data.List.Range.RangeL

Methods

zipWithML :: Monad q => (a -> b -> q c) -> RangeL 0 0 a -> RangeL v w b -> q (RangeL 0 0 c, RangeL (v - 0) (w - 0) b)

zipL :: ZipL n m v w => RangeL n m a -> RangeL v w b -> (RangeL n m (a, b), RangeL (v - m) (w - n) b)

To recieve two lists and return a tuple list and rest of the second list. The first list must be shorter or equal than the second list.

>>> :set -XDataKinds
>>> sampleZipL1 = 1 :. 2 :. 3 :.. NilL :: RangeL 2 4 Integer
>>> sampleZipL2 = 7 :. 6 :. 5 :. 4 :. 3 :. 2 :.. NilL :: RangeL 5 7 Integer
>>> zipL sampleZipL1 sampleZipL2
((1,7) :. ((2,6) :. ((3,5) :.. NilL)),4 :. (3 :.. (2 :.. NilL)))
>>> :type zipL sampleZipL1 sampleZipL2
zipL sampleZipL1 sampleZipL2
  :: (RangeL 2 4 (Integer, Integer), RangeL 1 5 Integer)

zipWithL :: ZipL n m v w => (a -> b -> c) -> RangeL n m a -> RangeL v w b -> (RangeL n m c, RangeL (v - m) (w - n) b)

It is like zipL. But it evaluate a function to make values instead of put together in tuples.

>>> :set -XDataKinds
>>> sampleZipWithL1 = 1 :. 2 :. 3 :.. NilL :: RangeL 2 4 Integer
>>> sampleZipWithL2 = 7 :. 6 :. 5 :. 4 :. 3 :. 2 :.. NilL :: RangeL 5 7 Integer
>>> zipWithL (+) sampleZipWithL1 sampleZipWithL2
(8 :. (8 :. (8 :.. NilL)),4 :. (3 :.. (2 :.. NilL)))
>>> :type zipWithL (+) sampleZipWithL1 sampleZipWithL2
zipWithL (+) sampleZipWithL1 sampleZipWithL2
  :: (RangeL 2 4 Integer, RangeL 1 5 Integer)

zipWithML :: (ZipL n m v w, Monad q) => (a -> b -> q c) -> RangeL n m a -> RangeL v w b -> q (RangeL n m c, RangeL (v - m) (w - n) b)

It is like zipWithL. But it use a function which return a monad instead of a simple value.

>>> :set -XDataKinds -fno-warn-tabs
>>> ns = 1 :. 2 :. 3 :.. NilL :: RangeL 2 4 Int
>>> :{
	cs :: RangeL 5 7 Char
	cs = 'a' :. 'b' :. 'c' :. 'd' :. 'e' :. 'f' :.. NilL
:}

>>> zipWithML (\n -> putStrLn . replicate n) ns cs
a
bb
ccc
(() :. (() :. (() :.. NilL)),'d' :. ('e' :.. ('f' :.. NilL)))

ListToLengthL

class ListToLengthL n

Minimal complete definition

splitL

Instances

(1 <= n, 1 <= (n - 1), 0 <= (n - 1), ListToLengthL (n - 1)) => ListToLengthL n

Defined in Data.List.Length.LengthL

Methods

splitL :: [a] -> Either (RangeL 0 (n - 1) a) (LengthL n a, [a])

ListToLengthL 1

Defined in Data.List.Length.LengthL

Methods

splitL :: [a] -> Either (RangeL 0 (1 - 1) a) (LengthL 1 a, [a])

splitL :: ListToLengthL n => [a] -> Either (RangeL 0 (n - 1) a) (LengthL n a, [a])

To take a lengthed list from a list. If an original list has not enough elements, then it return a left value.

>>> :set -XTypeApplications -XDataKinds
>>> splitL @4 "Hi!"
Left ('H' :.. ('i' :.. ('!' :.. NilL)))
>>> splitL @4 "Hello!"
Right ('H' :. ('e' :. ('l' :. ('l' :. NilL))),"o!")

chunksL :: ListToLengthL n => [a] -> ([LengthL n a], RangeL 0 (n - 1) a)

To separate a list to multiple lengthed lists. It return separeted lengthed lists and a not enough length fragment.

>>> :set -XTypeApplications -XDataKinds
>>> chunksL @3 "foo bar"
(['f' :. ('o' :. ('o' :. NilL)),' ' :. ('b' :. ('a' :. NilL))],'r' :.. NilL)

chunksL' :: (Unfoldr 0 n n, LoosenLMax 0 (n - 1) n, ListToLengthL n) => a -> [a] -> [LengthL n a]

It is like chunksL. But if there is a not enough length fragment, then it fill with a default value.

>>> :set -XTypeApplications -XDataKinds
>>> print `mapM_` chunksL' @3 '@' "foo bar"
'f' :. ('o' :. ('o' :. NilL))
' ' :. ('b' :. ('a' :. NilL))
'r' :. ('@' :. ('@' :. NilL))

LENGTHED LIST RIGHT

Type

type LengthR n = RangeR n n

LengthR n a is a list which have just n members of type a. You can push and pop an element from right.

>>> :set -XDataKinds
>>> sampleLengthR = NilR :+ 'h' :+ 'e' :+ 'l' :+ 'l' :+ 'o' :: LengthR 5 Char

data RangeR :: Nat -> Nat -> Type -> Type where

RangeR n m a is a list of type a values whose element number is at minimum n, and at maximum m. You can push and pop an element from right.

>>> :set -XDataKinds
>>> sampleRangeR = NilR :++ 'h' :++ 'e' :+ 'l' :+ 'l' :+ 'o' :: RangeR 3 8 Char

Constructors

NilR :: 0 <= m => RangeR 0 m a

(:+) :: (1 <= n, 1 <= m) => RangeR (n - 1) (m - 1) a -> a -> RangeR n m a infixl 6

Instances

(1 <= n, Applicative (RangeR n n), Monad (RangeR (n - 1) (n - 1))) => Monad (RangeR n n)

Defined in Data.List.Range.RangeR

Methods

(>>=) :: RangeR n n a -> (a -> RangeR n n b) -> RangeR n n b

(>>) :: RangeR n n a -> RangeR n n b -> RangeR n n b

return :: a -> RangeR n n a

Applicative (RangeR 0 0) => Monad (RangeR 0 0)

Defined in Data.List.Range.RangeR

Methods

(>>=) :: RangeR 0 0 a -> (a -> RangeR 0 0 b) -> RangeR 0 0 b

(>>) :: RangeR 0 0 a -> RangeR 0 0 b -> RangeR 0 0 b

return :: a -> RangeR 0 0 a

(1 <= n, Functor (RangeR (n - 1) (m - 1))) => Functor (RangeR n m)

Defined in Data.List.Range.RangeR

Methods

fmap :: (a -> b) -> RangeR n m a -> RangeR n m b

(<$) :: a -> RangeR n m b -> RangeR n m a

Functor (RangeR 0 (m - 1)) => Functor (RangeR 0 m)

Defined in Data.List.Range.RangeR

Methods

fmap :: (a -> b) -> RangeR 0 m a -> RangeR 0 m b

(<$) :: a -> RangeR 0 m b -> RangeR 0 m a

Functor (RangeR 0 0)

Defined in Data.List.Range.RangeR

Methods

fmap :: (a -> b) -> RangeR 0 0 a -> RangeR 0 0 b

(<$) :: a -> RangeR 0 0 b -> RangeR 0 0 a

(1 <= n, Functor (RangeR n m), Applicative (RangeR (n - 1) (m - 1)), Unfoldl 0 n m) => Applicative (RangeR n m)

Defined in Data.List.Range.RangeR

Methods

pure :: a -> RangeR n m a

(<*>) :: RangeR n m (a -> b) -> RangeR n m a -> RangeR n m b

liftA2 :: (a -> b -> c) -> RangeR n m a -> RangeR n m b -> RangeR n m c

(*>) :: RangeR n m a -> RangeR n m b -> RangeR n m b

(<*) :: RangeR n m a -> RangeR n m b -> RangeR n m a

(1 <= n, Functor (RangeR n n), Applicative (RangeR (n - 1) (n - 1)), Unfoldl 0 n n) => Applicative (RangeR n n)

Defined in Data.List.Range.RangeR

Methods

pure :: a -> RangeR n n a

(<*>) :: RangeR n n (a -> b) -> RangeR n n a -> RangeR n n b

liftA2 :: (a -> b -> c) -> RangeR n n a -> RangeR n n b -> RangeR n n c

(*>) :: RangeR n n a -> RangeR n n b -> RangeR n n b

(<*) :: RangeR n n a -> RangeR n n b -> RangeR n n a

(Functor (RangeR 0 m), Applicative (RangeR 0 (m - 1)), Unfoldl 0 0 m) => Applicative (RangeR 0 m)

Defined in Data.List.Range.RangeR

Methods

pure :: a -> RangeR 0 m a

(<*>) :: RangeR 0 m (a -> b) -> RangeR 0 m a -> RangeR 0 m b

liftA2 :: (a -> b -> c) -> RangeR 0 m a -> RangeR 0 m b -> RangeR 0 m c

(*>) :: RangeR 0 m a -> RangeR 0 m b -> RangeR 0 m b

(<*) :: RangeR 0 m a -> RangeR 0 m b -> RangeR 0 m a

Applicative (RangeR 0 0)

Defined in Data.List.Range.RangeR

Methods

pure :: a -> RangeR 0 0 a

(<*>) :: RangeR 0 0 (a -> b) -> RangeR 0 0 a -> RangeR 0 0 b

liftA2 :: (a -> b -> c) -> RangeR 0 0 a -> RangeR 0 0 b -> RangeR 0 0 c

(*>) :: RangeR 0 0 a -> RangeR 0 0 b -> RangeR 0 0 b

(<*) :: RangeR 0 0 a -> RangeR 0 0 b -> RangeR 0 0 a

(1 <= n, Foldable (RangeR (n - 1) (m - 1))) => Foldable (RangeR n m)

Defined in Data.List.Range.RangeR

Methods

fold :: Monoid m0 => RangeR n m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> RangeR n m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> RangeR n m a -> m0

foldr :: (a -> b -> b) -> b -> RangeR n m a -> b

foldr' :: (a -> b -> b) -> b -> RangeR n m a -> b

foldl :: (b -> a -> b) -> b -> RangeR n m a -> b

foldl' :: (b -> a -> b) -> b -> RangeR n m a -> b

foldr1 :: (a -> a -> a) -> RangeR n m a -> a

foldl1 :: (a -> a -> a) -> RangeR n m a -> a

toList :: RangeR n m a -> [a]

null :: RangeR n m a -> Bool

length :: RangeR n m a -> Int

elem :: Eq a => a -> RangeR n m a -> Bool

maximum :: Ord a => RangeR n m a -> a

minimum :: Ord a => RangeR n m a -> a

sum :: Num a => RangeR n m a -> a

product :: Num a => RangeR n m a -> a

Foldable (RangeR 0 (m - 1)) => Foldable (RangeR 0 m)

Defined in Data.List.Range.RangeR

Methods

fold :: Monoid m0 => RangeR 0 m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> RangeR 0 m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> RangeR 0 m a -> m0

foldr :: (a -> b -> b) -> b -> RangeR 0 m a -> b

foldr' :: (a -> b -> b) -> b -> RangeR 0 m a -> b

foldl :: (b -> a -> b) -> b -> RangeR 0 m a -> b

foldl' :: (b -> a -> b) -> b -> RangeR 0 m a -> b

foldr1 :: (a -> a -> a) -> RangeR 0 m a -> a

foldl1 :: (a -> a -> a) -> RangeR 0 m a -> a

toList :: RangeR 0 m a -> [a]

null :: RangeR 0 m a -> Bool

length :: RangeR 0 m a -> Int

elem :: Eq a => a -> RangeR 0 m a -> Bool

maximum :: Ord a => RangeR 0 m a -> a

minimum :: Ord a => RangeR 0 m a -> a

sum :: Num a => RangeR 0 m a -> a

product :: Num a => RangeR 0 m a -> a

Foldable (RangeR 0 0)

Defined in Data.List.Range.RangeR

Methods

fold :: Monoid m => RangeR 0 0 m -> m

foldMap :: Monoid m => (a -> m) -> RangeR 0 0 a -> m

foldMap' :: Monoid m => (a -> m) -> RangeR 0 0 a -> m

foldr :: (a -> b -> b) -> b -> RangeR 0 0 a -> b

foldr' :: (a -> b -> b) -> b -> RangeR 0 0 a -> b

foldl :: (b -> a -> b) -> b -> RangeR 0 0 a -> b

foldl' :: (b -> a -> b) -> b -> RangeR 0 0 a -> b

foldr1 :: (a -> a -> a) -> RangeR 0 0 a -> a

foldl1 :: (a -> a -> a) -> RangeR 0 0 a -> a

toList :: RangeR 0 0 a -> [a]

null :: RangeR 0 0 a -> Bool

length :: RangeR 0 0 a -> Int

elem :: Eq a => a -> RangeR 0 0 a -> Bool

maximum :: Ord a => RangeR 0 0 a -> a

minimum :: Ord a => RangeR 0 0 a -> a

sum :: Num a => RangeR 0 0 a -> a

product :: Num a => RangeR 0 0 a -> a

(1 <= n, Traversable (RangeR (n - 1) (m - 1))) => Traversable (RangeR n m)

Defined in Data.List.Range.RangeR

Methods

traverse :: Applicative f => (a -> f b) -> RangeR n m a -> f (RangeR n m b)

sequenceA :: Applicative f => RangeR n m (f a) -> f (RangeR n m a)

mapM :: Monad m0 => (a -> m0 b) -> RangeR n m a -> m0 (RangeR n m b)

sequence :: Monad m0 => RangeR n m (m0 a) -> m0 (RangeR n m a)

Traversable (RangeR 0 (m - 1)) => Traversable (RangeR 0 m)

Defined in Data.List.Range.RangeR

Methods

traverse :: Applicative f => (a -> f b) -> RangeR 0 m a -> f (RangeR 0 m b)

sequenceA :: Applicative f => RangeR 0 m (f a) -> f (RangeR 0 m a)

mapM :: Monad m0 => (a -> m0 b) -> RangeR 0 m a -> m0 (RangeR 0 m b)

sequence :: Monad m0 => RangeR 0 m (m0 a) -> m0 (RangeR 0 m a)

Traversable (RangeR 0 0)

Defined in Data.List.Range.RangeR

Methods

traverse :: Applicative f => (a -> f b) -> RangeR 0 0 a -> f (RangeR 0 0 b)

sequenceA :: Applicative f => RangeR 0 0 (f a) -> f (RangeR 0 0 a)

mapM :: Monad m => (a -> m b) -> RangeR 0 0 a -> m (RangeR 0 0 b)

sequence :: Monad m => RangeR 0 0 (m a) -> m (RangeR 0 0 a)

(Foldable (RangeR n m), Unfoldl 0 n m) => IsList (RangeR n m a)

Defined in Data.List.Range.RangeR

Associated Types

type Item (RangeR n m a)

Methods

fromList :: [Item (RangeR n m a)] -> RangeR n m a

fromListN :: Int -> [Item (RangeR n m a)] -> RangeR n m a

toList :: RangeR n m a -> [Item (RangeR n m a)]

Eq a => Eq (RangeR n m a)

Defined in Data.List.Range.RangeR

Methods

(==) :: RangeR n m a -> RangeR n m a -> Bool

(/=) :: RangeR n m a -> RangeR n m a -> Bool

Ord a => Ord (RangeR n m a)

Defined in Data.List.Range.RangeR

Methods

compare :: RangeR n m a -> RangeR n m a -> Ordering

(<) :: RangeR n m a -> RangeR n m a -> Bool

(<=) :: RangeR n m a -> RangeR n m a -> Bool

(>) :: RangeR n m a -> RangeR n m a -> Bool

(>=) :: RangeR n m a -> RangeR n m a -> Bool

max :: RangeR n m a -> RangeR n m a -> RangeR n m a

min :: RangeR n m a -> RangeR n m a -> RangeR n m a

Show a => Show (RangeR n m a)

Defined in Data.List.Range.RangeR

Methods

showsPrec :: Int -> RangeR n m a -> ShowS

show :: RangeR n m a -> String

showList :: [RangeR n m a] -> ShowS

Unfoldl 0 n m => IsString (RangeR n m Char)

Defined in Data.List.Range.RangeR

Methods

fromString :: String -> RangeR n m Char

type Item (RangeR n m a)

Defined in Data.List.Range.RangeR

type Item (RangeR n m a) = a

AddR

class AddR n m v w

Minimal complete definition

(+++)

Instances

(1 <= v, AddR n m (v - 1) (w - 1)) => AddR n m v w

Defined in Data.List.Range.RangeR

Methods

(+++) :: RangeR n m a -> RangeR v w a -> RangeR (n + v) (m + w) a

(PushR n ((m + w) - 1), AddR n m 0 (w - 1), LoosenRMax n m (m + w)) => AddR n m 0 w

Defined in Data.List.Range.RangeR

Methods

(+++) :: RangeR n m a -> RangeR 0 w a -> RangeR (n + 0) (m + w) a

AddR n m 0 0

Defined in Data.List.Range.RangeR

Methods

(+++) :: RangeR n m a -> RangeR 0 0 a -> RangeR (n + 0) (m + 0) a

(+++) :: AddR n m v w => RangeR n m a -> RangeR v w a -> RangeR (n + v) (m + w) a infixl 5

To concatenate two lists whose types are RangeR n m a and RangeR v w a.

>>> :set -XDataKinds
>>> sampleRangeR1 = NilR :++ 'f' :+ 'o' :+ 'o' :: RangeR 2 5 Char
>>> sampleRangeR2 = NilR :++ 'b' :++ 'a' :+ 'r' :: RangeR 1 6 Char
>>> sampleRangeR1 +++ sampleRangeR2
(((((NilR :++ 'f') :++ 'o') :++ 'o') :+ 'b') :+ 'a') :+ 'r'
>>> :type sampleRangeR1 +++ sampleRangeR2
sampleRangeR1 +++ sampleRangeR2 :: RangeR 3 11 Char

Unfoldl

class

class Unfoldl n v w

Minimal complete definition

unfoldlMRangeWithBase, unfoldlMRangeMaybeWithBase

Instances

(1 <= n, 1 <= v, Unfoldl (n - 1) (v - 1) (w - 1)) => Unfoldl n v w

Defined in Data.List.Range.RangeR

Methods

unfoldlMRangeWithBase :: Monad m => m Bool -> m a -> RangeR n w a -> m (RangeR v w a)

unfoldlMRangeMaybeWithBase :: Monad m => m Bool -> m a -> RangeR n w a -> m (Maybe (RangeR v w a))

(1 <= v, 1 <= w, Unfoldl 0 (v - 1) (w - 1)) => Unfoldl 0 v w

Defined in Data.List.Range.RangeR

Methods

unfoldlMRangeWithBase :: Monad m => m Bool -> m a -> RangeR 0 w a -> m (RangeR v w a)

unfoldlMRangeMaybeWithBase :: Monad m => m Bool -> m a -> RangeR 0 w a -> m (Maybe (RangeR v w a))

(1 <= w, Unfoldl 0 0 (w - 1)) => Unfoldl 0 0 w

Defined in Data.List.Range.RangeR

Methods

unfoldlMRangeWithBase :: Monad m => m Bool -> m a -> RangeR 0 w a -> m (RangeR 0 w a)

unfoldlMRangeMaybeWithBase :: Monad m => m Bool -> m a -> RangeR 0 w a -> m (Maybe (RangeR 0 w a))

Unfoldl 0 0 0

Defined in Data.List.Range.RangeR

Methods

unfoldlMRangeWithBase :: Monad m => m Bool -> m a -> RangeR 0 0 a -> m (RangeR 0 0 a)

unfoldlMRangeMaybeWithBase :: Monad m => m Bool -> m a -> RangeR 0 0 a -> m (Maybe (RangeR 0 0 a))

without monad

repeatR :: (0 <= n, Unfoldl 0 n n) => a -> LengthR n a

To repeat a value of type a to construct a list of type LengthR n a.

>>> :set -XDataKinds
>>> repeatR 'c' :: LengthR 5 Char
((((NilR :+ 'c') :+ 'c') :+ 'c') :+ 'c') :+ 'c'

fillR :: Unfoldl n m m => a -> RangeR n m a -> LengthR m a

To fill a list of type LengthR n a with a default value.

>>> :set -XDataKinds
>>> fillR 'c' (NilR :++ 'a' :+ 'b') :: LengthR 5 Char
((((NilR :+ 'c') :+ 'c') :+ 'c') :+ 'a') :+ 'b'

unfoldl :: (0 <= n, Unfoldl 0 n n) => (s -> (s, a)) -> s -> LengthR n a

To eveluate function repeatedly to construct a list of type LengthR n a. The function recieve a state and return a new state and an element value.

>>> :set -XDataKinds
>>> unfoldl (\n -> (n + 1, 2 * n)) 0 :: LengthR 5 Integer
((((NilR :+ 8) :+ 6) :+ 4) :+ 2) :+ 0

unfoldlWithBase :: Unfoldl n m m => (s -> (s, a)) -> s -> RangeR n m a -> LengthR m a

It is like unfoldl. But it has already prepared values.

>>> :set -XDataKinds
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Integer
>>> unfoldlWithBase (\n -> (n + 1, 2 * n)) 0 xs :: LengthR 5 Integer
((((NilR :+ 4) :+ 2) :+ 0) :+ 123) :+ 456

with monad

unfoldlM :: (Monad m, 0 <= n, Unfoldl 0 n n) => m a -> m (LengthR n a)

It is like unfoldl. But it use monad as an argument instead of function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n <$ writeIORef r (n + 1)
>>> unfoldlM count :: IO (LengthR 5 Integer)
((((NilR :+ 5) :+ 4) :+ 3) :+ 2) :+ 1

unfoldlMWithBase :: (Monad m, Unfoldl n w w) => m a -> RangeR n w a -> m (LengthR w a)

It is like unfoldlM. But it has already prepared values.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n <$ writeIORef r (n + 1)
>>> unfoldlMWithBase count (NilR :++ 123 :+ 456) :: IO (LengthR 5 Integer)
((((NilR :+ 3) :+ 2) :+ 1) :+ 123) :+ 456

ZipR

class ZipR n m v w

Minimal complete definition

zipWithMR

Instances

(1 <= n, 1 <= v, v <= m, w <= n, ZipR (n - 1) (m - 1) (v - 1) (w - 1)) => ZipR n m v w

Defined in Data.List.Range.RangeR

Methods

zipWithMR :: Monad q => (a -> b -> q c) -> RangeR n m a -> RangeR v w b -> q (RangeR (n - w) (m - v) a, RangeR v w c)

(1 <= n, 1 <= m, w <= n, LoosenRMin n m (n - w), LoosenRMax (n - w) (m - 1) m, ZipR (n - 1) (m - 1) 0 (w - 1)) => ZipR n m 0 w

Defined in Data.List.Range.RangeR

Methods

zipWithMR :: Monad q => (a -> b -> q c) -> RangeR n m a -> RangeR 0 w b -> q (RangeR (n - w) (m - 0) a, RangeR 0 w c)

ZipR n m 0 0

Defined in Data.List.Range.RangeR

Methods

zipWithMR :: Monad q => (a -> b -> q c) -> RangeR n m a -> RangeR 0 0 b -> q (RangeR (n - 0) (m - 0) a, RangeR 0 0 c)

zipR :: ZipR n m v w => RangeR n m a -> RangeR v w b -> (RangeR (n - w) (m - v) a, RangeR v w (a, b))

To recieve two lists and return a tuple list and rest of the first list. The second list must be shorter or equal than the first list.

>>> :set -XDataKinds
>>> sampleZipR1 = NilR :++ 1 :+ 2 :+ 3 :+ 4 :+ 5 :+ 6 :: RangeR 5 7 Integer
>>> sampleZipR2 = NilR :++ 3 :+ 2 :+ 1 :: RangeR 2 4 Integer
>>> zipR sampleZipR1 sampleZipR2
(((NilR :++ 1) :++ 2) :+ 3,((NilR :++ (4,3)) :+ (5,2)) :+ (6,1))
>>> :type zipR sampleZipR1 sampleZipR2
zipR sampleZipR1 sampleZipR2
  :: (RangeR 1 5 Integer, RangeR 2 4 (Integer, Integer))

zipWithR :: ZipR n m v w => (a -> b -> c) -> RangeR n m a -> RangeR v w b -> (RangeR (n - w) (m - v) a, RangeR v w c)

It is like zipR. But it evaluates a function to make values instead of puts together in tuples.

>>> :set -XDataKinds
>>> sampleZipWithR1 = NilR :++ 1 :+ 2 :+ 3 :+ 4 :+ 5 :+ 6 :: RangeR 5 7 Integer
>>> sampleZipWithR2 = NilR :++ 7 :+ 6 :+ 5 :: RangeR 2 4 Integer
>>> zipWithR (+) sampleZipWithR1 sampleZipWithR2
(((NilR :++ 1) :++ 2) :+ 3,((NilR :++ 11) :+ 11) :+ 11)
>>> :type zipWithR (+) sampleZipWithR1 sampleZipWithR2
zipWithR (+) sampleZipWithR1 sampleZipWithR2
  :: (RangeR 1 5 Integer, RangeR 2 4 Integer)

zipWithMR :: (ZipR n m v w, Monad q) => (a -> b -> q c) -> RangeR n m a -> RangeR v w b -> q (RangeR (n - w) (m - v) a, RangeR v w c)

It is like zipWithR. But it uses a function which returns a monad instead of a simple value.

>>> :set -XDataKinds
>>> ns = NilR :++ 1 :+ 2 :+ 3 :+ 4 :+ 5 :+ 6 :: RangeR 5 7 Int
>>> cs = NilR :++ 'a' :+ 'b' :+ 'c' :: RangeR 2 4 Char
>>> zipWithMR (\n -> putStrLn . replicate n) ns cs
cccccc
bbbbb
aaaa
(((NilR :++ 1) :++ 2) :+ 3,((NilR :++ ()) :+ ()) :+ ())

ListToLengthR

class ListToLengthR n

Minimal complete definition

listToLengthR

Instances

(1 <= n, 1 <= (n - 1), 0 <= (n - 1), ListToLengthR (n - 1)) => ListToLengthR n

Defined in Data.List.Length.LengthR

Methods

listToLengthR :: [a] -> Either (RangeR 0 (n - 1) a) (LengthR n a, [a])

ListToLengthR 1

Defined in Data.List.Length.LengthR

Methods

listToLengthR :: [a] -> Either (RangeR 0 (1 - 1) a) (LengthR 1 a, [a])

listToLengthR :: ListToLengthR n => [a] -> Either (RangeR 0 (n - 1) a) (LengthR n a, [a])

To take a lengthed list from a list. If an original list has not enough elements, then it return a left value.

>>> :set -XTypeApplications -XDataKinds
>>> listToLengthR @4 "Hi!"
Left (((NilR :++ '!') :++ 'i') :++ 'H')
>>> listToLengthR @4 "Hello!"
Right ((((NilR :+ 'l') :+ 'l') :+ 'e') :+ 'H',"o!")

chunksR :: ListToLengthR n => [a] -> ([LengthR n a], RangeR 0 (n - 1) a)

To separate a list to multiple lengthed lists. It return separated lengthed lists and a not enough length fragment.

>>> :set -XTypeApplications -XDataKinds
>>> chunksR @3 "foo bar"
([((NilR :+ 'o') :+ 'o') :+ 'f',((NilR :+ 'a') :+ 'b') :+ ' '],NilR :++ 'r')

chunksR' :: (Unfoldl 0 n n, LoosenRMax 0 (n - 1) n, ListToLengthR n) => a -> [a] -> [LengthR n a]

It is like chunksR. But if there is a not enough length fragment, then it fill with a default value.

>>> :set -XTypeApplications -XDataKinds
>>> print `mapM_` chunksR' @3 '@' "foo bar"
((NilR :+ 'o') :+ 'o') :+ 'f'
((NilR :+ 'a') :+ 'b') :+ ' '
((NilR :+ '@') :+ '@') :+ 'r'

LEFT TO RIGHT

class LeftToRight n m v w

Minimal complete definition

(++.+)

Instances

(1 <= v, LeftToRight (n + 1) (m + 1) (v - 1) (w - 1)) => LeftToRight n m v w

Defined in Data.List.Range

Methods

(++.+) :: RangeR n m a -> RangeL v w a -> RangeR (n + v) (m + w) a

(1 <= n, PushR (n - 1) (m - 1), LoosenRMax n m (m + w), LeftToRight n (m + 1) 0 (w - 1)) => LeftToRight n m 0 w

Defined in Data.List.Range

Methods

(++.+) :: RangeR n m a -> RangeL 0 w a -> RangeR (n + 0) (m + w) a

LeftToRight n m 0 0

Defined in Data.List.Range

Methods

(++.+) :: RangeR n m a -> RangeL 0 0 a -> RangeR (n + 0) (m + 0) a

(++.+) :: LeftToRight n m v w => RangeR n m a -> RangeL v w a -> RangeR (n + v) (m + w) a infixl 5

To concatenate a right-list and a left-list and return a right-list.

>>> :set -XDataKinds
>>> sampleLeftToRight1 = NilR :++ 'f' :++ 'o' :+ 'o' :: RangeR 1 4 Char
>>> sampleLeftToRight2 = 'b' :. 'a' :. 'r' :.. NilL :: RangeL 2 3 Char
>>> sampleLeftToRight1 ++.+ sampleLeftToRight2
(((((NilR :++ 'f') :++ 'o') :++ 'o') :+ 'b') :+ 'a') :+ 'r'
>>> :type sampleLeftToRight1 ++.+ sampleLeftToRight2
sampleLeftToRight1 ++.+ sampleLeftToRight2 :: RangeR 3 7 Char

leftToRight :: forall v w a. LeftToRight 0 0 v w => RangeL v w a -> RangeR v w a

To convert a left-list to a right-list.

>>> :set -XDataKinds -fno-warn-tabs
>>> :{
	sampleLeftToRight :: RangeL 3 8 Char
	sampleLeftToRight = 'h' :. 'e' :. 'l' :. 'l' :.. 'o' :.. NilL
:}

>>> leftToRight sampleLeftToRight
((((NilR :++ 'h') :++ 'e') :+ 'l') :+ 'l') :+ 'o'

RIGHT TO LEFT

class RightToLeft n m v w

Minimal complete definition

(++..)

Instances

(1 <= n, RightToLeft (n - 1) (m - 1) (v + 1) (w + 1)) => RightToLeft n m v w

Defined in Data.List.Range

Methods

(++..) :: RangeR n m a -> RangeL v w a -> RangeL (n + v) (m + w) a

(1 <= v, PushL (v - 1) (w - 1), LoosenLMax v w (m + w), RightToLeft 0 (m - 1) v (w + 1)) => RightToLeft 0 m v w

Defined in Data.List.Range

Methods

(++..) :: RangeR 0 m a -> RangeL v w a -> RangeL (0 + v) (m + w) a

RightToLeft 0 0 v w

Defined in Data.List.Range

Methods

(++..) :: RangeR 0 0 a -> RangeL v w a -> RangeL (0 + v) (0 + w) a

(++..) :: RightToLeft n m v w => RangeR n m a -> RangeL v w a -> RangeL (n + v) (m + w) a infixr 5

To concatenate a right-list and a left-list and return a left-list.

>>> :set -XDataKinds
>>> sampleRightToLeft1 = NilR :++ 'f' :++ 'o' :+ 'o' :: RangeR 1 4 Char
>>> sampleRightToLeft2 = 'b' :. 'a' :. 'r' :.. NilL :: RangeL 2 3 Char
>>> sampleRightToLeft1 ++.. sampleRightToLeft2
'f' :. ('o' :. ('o' :. ('b' :.. ('a' :.. ('r' :.. NilL)))))

rightToLeft :: forall n m a. RightToLeft n m 0 0 => RangeR n m a -> RangeL n m a

To convert a right-list to a left-list.

>>> :set -XDataKinds
>>> :{
	sampleRightToLeft :: RangeR 3 8 Char
	sampleRightToLeft = NilR :++ 'h' :++ 'e' :+ 'l' :+ 'l' :+ 'o'
:}

>>> rightToLeft sampleRightToLeft
'h' :. ('e' :. ('l' :. ('l' :.. ('o' :.. NilL))))