Data.List.Range

RANGED LIST LEFT

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

Type

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 <= m => a -> RangeL 0 (m - 1) a -> RangeL 0 m a infixr 6

(:.) :: (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)]

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

PushL

class PushL n m

Minimal complete definition

(.:..)

Instances

(1 <= n, PushL (n - 1) (m - 1)) => PushL n m

Defined in Data.List.Range.RangeL

Methods

(.:..) :: a -> RangeL n m a -> RangeL n (m + 1) a

PushL 0 m

Defined in Data.List.Range.RangeL

Methods

(.:..) :: a -> RangeL 0 m a -> RangeL 0 (m + 1) a

(.:..) :: PushL n m => a -> RangeL n m a -> RangeL n (m + 1) a infixr 5

To push an optional element.

>>> :set -XDataKinds
>>> samplePushL = 'e' :. 'l' :. 'l' :. 'o' :.. NilL :: RangeL 3 7 Char
>>> 'h' .:.. samplePushL
'h' :. ('e' :. ('l' :. ('l' :.. ('o' :.. NilL))))
>>> :type 'h' .:.. samplePushL
'h' .:.. samplePushL :: RangeL 3 8 Char

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

LoosenLMin and LoosenLMax

loosenL

loosenL :: (LoosenLMin n m v, LoosenLMax v m w) => RangeL n m a -> RangeL v w a

To loosen a range of an element number.

>>> :set -XDataKinds
>>> sampleLoosenL = 'h' :. 'e' :. 'l' :. 'l' :. 'o' :.. NilL :: RangeL 4 6 Char
>>> loosenL sampleLoosenL :: RangeL 2 8 Char
'h' :. ('e' :. ('l' :.. ('l' :.. ('o' :.. NilL))))

loosenLMin

class LoosenLMin n m v

Minimal complete definition

loosenLMin

Instances

(1 <= n, 1 <= v, LoosenLMin (n - 1) (m - 1) (v - 1)) => LoosenLMin n m v

Defined in Data.List.Range.RangeL

Methods

loosenLMin :: RangeL n m a -> RangeL v m a

(1 <= n, LoosenLMin (n - 1) (m - 1) 0) => LoosenLMin n m 0

Defined in Data.List.Range.RangeL

Methods

loosenLMin :: RangeL n m a -> RangeL 0 m a

LoosenLMin 0 m 0

Defined in Data.List.Range.RangeL

Methods

loosenLMin :: RangeL 0 m a -> RangeL 0 m a

loosenLMin :: LoosenLMin n m v => RangeL n m a -> RangeL v m a

To loosen a lower bound of an element number.

>>> :set -XDataKinds -fno-warn-tabs
>>> :{
	sampleLoosenLMin :: RangeL 4 6 Char
	sampleLoosenLMin = 'h' :. 'e' :. 'l' :. 'l' :. 'o' :.. NilL
:}

>>> loosenLMin sampleLoosenLMin :: RangeL 2 6 Char
'h' :. ('e' :. ('l' :.. ('l' :.. ('o' :.. NilL))))

loosenLMax

class LoosenLMax n m w

Minimal complete definition

loosenLMax

Instances

(1 <= n, 1 <= w, LoosenLMax (n - 1) (m - 1) (w - 1)) => LoosenLMax n m w

Defined in Data.List.Range.RangeL

Methods

loosenLMax :: RangeL n m a -> RangeL n w a

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

Defined in Data.List.Range.RangeL

Methods

loosenLMax :: RangeL 0 m a -> RangeL 0 w a

LoosenLMax 0 0 w

Defined in Data.List.Range.RangeL

Methods

loosenLMax :: RangeL 0 0 a -> RangeL 0 w a

loosenLMax :: LoosenLMax n m w => RangeL n m a -> RangeL n w a

To loosen an upper bound of an element number.

>>> :set -XDataKinds -fno-warn-tabs
>>> :{
	sampleLoosenLMax :: RangeL 4 6 Char
	sampleLoosenLMax = 'h' :. 'e' :. 'l' :. 'l' :. 'o' :.. NilL
:}

>>> loosenLMax sampleLoosenLMax :: RangeL 4 8 Char
'h' :. ('e' :. ('l' :. ('l' :. ('o' :.. NilL))))

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))

unfoldrRange

without monad

unfoldrRange :: Unfoldr 0 v w => (s -> Bool) -> (s -> (a, s)) -> s -> RangeL v w a

To evaluate a function to construct a list. The function recieve a state and return an element and a new state. First argument is a predication which is evaluated when an element number is greater than a minimum and not greater than a maximum.

>>> :set -XDataKinds
>>> next n = (n * 3, n + 1)
>>> unfoldrRange (< 2) next 1 :: RangeL 3 5 Int
3 :. (6 :. (9 :. NilL))

>>> unfoldrRange (< 5) next 1 :: RangeL 3 5 Int
3 :. (6 :. (9 :. (12 :.. NilL)))

>>> unfoldrRange (< 10) next 1 :: RangeL 3 5 Int
3 :. (6 :. (9 :. (12 :.. (15 :.. NilL))))

unfoldrRangeWithBase :: Unfoldr n v w => RangeL n w a -> (s -> Bool) -> (s -> (a, s)) -> s -> RangeL v w a

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

>>> :set -XDataKinds
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Integer
>>> unfoldrRangeWithBase xs (< 3) (\n -> (n * 3, n + 1)) 1 :: RangeL 3 5 Integer
123 :. (456 :. (3 :. (6 :.. NilL)))

unfoldrRangeWithBaseWithS :: Unfoldr n v w => RangeL n w a -> (s -> Bool) -> (s -> (a, s)) -> s -> (RangeL v w a, s)

It is like unfoldrRangeWithBase. But it return not only a list but also a state value.

>>> :set -XDataKinds
>>> next n = (n * 3, n + 1)
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Integer
>>> unfoldrRangeWithBaseWithS xs (< 3) next 1 :: (RangeL 3 5 Integer, Integer)
(123 :. (456 :. (3 :. (6 :.. NilL))),3)

with monad

unfoldrMRange :: (Unfoldr 0 v w, Monad m) => m Bool -> m a -> m (RangeL v w a)

It is like unfoldrRange. But it use a monad instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldrMRange ((< 5) <$> readIORef r) count :: IO (RangeL 3 5 Integer)
3 :. (6 :. (9 :. (12 :.. NilL)))

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

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

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> check = (< 3) <$> readIORef r
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Integer
>>> unfoldrMRangeWithBase xs check count :: IO (RangeL 3 5 Integer)
123 :. (456 :. (3 :. (6 :.. NilL)))

unfoldrRangeMaybe

without monad

unfoldrRangeMaybe :: Unfoldr 0 v w => (s -> Maybe (a, s)) -> s -> Maybe (RangeL v w a)

To eveluate a function to construct a list. The function recieve a state and return a nothing value or an element and a new state. If number of created elements is less than a minimum number of list elements or greater than a maximum number, then return Nothing.

>>> :set -XDataKinds
>>> next n0 n = if n < n0 then Just (n * 3, n + 1) else Nothing
>>> unfoldrRangeMaybe (next 2) 1 :: Maybe (RangeL 3 5 Int)
Nothing

>>> unfoldrRangeMaybe (next 5) 1 :: Maybe (RangeL 3 5 Int)
Just (3 :. (6 :. (9 :. (12 :.. NilL))))

>>> unfoldrRangeMaybe (next 10) 1 :: Maybe (RangeL 3 5 Int)
Nothing

unfoldrRangeMaybeWithBase :: Unfoldr n v w => RangeL n w a -> (s -> Maybe (a, s)) -> s -> Maybe (RangeL v w a)

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

>>> :set -XDataKinds
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Int
>>> next n = if n < 3 then Just (n * 3, n + 1) else Nothing
>>> unfoldrRangeMaybeWithBase xs next 1 :: Maybe (RangeL 3 5 Int)
Just (123 :. (456 :. (3 :. (6 :.. NilL))))

with monad

unfoldrMRangeMaybe :: (Unfoldr 0 v w, Monad m) => m Bool -> m a -> m (Maybe (RangeL v w a))

It is like unfoldrRangeMaybe. But it use a monad instead of a function. The first argument monad return boolean value. It create values while this boolean value is True. If this boolean value is False before to create enough values or True after to create full values, then unfoldrMRangeMaybe return Nothing.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> check n0 = (< n0) <$> readIORef r
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldrMRangeMaybe (check 2) count :: IO (Maybe (RangeL 3 5 Integer))
Nothing

>>> writeIORef r 1
>>> unfoldrMRangeMaybe (check 5) count :: IO (Maybe (RangeL 3 5 Integer))
Just (3 :. (6 :. (9 :. (12 :.. NilL))))

>>> writeIORef r 1
>>> unfoldrMRangeMaybe (check 10) count :: IO (Maybe (RangeL 3 5 Integer))
Nothing

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

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

>>> :set -XDataKinds -fno-warn-tabs
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> check = (< 3) <$> readIORef r
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> xs = 123 :. 456 :.. NilL :: RangeL 1 5 Integer
>>> :{
	unfoldrMRangeMaybeWithBase xs check count
		:: IO (Maybe (RangeL 3 5 Integer))
:}
Just (123 :. (456 :. (3 :. (6 :.. 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)))

Repeat and Unfoldr Min and Max

repeat

repeatLMin :: (LoosenLMax n n m, Unfoldr 0 n n) => a -> RangeL n m a

To repeat a value minimum number of times.

>>> :set -XDataKinds
>>> repeatLMin 123 :: RangeL 3 5 Integer
123 :. (123 :. (123 :. NilL))

repeatLMax :: (LoosenLMin m m n, Unfoldr 0 m m) => a -> RangeL n m a

To repeat a value maximum number of times.

>>> :set -XDataKinds
>>> repeatLMax 123 :: RangeL 3 5 Integer
123 :. (123 :. (123 :. (123 :.. (123 :.. NilL))))

unfoldr

unfoldrMin :: (LoosenLMax n n m, Unfoldr 0 n n) => (s -> (a, s)) -> s -> RangeL n m a

To evaluate a function to construct values minimum number of times. The function recieve a state and return a value and a new state.

>>> :set -XDataKinds
>>> unfoldrMin (\n -> (n * 3, n + 1)) 1 :: RangeL 3 5 Integer
3 :. (6 :. (9 :. NilL))

unfoldrMax :: (LoosenLMin m m n, Unfoldr 0 m m) => (s -> (a, s)) -> s -> RangeL n m a

To evaluate a function to construct values maximum number of times. The function recieve a state and return a value and a new state.

>>> :set -XDataKinds
>>> unfoldrMax (\n -> (n * 3, n + 1)) 1 :: RangeL 3 5 Integer
3 :. (6 :. (9 :. (12 :.. (15 :.. NilL))))

unfoldrM

unfoldrMMin :: (Monad m, LoosenLMax n n w, Unfoldr 0 n n) => m a -> m (RangeL n w a)

It is like unfoldrMin. But it use a monad instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldrMMin count :: IO (RangeL 3 5 Integer)
3 :. (6 :. (9 :. NilL))

unfoldrMMax :: (Monad m, LoosenLMin w w n, Unfoldr 0 w w) => m a -> m (RangeL n w a)

It is like unfoldrMax. But it use a monad instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldrMMax count :: IO (RangeL 3 5 Integer)
3 :. (6 :. (9 :. (12 :.. (15 :.. NilL))))

RANGED LIST RIGHT

Type

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 <= m => RangeR 0 (m - 1) a -> a -> RangeR 0 m a infixl 6

(:+) :: (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)]

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

PushR

class PushR n m

Minimal complete definition

(.:++)

Instances

(1 <= n, PushR (n - 1) (m - 1)) => PushR n m

Defined in Data.List.Range.RangeR

Methods

(.:++) :: RangeR n m a -> a -> RangeR n (m + 1) a

PushR 0 m

Defined in Data.List.Range.RangeR

Methods

(.:++) :: RangeR 0 m a -> a -> RangeR 0 (m + 1) a

(.:++) :: PushR n m => RangeR n m a -> a -> RangeR n (m + 1) a infixl 5

To push an optional element.

>>> :set -XDataKinds
>>> samplePushR = NilR :++ 'h' :+ 'e' :+ 'l' :+ 'l' :: RangeR 3 7 Char
>>> samplePushR .:++ 'o'
((((NilR :++ 'h') :++ 'e') :+ 'l') :+ 'l') :+ 'o'
>>> :type samplePushR .:++ 'o'
samplePushR .:++ 'o' :: RangeR 3 8 Char

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

LoosenRMin and LoosenRMax

loosenR

loosenR :: (LoosenRMin n m v, LoosenRMax v m w) => RangeR n m a -> RangeR v w a

To loosen a range of element number.

>>> :set -XDataKinds
>>> sampleLoosenR = NilR :++ 'h' :+ 'e' :+ 'l' :+ 'l' :+ 'o' :: RangeR 4 6 Char
>>> loosenR sampleLoosenR :: RangeR 2 8 Char
((((NilR :++ 'h') :++ 'e') :++ 'l') :+ 'l') :+ 'o'

loosenRMin

class LoosenRMin n m v

Minimal complete definition

loosenRMin

Instances

(1 <= n, 1 <= v, LoosenRMin (n - 1) (m - 1) (v - 1)) => LoosenRMin n m v

Defined in Data.List.Range.RangeR

Methods

loosenRMin :: RangeR n m a -> RangeR v m a

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

Defined in Data.List.Range.RangeR

Methods

loosenRMin :: RangeR n m a -> RangeR 0 m a

LoosenRMin 0 m 0

Defined in Data.List.Range.RangeR

Methods

loosenRMin :: RangeR 0 m a -> RangeR 0 m a

loosenRMin :: LoosenRMin n m v => RangeR n m a -> RangeR v m a

To loosen a lower bound of element number.

>>> :set -XDataKinds -fno-warn-tabs
>>> :{
	sampleLoosenRMin :: RangeR 4 6 Char
	sampleLoosenRMin = NilR :++ 'h' :+ 'e' :+ 'l' :+ 'l' :+ 'o'
:}

>>> loosenRMin sampleLoosenRMin :: RangeR 2 6 Char
((((NilR :++ 'h') :++ 'e') :++ 'l') :+ 'l') :+ 'o'

loosenRMax

class LoosenRMax n m w

Minimal complete definition

loosenRMax

Instances

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

Defined in Data.List.Range.RangeR

Methods

loosenRMax :: RangeR n m a -> RangeR n w a

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

Defined in Data.List.Range.RangeR

Methods

loosenRMax :: RangeR 0 m a -> RangeR 0 w a

LoosenRMax 0 0 m

Defined in Data.List.Range.RangeR

Methods

loosenRMax :: RangeR 0 0 a -> RangeR 0 m a

loosenRMax :: LoosenRMax n m w => RangeR n m a -> RangeR n w a

To loosen an upper bound of element number.

>>> :set -XDataKinds -fno-warn-tabs
>>> :{
	sampleLoosenRMax :: RangeR 4 6 Char
	sampleLoosenRMax = NilR :++ 'h' :+ 'e' :+ 'l' :+ 'l' :+ 'o'
:}

>>> loosenRMax sampleLoosenRMax :: RangeR 4 8 Char
((((NilR :++ 'h') :+ 'e') :+ 'l') :+ 'l') :+ 'o'

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))

unfoldlRange

without monad

unfoldlRange :: Unfoldl 0 v w => (s -> Bool) -> (s -> (s, a)) -> s -> RangeR v w a

To eveluate a function to construct a list. The function recieve a state and return an element and a new state. The first argument is a predication which is evaluated when an element number is greater than a minimum and not greater than a maximum.

>>> :set -XDataKinds
>>> unfoldlRange (< 2) (\n -> (n + 1, n * 3)) 1 :: RangeR 3 5 Int
((NilR :+ 9) :+ 6) :+ 3

>>> unfoldlRange (< 5) (\n -> (n + 1, n * 3)) 1 :: RangeR 3 5 Int
(((NilR :++ 12) :+ 9) :+ 6) :+ 3

>>> unfoldlRange (< 10) (\n -> (n + 1, n * 3)) 1 :: RangeR 3 5 Int
((((NilR :++ 15) :++ 12) :+ 9) :+ 6) :+ 3

unfoldlRangeWithBase :: Unfoldl n v w => (s -> Bool) -> (s -> (s, a)) -> s -> RangeR n w a -> RangeR v w a

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

>>> :set -XDataKinds
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Integer
>>> unfoldlRangeWithBase (< 3) (\n -> (n + 1, n * 3)) 1 xs :: RangeR 3 5 Integer
(((NilR :++ 6) :+ 3) :+ 123) :+ 456

unfoldlRangeWithBaseWithS :: Unfoldl n v w => (s -> Bool) -> (s -> (s, a)) -> s -> RangeR n w a -> (s, RangeR v w a)

It is like unfoldlRangeWithBase. But it return not only a list but also a state value.

>>> :set -XDataKinds -fno-warn-tabs
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Integer
>>> :{
	unfoldlRangeWithBaseWithS (< 3) (\n -> (n + 1, n * 3)) 1 xs
		:: (Integer, RangeR 3 5 Integer)
:}
(3,(((NilR :++ 6) :+ 3) :+ 123) :+ 456)

with monad

unfoldlMRange :: (Unfoldl 0 v w, Monad m) => m Bool -> m a -> m (RangeR v w a)

It is like unfoldlRange. But it use a monad instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldlMRange ((< 5) <$> readIORef r) count :: IO (RangeR 3 5 Integer)
(((NilR :++ 12) :+ 9) :+ 6) :+ 3

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

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

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Integer
>>> :{
	unfoldlMRangeWithBase ((< 3) <$> readIORef r) count xs
		:: IO (RangeR 3 5 Integer)
:}
(((NilR :++ 6) :+ 3) :+ 123) :+ 456

unfoldlRangeMaybe

without monad

unfoldlRangeMaybe :: Unfoldl 0 v w => (s -> Maybe (s, a)) -> s -> Maybe (RangeR v w a)

To evaluate a function to construct a list. The function recieves a state and return a nothing value or an element and a new state. If the number of created elements is less than a minimum number of list elements or greater than a maximum number, then return Nothing.

>>> :set -XDataKinds
>>> count n0 n = if n < n0 then Just (n + 1, n * 3) else Nothing
>>> unfoldlRangeMaybe (count 2) 1 :: Maybe (RangeR 3 5 Int)
Nothing

>>> unfoldlRangeMaybe (count 5) 1 :: Maybe (RangeR 3 5 Int)
Just ((((NilR :++ 12) :+ 9) :+ 6) :+ 3)

>>> unfoldlRangeMaybe (count 10) 1 :: Maybe (RangeR 3 5 Int)
Nothing

unfoldlRangeMaybeWithBase :: Unfoldl n v w => (s -> Maybe (s, a)) -> s -> RangeR n w a -> Maybe (RangeR v w a)

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

>>> :set -XDataKinds
>>> count n = if n < 3 then Just (n + 1, n * 3) else Nothing
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Int
>>> unfoldlRangeMaybeWithBase count 1 xs :: Maybe (RangeR 3 5 Int)
Just ((((NilR :++ 6) :+ 3) :+ 123) :+ 456)

with monad

unfoldlMRangeMaybe :: (Unfoldl 0 v w, Monad m) => m Bool -> m a -> m (Maybe (RangeR v w a))

It is like unfoldlRangeMaybe. But it use a monad instead of a function. The first argument monad returns a boolean value. It creates values while this boolean value is True. If this boolean value is False before to create enough values or True after to create full values, then unfoldlMRangeMaybe returns Nothing.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> check n0 = (< n0) <$> readIORef r
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldlMRangeMaybe (check 2) count :: IO (Maybe (RangeR 3 5 Integer))
Nothing

>>> writeIORef r 1
>>> unfoldlMRangeMaybe (check 5) count :: IO (Maybe (RangeR 3 5 Integer))
Just ((((NilR :++ 12) :+ 9) :+ 6) :+ 3)

>>> writeIORef r 1
>>> unfoldlMRangeMaybe (check 10) count :: IO (Maybe (RangeR 3 5 Integer))
Nothing

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

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

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> check = (< 3) <$> readIORef r
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> xs = NilR :++ 123 :+ 456 :: RangeR 1 5 Integer
>>> :{
	unfoldlMRangeMaybeWithBase check count xs
		:: IO (Maybe (RangeR 3 5 Integer))
:}
Just ((((NilR :++ 6) :+ 3) :+ 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 :++ ()) :+ ()) :+ ())

Repeat and Unfoldl Min and Max

repeat

repeatRMin :: (LoosenRMax n n m, Unfoldl 0 n n) => a -> RangeR n m a

To repeat a value minimum number of times.

>>> :set -XDataKinds
>>> repeatRMin 123 :: RangeR 3 5 Integer
((NilR :+ 123) :+ 123) :+ 123

repeatRMax :: (LoosenRMin m m n, Unfoldl 0 m m) => a -> RangeR n m a

To repeat a value maximum number of times.

>>> :set -XDataKinds
>>> repeatRMax 123 :: RangeR 3 5 Integer
((((NilR :++ 123) :++ 123) :+ 123) :+ 123) :+ 123

unfoldl

unfoldlMin :: (LoosenRMax n n m, Unfoldl 0 n n) => (s -> (s, a)) -> s -> RangeR n m a

To evaluate a function to construct values minimum number of times. The function recieves a state and return a value and a new state.

>>> :set -XDataKinds
>>> unfoldlMin (\n -> (n + 1, n * 3)) 1 :: RangeR 3 5 Integer
((NilR :+ 9) :+ 6) :+ 3

unfoldlMax :: (LoosenRMin m m n, Unfoldl 0 m m) => (s -> (s, a)) -> s -> RangeR n m a

To eveluate a function to construct values maximum number of times. The function recieves a state and return a value and a new state.

>>> :set -XDataKinds
>>> unfoldlMax (\n -> (n + 1, n * 3)) 1 :: RangeR 3 5 Integer
((((NilR :++ 15) :++ 12) :+ 9) :+ 6) :+ 3

unfoldlM

unfoldlMMin :: (Monad m, LoosenRMax n n w, Unfoldl 0 n n) => m a -> m (RangeR n w a)

It is like unfoldlMax. But it uses a monad instead of a function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldlMMin count :: IO (RangeR 3 5 Integer)
((NilR :+ 9) :+ 6) :+ 3

unfoldlMMax :: (Monad m, LoosenRMin w w n, Unfoldl 0 w w) => m a -> m (RangeR n w a)

It is like unfoldlMax. But it uses a monad instead of function.

>>> :set -XDataKinds
>>> :module + Data.IORef
>>> r <- newIORef 1
>>> count = readIORef r >>= \n -> n * 3 <$ writeIORef r (n + 1)
>>> unfoldlMMax count :: IO (RangeR 3 5 Integer)
((((NilR :++ 15) :++ 12) :+ 9) :+ 6) :+ 3

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))))