Safe Haskell | None |
---|---|
Language | Haskell2010 |
Synopsis
- type LengthL n = RangeL n n
- data RangeL :: Nat -> Nat -> Type -> Type where
- class AddL n m v w
- (++.) :: AddL n m v w => RangeL n m a -> RangeL v w a -> RangeL (n + v) (m + w) a
- class Unfoldr n v w
- repeatL :: (0 <= n, Unfoldr 0 n n) => a -> LengthL n a
- fillL :: Unfoldr n m m => RangeL n m a -> a -> LengthL m a
- unfoldr :: (0 <= n, Unfoldr 0 n n) => (s -> (a, s)) -> s -> LengthL n a
- unfoldrWithBase :: Unfoldr n m m => RangeL n m a -> (s -> (a, s)) -> s -> LengthL m a
- unfoldrM :: (Monad m, 0 <= n, Unfoldr 0 n n) => m a -> m (LengthL n a)
- unfoldrMWithBase :: (Monad m, Unfoldr n w w) => RangeL n w a -> m a -> m (LengthL w a)
- class ZipL n m v w
- 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)
- 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)
- 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)
- class ListToLengthL n
- splitL :: ListToLengthL n => [a] -> Either (RangeL 0 (n - 1) a) (LengthL n a, [a])
- chunksL :: ListToLengthL n => [a] -> ([LengthL n a], RangeL 0 (n - 1) a)
- chunksL' :: (Unfoldr 0 n n, LoosenLMax 0 (n - 1) n, ListToLengthL n) => a -> [a] -> [LengthL n a]
- type LengthR n = RangeR n n
- data RangeR :: Nat -> Nat -> Type -> Type where
- class AddR n m v w
- (+++) :: AddR n m v w => RangeR n m a -> RangeR v w a -> RangeR (n + v) (m + w) a
- class Unfoldl n v w
- repeatR :: (0 <= n, Unfoldl 0 n n) => a -> LengthR n a
- fillR :: Unfoldl n m m => a -> RangeR n m a -> LengthR m a
- unfoldl :: (0 <= n, Unfoldl 0 n n) => (s -> (s, a)) -> s -> LengthR n a
- unfoldlWithBase :: Unfoldl n m m => (s -> (s, a)) -> s -> RangeR n m a -> LengthR m a
- unfoldlM :: (Monad m, 0 <= n, Unfoldl 0 n n) => m a -> m (LengthR n a)
- unfoldlMWithBase :: (Monad m, Unfoldl n w w) => m a -> RangeR n w a -> m (LengthR w a)
- class ZipR n m v w
- 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))
- 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)
- 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)
- class ListToLengthR n
- listToLengthR :: ListToLengthR n => [a] -> Either (RangeR 0 (n - 1) a) (LengthR n a, [a])
- chunksR :: ListToLengthR n => [a] -> ([LengthR n a], RangeR 0 (n - 1) a)
- chunksR' :: (Unfoldl 0 n n, LoosenRMax 0 (n - 1) n, ListToLengthR n) => a -> [a] -> [LengthR n a]
- class LeftToRight n m v w
- (++.+) :: LeftToRight n m v w => RangeR n m a -> RangeL v w a -> RangeR (n + v) (m + w) a
- leftToRight :: forall v w a. LeftToRight 0 0 v w => RangeL v w a -> RangeR v w a
- class RightToLeft n m v w
- (++..) :: RightToLeft n m v w => RangeR n m a -> RangeL v w a -> RangeL (n + v) (m + w) a
- rightToLeft :: forall n m a. RightToLeft n m 0 0 => RangeR n m a -> RangeL n m a
LENGTHED LIST LEFT
Type
type LengthL n = RangeL n n Source #
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 Source #
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
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) Source # | |
Applicative (LengthL 0) => Monad (LengthL 0) Source # | |
Applicative (LengthL 0) Source # | |
(1 <= n, Functor (RangeL (n - 1) (m - 1))) => Functor (RangeL n m) Source # | |
Functor (RangeL 0 (m - 1)) => Functor (RangeL 0 m) Source # | |
Functor (RangeL 0 0) Source # | |
(1 <= n, Functor (RangeL n m), Applicative (RangeL (n - 1) (m - 1)), Unfoldr 0 n m) => Applicative (RangeL n m) Source # | |
Defined in Data.List.Range.RangeL | |
(Functor (RangeL 0 m), Applicative (RangeL 0 (m - 1)), Unfoldr 0 0 m) => Applicative (RangeL 0 m) Source # | |
Defined in Data.List.Range.RangeL | |
(1 <= n, Foldable (RangeL (n - 1) (m - 1))) => Foldable (RangeL n m) Source # | |
Defined in Data.List.Range.RangeL 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 # | |
Foldable (RangeL 0 (m - 1)) => Foldable (RangeL 0 m) Source # | |
Defined in Data.List.Range.RangeL 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 # | |
Foldable (RangeL 0 0) Source # | |
Defined in Data.List.Range.RangeL 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 # | |
(1 <= n, Traversable (RangeL (n - 1) (m - 1))) => Traversable (RangeL n m) Source # | |
Defined in Data.List.Range.RangeL | |
Traversable (RangeL 0 (m - 1)) => Traversable (RangeL 0 m) Source # | |
Defined in Data.List.Range.RangeL | |
Traversable (RangeL 0 0) Source # | |
Defined in Data.List.Range.RangeL | |
(Foldable (RangeL n m), Unfoldr 0 n m) => IsList (RangeL n m a) Source # | |
Show a => Show (RangeL n m a) Source # | |
Unfoldr 0 n m => IsString (RangeL n m Char) Source # | |
Defined in Data.List.Range.RangeL fromString :: String -> RangeL n m Char # | |
type Item (RangeL n m a) Source # | |
Defined in Data.List.Range.RangeL |
AddL
(++.) :: AddL n m v w => RangeL n m a -> RangeL v w a -> RangeL (n + v) (m + w) a infixr 5 Source #
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
without monad
repeatL :: (0 <= n, Unfoldr 0 n n) => a -> LengthL n a Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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
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) Source #
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) Source #
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) Source #
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 Source #
Instances
(1 <= n, 1 <= (n - 1), 0 <= (n - 1), ListToLengthL (n - 1)) => ListToLengthL n Source # | |
ListToLengthL 1 Source # | |
splitL :: ListToLengthL n => [a] -> Either (RangeL 0 (n - 1) a) (LengthL n a, [a]) Source #
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) Source #
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] Source #
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 Source #
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 Source #
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
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) Source # | |
Applicative (RangeR 0 0) => Monad (RangeR 0 0) Source # | |
(1 <= n, Functor (RangeR (n - 1) (m - 1))) => Functor (RangeR n m) Source # | |
Functor (RangeR 0 (m - 1)) => Functor (RangeR 0 m) Source # | |
Functor (RangeR 0 0) Source # | |
(1 <= n, Functor (RangeR n m), Applicative (RangeR (n - 1) (m - 1)), Unfoldl 0 n m) => Applicative (RangeR n m) Source # | |
Defined in Data.List.Range.RangeR | |
(1 <= n, Functor (RangeR n n), Applicative (RangeR (n - 1) (n - 1)), Unfoldl 0 n n) => Applicative (RangeR n n) Source # | |
Defined in Data.List.Range.RangeR | |
(Functor (RangeR 0 m), Applicative (RangeR 0 (m - 1)), Unfoldl 0 0 m) => Applicative (RangeR 0 m) Source # | |
Defined in Data.List.Range.RangeR | |
Applicative (RangeR 0 0) Source # | |
Defined in Data.List.Range.RangeR | |
(1 <= n, Foldable (RangeR (n - 1) (m - 1))) => Foldable (RangeR n m) Source # | |
Defined in Data.List.Range.RangeR 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 # | |
Foldable (RangeR 0 (m - 1)) => Foldable (RangeR 0 m) Source # | |
Defined in Data.List.Range.RangeR 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 # | |
Foldable (RangeR 0 0) Source # | |
Defined in Data.List.Range.RangeR 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 # | |
(1 <= n, Traversable (RangeR (n - 1) (m - 1))) => Traversable (RangeR n m) Source # | |
Defined in Data.List.Range.RangeR | |
Traversable (RangeR 0 (m - 1)) => Traversable (RangeR 0 m) Source # | |
Defined in Data.List.Range.RangeR | |
Traversable (RangeR 0 0) Source # | |
Defined in Data.List.Range.RangeR | |
(Foldable (RangeR n m), Unfoldl 0 n m) => IsList (RangeR n m a) Source # | |
Show a => Show (RangeR n m a) Source # | |
Unfoldl 0 n m => IsString (RangeR n m Char) Source # | |
Defined in Data.List.Range.RangeR fromString :: String -> RangeR n m Char # | |
type Item (RangeR n m a) Source # | |
Defined in Data.List.Range.RangeR |
AddR
(+++) :: AddR n m v w => RangeR n m a -> RangeR v w a -> RangeR (n + v) (m + w) a infixl 5 Source #
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
without monad
repeatR :: (0 <= n, Unfoldl 0 n n) => a -> LengthR n a Source #
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 Source #
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 Source #
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 Source #
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) Source #
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) Source #
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
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)) Source #
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) Source #
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) Source #
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 Source #
Instances
(1 <= n, 1 <= (n - 1), 0 <= (n - 1), ListToLengthR (n - 1)) => ListToLengthR n Source # | |
Defined in Data.List.Length.LengthR | |
ListToLengthR 1 Source # | |
Defined in Data.List.Length.LengthR |
listToLengthR :: ListToLengthR n => [a] -> Either (RangeR 0 (n - 1) a) (LengthR n a, [a]) Source #
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) Source #
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] Source #
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 Source #
Instances
(1 <= v, LeftToRight (n + 1) (m + 1) (v - 1) (w - 1)) => LeftToRight n m v w Source # | |
(1 <= n, PushR (n - 1) (m - 1), LoosenRMax n m (m + w), LeftToRight n (m + 1) 0 (w - 1)) => LeftToRight n m 0 w Source # | |
LeftToRight n m 0 0 Source # | |
(++.+) :: LeftToRight n m v w => RangeR n m a -> RangeL v w a -> RangeR (n + v) (m + w) a infixl 5 Source #
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 Source #
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 Source #
Instances
(1 <= n, RightToLeft (n - 1) (m - 1) (v + 1) (w + 1)) => RightToLeft n m v w Source # | |
(1 <= v, PushL (v - 1) (w - 1), LoosenLMax v w (m + w), RightToLeft 0 (m - 1) v (w + 1)) => RightToLeft 0 m v w Source # | |
RightToLeft 0 0 v w Source # | |
(++..) :: RightToLeft n m v w => RangeR n m a -> RangeL v w a -> RangeL (n + v) (m + w) a infixr 5 Source #
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 Source #
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))))