empty𝐼 :: 𝐼 a Source #

cons𝐼 :: a -> 𝐼 a -> 𝐼 a Source #

stream :: ToIter a t => t -> 𝑆 a Source #

zipWith :: (ToIter a t₁, ToIter b t₂) => (a -> b -> c) -> t₁ -> t₂ -> 𝐼 c Source #

zip :: (ToIter a t₁, ToIter b t₂) => t₁ -> t₂ -> 𝐼 (a ∧ b) Source #

snoc𝐼 :: 𝐼 a -> a -> 𝐼 a Source #

isEmpty :: ToIter a t => t -> 𝔹 Source #

firstElem :: ToIter a t => t -> 𝑂 a Source #

append𝐼 :: 𝐼 a -> 𝐼 a -> 𝐼 a Source #

bind𝐼 :: 𝐼 a -> (a -> 𝐼 b) -> 𝐼 b Source #

mjoin𝐼 :: 𝐼 (𝐼 a) -> 𝐼 a Source #

mapM𝐼 :: Monad m => (a -> m b) -> 𝐼 a -> m (𝐼 b) Source #

fold :: ToIter a t => b -> (a -> b -> b) -> t -> b Source #

foldFromWith :: ToIter a t => b -> (a -> b -> b) -> t -> b Source #

foldFromOn :: ToIter a t => b -> t -> (a -> b -> b) -> b Source #

foldOnFrom :: ToIter a t => t -> b -> (a -> b -> b) -> b Source #

foldOnWith :: ToIter a t => t -> (a -> b -> b) -> b -> b Source #

foldWithOn :: ToIter a t => (a -> b -> b) -> t -> b -> b Source #

foldWithFrom :: ToIter a t => (a -> b -> b) -> b -> t -> b Source #

foldk :: ToIter a t => b -> (a -> b -> (b -> b) -> b) -> t -> b Source #

foldkFromWith :: ToIter a t => b -> (a -> b -> (b -> b) -> b) -> t -> b Source #

foldkFromOn :: ToIter a t => b -> t -> (a -> b -> (b -> b) -> b) -> b Source #

foldkOnFrom :: ToIter a t => t -> b -> (a -> b -> (b -> b) -> b) -> b Source #

foldkOnWith :: ToIter a t => t -> (a -> b -> (b -> b) -> b) -> b -> b Source #

foldkWithOn :: ToIter a t => (a -> b -> (b -> b) -> b) -> t -> b -> b Source #

foldkWithFrom :: ToIter a t => (a -> b -> (b -> b) -> b) -> b -> t -> b Source #

foldr :: ToIter a t => b -> (a -> b -> b) -> t -> b Source #

foldrFromWith :: ToIter a t => b -> (a -> b -> b) -> t -> b Source #

foldrFromOn :: ToIter a t => b -> t -> (a -> b -> b) -> b Source #

foldrOnFrom :: ToIter a t => t -> b -> (a -> b -> b) -> b Source #

foldrOnWith :: ToIter a t => t -> (a -> b -> b) -> b -> b Source #

foldrWithOn :: ToIter a t => (a -> b -> b) -> t -> b -> b Source #

foldrWithFrom :: ToIter a t => (a -> b -> b) -> b -> t -> b Source #

mfold :: (Monad m, ToIter a t) => b -> (a -> b -> m b) -> t -> m b Source #

mfoldFromWith :: (Monad m, ToIter a t) => b -> (a -> b -> m b) -> t -> m b Source #

mfoldFromOn :: (Monad m, ToIter a t) => b -> t -> (a -> b -> m b) -> m b Source #

mfoldOnFrom :: (Monad m, ToIter a t) => t -> b -> (a -> b -> m b) -> m b Source #

mfoldOnWith :: (Monad m, ToIter a t) => t -> (a -> b -> m b) -> b -> m b Source #

mfoldWithOn :: (Monad m, ToIter a t) => (a -> b -> m b) -> t -> b -> m b Source #

mfoldWithFrom :: (Monad m, ToIter a t) => (a -> b -> m b) -> b -> t -> m b Source #

mfoldk :: (Monad m, ToIter a t) => b -> (a -> b -> (m b -> m b) -> m b) -> t -> m b Source #

mfoldkFromWith :: (Monad m, ToIter a t) => b -> (a -> b -> (m b -> m b) -> m b) -> t -> m b Source #

mfoldkFromOn :: (Monad m, ToIter a t) => b -> t -> (a -> b -> (m b -> m b) -> m b) -> m b Source #

mfoldkOnFrom :: (Monad m, ToIter a t) => t -> b -> (a -> b -> (m b -> m b) -> m b) -> m b Source #

mfoldkOnWith :: (Monad m, ToIter a t) => t -> (a -> b -> (m b -> m b) -> m b) -> b -> m b Source #

mfoldkWithOn :: (Monad m, ToIter a t) => (a -> b -> (m b -> m b) -> m b) -> t -> b -> m b Source #

mfoldkWithFrom :: (Monad m, ToIter a t) => (a -> b -> (m b -> m b) -> m b) -> b -> t -> m b Source #

mfoldr :: (Monad m, ToIter a t) => b -> (a -> b -> m b) -> t -> m b Source #

mfoldrFromWith :: (Monad m, ToIter a t) => b -> (a -> b -> m b) -> t -> m b Source #

mfoldrFromOn :: (Monad m, ToIter a t) => b -> t -> (a -> b -> m b) -> m b Source #

mfoldrOnFrom :: (Monad m, ToIter a t) => t -> b -> (a -> b -> m b) -> m b Source #

mfoldrOnWith :: (Monad m, ToIter a t) => t -> (a -> b -> m b) -> b -> m b Source #

mfoldrWithOn :: (Monad m, ToIter a t) => (a -> b -> m b) -> t -> b -> m b Source #

mfoldrWithFrom :: (Monad m, ToIter a t) => (a -> b -> m b) -> b -> t -> m b Source #

eachWith :: (Monad m, ToIter a t) => (a -> m ()) -> t -> m () Source #

eachOn :: (Monad m, ToIter a t) => t -> (a -> m ()) -> m () Source #

eachkWith :: (Monad m, ToIter a t) => (a -> (m () -> m ()) -> m ()) -> t -> m () Source #

eachkOn :: (Monad m, ToIter a t) => t -> (a -> (m () -> m ()) -> m ()) -> m () Source #

exec :: (Monad m, ToIter (m ()) t) => t -> m () Source #

sum :: (ToIter a t, Additive a) => t -> a Source #

product :: (ToIter a t, Multiplicative a) => t -> a Source #

concat :: (Monoid a, ToIter a t) => t -> a Source #

sequence :: (Seqoid a, ToIter a t) => t -> a Source #

compose :: ToIter (a -> a) t => t -> a -> a Source #

mcompose :: (Monad m, ToIter (a -> m a) t) => t -> a -> m a Source #

wcompose :: (Comonad w, ToIter (w a -> a) t) => t -> w a -> a Source #

minsFrom :: (ToIter a t, Ord a) => a -> t -> a Source #

maxsFrom :: (ToIter a t, Ord a) => a -> t -> a Source #

joinsFrom :: (ToIter a t, Join a) => a -> t -> a Source #

joins :: (JoinLattice a, ToIter a t) => t -> a Source #

meetsFrom :: (ToIter a t, Meet a) => a -> t -> a Source #

meets :: (MeetLattice a, ToIter a t) => t -> a Source #

or :: ToIter 𝔹 t => t -> 𝔹 Source #

orf :: ToIter (a -> 𝔹) t => t -> a -> 𝔹 Source #

andf :: ToIter (a -> 𝔹) t => t -> a -> 𝔹 Source #

and :: ToIter 𝔹 t => t -> 𝔹 Source #

eqs :: (Eq a, ToIter a t) => t -> 𝔹 Source #

count :: forall n t a. (Zero n, One n, Plus n, ToIter a t) => t -> n Source #

countWith :: forall n t a. (Zero n, One n, Plus n, ToIter a t) => (a -> 𝔹) -> t -> n Source #

reverse :: ToIter a t => t -> 𝐼 a Source #

replicateI :: (Eq n, Zero n, One n, Plus n) => n -> (n -> a) -> 𝐼 a Source #

replicate :: (Eq n, Zero n, One n, Plus n) => n -> a -> 𝐼 a Source #

build :: (Eq n, Zero n, One n, Plus n) => n -> a -> (a -> a) -> 𝐼 a Source #

range :: (Eq n, Additive n, One n, Minus n) => n -> n -> 𝐼 n Source #

upto :: (Eq n, Additive n, One n) => n -> 𝐼 n Source #

uptoStep :: ℕ64 -> ℕ64 -> 𝐼 ℕ64 Source #

mapState𝐼 :: forall t a b s. ToIter a t => s -> (a -> s -> s ∧ b) -> t -> 𝐼 b Source #

mapStateOnFrom𝐼 :: forall t a b s. ToIter a t => t -> s -> (a -> s -> s ∧ b) -> 𝐼 b Source #

mapCont𝐼 :: forall t a b. ToIter a t => (forall i. a -> i -> (b -> i -> (i -> i) -> i) -> (i -> i) -> (i -> i) -> i) -> t -> 𝐼 b Source #

mapContOn𝐼 :: forall t a b. ToIter a t => t -> (forall i. a -> i -> (b -> i -> (i -> i) -> i) -> (i -> i) -> (i -> i) -> i) -> 𝐼 b Source #

withIndex :: forall n t a. (Zero n, One n, Plus n, ToIter a t) => t -> 𝐼 (n ∧ a) Source #

withFirst :: ToIter a t => t -> 𝐼 (𝔹 ∧ a) Source #

mapFirst :: ToIter a t => (a -> a) -> t -> 𝐼 a Source #

mapAfterFirst :: ToIter a t => (a -> a) -> t -> 𝐼 a Source #

keepN :: (ToIter a t, Ord n, Zero n, One n, Plus n) => n -> t -> 𝐼 a Source #

dropN :: (ToIter a t, Ord n, Zero n, One n, Plus n) => n -> t -> 𝐼 a Source #

withLast :: ToIter a t => t -> 𝐼 (𝔹 ∧ a) Source #

mapLast :: ToIter a t => (a -> a) -> t -> 𝐼 a Source #

mapLastOn :: ToIter a t => t -> (a -> a) -> 𝐼 a Source #

mapBeforeLast :: ToIter a t => (a -> a) -> t -> 𝐼 a Source #

filter :: ToIter a t => (a -> 𝔹) -> t -> 𝐼 a Source #

filterOn :: ToIter a t => t -> (a -> 𝔹) -> 𝐼 a Source #

filterO :: ToIter (𝑂 a) t => t -> 𝐼 a Source #

filterMap :: ToIter a t => (a -> 𝑂 b) -> t -> 𝐼 b Source #

filterMapOn :: ToIter a t => t -> (a -> 𝑂 b) -> 𝐼 b Source #

filterM :: (ToIter a t, Monad m) => (a -> m 𝔹) -> t -> m (𝐼 a) Source #

filterMOn :: (ToIter a t, Monad m) => t -> (a -> m 𝔹) -> m (𝐼 a) Source #

filterMapM :: (ToIter a t, Monad m) => (a -> m (𝑂 b)) -> t -> m (𝐼 b) Source #

filterMapMOn :: (ToIter a t, Monad m) => t -> (a -> m (𝑂 b)) -> m (𝐼 b) Source #

inbetween :: ToIter a t => a -> t -> 𝐼 a Source #

alignLeftFill :: ℂ -> ℕ -> 𝕊 -> 𝕊 Source #

alignLeft :: ℕ -> 𝕊 -> 𝕊 Source #

alignRightFill :: ℂ -> ℕ -> 𝕊 -> 𝕊 Source #

alignRight :: ℕ -> 𝕊 -> 𝕊 Source #

list :: ToIter a t => t -> 𝐿 a Source #

lazyList :: ToIter a t => t -> [a] Source #

string :: ToIter ℂ t => t -> 𝕊 Source #

stringS :: ToIter 𝕊 t => t -> 𝕊 Source #

truncate𝕊 :: ℕ64 -> 𝕊 -> 𝕊 -> 𝕊 Source #

showCollection :: ToIter a t => 𝕊 -> 𝕊 -> 𝕊 -> (a -> 𝕊) -> t -> 𝕊 Source #

showWith𝐼 :: (a -> 𝕊) -> 𝐼 a -> 𝕊 Source #

firstMaxByLT :: ToIter a t => (a -> a -> 𝔹) -> t -> 𝑂 a Source #

sortWith :: ToIter a t => (a -> a -> Ordering) -> t -> 𝐿 a Source #

sortOn :: (ToIter a t, Ord b) => (a -> b) -> t -> 𝐿 a Source #

sort :: (ToIter a t, Ord a) => t -> 𝐿 a Source #

materialize :: ToIter a t => t -> 𝐼 a Source #

mapWhile :: (a -> a) -> (a -> 𝔹) -> 𝐼 a -> 𝐼 a Source #

dropWhile :: (a -> 𝔹) -> 𝐼 a -> 𝐼 a Source #

takeWhile :: (a -> 𝔹) -> 𝐼 a -> 𝐼 a Source #

lookup𝐼 :: ℕ64 -> 𝐼 a -> 𝑂 a Source #

partition :: (a -> b ∨ c) -> 𝐿 a -> 𝐿 b ∧ 𝐿 c Source #

partition𝔹 :: (a -> 𝔹) -> 𝐿 a -> 𝐿 a ∧ 𝐿 a Source #