Idris2Doc : Prelude.Interfaces

Prelude.Interfaces

($>) : Functorf => fa -> b -> fb
  Flipped version of `<$`.

Totality: total
Fixity Declaration: infixr operator, level 4
(*>) : Applicativef => fa -> fb -> fb
Totality: total
Fixity Declaration: infixl operator, level 3
(<$) : Functorf => b -> fa -> fb
  Run something for effects, replacing the return value with a given parameter.

Totality: total
Fixity Declaration: infixr operator, level 4
(<$>) : Functorf => (a -> b) -> fa -> fb
  An infix alias for `map`, applying a function across everything of type 'a'
in a parameterised type.
@ f the parameterised type
@ func the function to apply

Totality: total
Fixity Declaration: infixr operator, level 4
(<&>) : Functorf => fa -> (a -> b) -> fb
  Flipped version of `<$>`, an infix alias for `map`, applying a function across
everything of type 'a' in a parameterised type.
@ f the parameterised type
@ func the function to apply

Totality: total
Fixity Declaration: infixl operator, level 1
(<*) : Applicativef => fa -> fb -> fa
Totality: total
Fixity Declaration: infixl operator, level 3
(<*>) : Applicativef => f (a -> b) -> fa -> fb
Totality: total
Fixity Declaration: infixl operator, level 3
(<+>) : Semigroupty => ty -> ty -> ty
Totality: total
Fixity Declaration: infixl operator, level 8
(<=<) : Monadm => (b -> mc) -> (a -> mb) -> a -> mc
  Right-to-left Kleisli composition of monads, flipped version of `>=>`.

Totality: total
Fixity Declaration: infixl operator, level 1
(<|>) : Alternativef => fa -> Lazy (fa) -> fa
Totality: total
Fixity Declaration: infixr operator, level 2
(=<<) : Monadm => (a -> mb) -> ma -> mb
  Right-to-left monadic bind, flipped version of `>>=`.

Totality: total
Fixity Declaration: infixl operator, level 1
(>=>) : Monadm => (a -> mb) -> (b -> mc) -> a -> mc
  Left-to-right Kleisli composition of monads.

Totality: total
Fixity Declaration: infixl operator, level 1
(>>) : Monadm => m () -> Lazy (mb) -> mb
  Sequencing of effectful composition

Totality: total
Fixity Declaration: infixl operator, level 1
(>>=) : Monadm => ma -> (a -> mb) -> mb
  Also called `bind`.

Totality: total
Fixity Declaration: infixl operator, level 1
interfaceAlternative : (Type -> Type) -> Type
Parameters: f
Constraints: Applicative f
Constructor: MkAlternative
Methods:
empty : fa
(<|>) : fa -> Lazy (fa) -> fa
Fixity Declaration: infixr operator, level 2

Implementations:
AlternativeMaybe
AlternativeList
interfaceApplicative : (Type -> Type) -> Type
Parameters: f
Constraints: Functor f
Constructor: MkApplicative
Methods:
pure : a -> fa
(<*>) : f (a -> b) -> fa -> fb
Fixity Declaration: infixl operator, level 3

Implementations:
ApplicativeIO
Monoida => Applicative (Paira)
ApplicativeMaybe
Applicative (Eithere)
ApplicativeList
interfaceBifoldable : (Type -> Type -> Type) -> Type
  `Bifoldable` identifies foldable structures with two different varieties
of elements (as opposed to `Foldable`, which has one variety of element).
Common examples are `Either` and `Pair`.

Parameters: p
Constructor: MkBifoldable
Methods:
bifoldr : (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> pab -> acc
bifoldl : (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> pab -> acc
binull : pab -> Lazy Bool

Implementations:
BifoldablePair
BifoldableEither
interfaceBifunctor : (Type -> Type -> Type) -> Type
  Bifunctors
@f The action of the Bifunctor on pairs of objects

Parameters: f
Constructor: MkBifunctor
Methods:
bimap : (a -> c) -> (b -> d) -> fab -> fcd
  The action of the Bifunctor on pairs of morphisms

````idris example
bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
````
mapFst : (a -> c) -> fab -> fcb
  The action of the Bifunctor on morphisms pertaining to the first object

````idris example
mapFst (\x => x + 1) (1, "hello") == (2, "hello")
````
mapSnd : (b -> d) -> fab -> fad
  The action of the Bifunctor on morphisms pertaining to the second object

````idris example
mapSnd reverse (1, "hello") == (1, "olleh")
````

Implementations:
BifunctorPair
BifunctorEither
interfaceBitraversable : (Type -> Type -> Type) -> Type
Parameters: p
Constraints: Bifunctor p, Bifoldable p
Constructor: MkBitraversable
Methods:
bitraverse : Applicativef => (a -> fc) -> (b -> fd) -> pab -> f (pcd)
  Map each element of a structure to a computation, evaluate those
computations and combine the results.

Implementations:
BitraversablePair
BitraversableEither
interfaceFoldable : (Type -> Type) -> Type
  The `Foldable` interface describes how you can iterate over the elements in
a parameterised type and combine the elements together, using a provided
function, into a single result.
@ t The type of the 'Foldable' parameterised type.

Parameters: t
Constructor: MkFoldable
Methods:
foldr : (elem -> acc -> acc) -> acc -> telem -> acc
  Successively combine the elements in a parameterised type using the
provided function, starting with the element that is in the final position
i.e. the right-most position.
@ func The function used to 'fold' an element into the accumulated result
@ init The starting value the results are being combined into
@ input The parameterised type
foldl : (acc -> elem -> acc) -> acc -> telem -> acc
  The same as `foldr` but begins the folding from the element at the initial
position in the data structure i.e. the left-most position.
@ func The function used to 'fold' an element into the accumulated result
@ init The starting value the results are being combined into
@ input The parameterised type
null : telem -> Lazy Bool
  Test whether the structure is empty.
@ acc The accumulator value which is specified to be lazy
foldlM : Monadm => (acc -> elem -> macc) -> acc -> telem -> macc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
Consequently, the final value is wrapped in the same `Monad`.
toList : telem -> Listelem
  Produce a list of the elements contained in the parametrised type.
foldMap : Monoidm => (a -> m) -> ta -> m
  Maps each element to a value and combine them.
For performance reasons, this should wherever
be implemented with tail recursion.
@ f The function to apply to each element.

Implementations:
FoldableMaybe
Foldable (Eithere)
FoldableList
interfaceFunctor : (Type -> Type) -> Type
  Functors allow a uniform action over a parameterised type.
@ f a parameterised type

Parameters: f
Constructor: MkFunctor
Methods:
map : (a -> b) -> fa -> fb
  Apply a function across everything of type 'a' in a parameterised type
@ f the parameterised type
@ func the function to apply

Implementations:
FunctorIO
Functor (Paira)
FunctorMaybe
Functor (Eithere)
FunctorList
FunctorStream
interfaceMonad : (Type -> Type) -> Type
Parameters: m
Constraints: Applicative m
Constructor: MkMonad
Methods:
(>>=) : ma -> (a -> mb) -> mb
  Also called `bind`.

Fixity Declaration: infixl operator, level 1
join : m (ma) -> ma
  Also called `flatten` or mu.

Implementations:
MonadIO
Monoida => Monad (Paira)
MonadMaybe
Monad (Eithere)
MonadList
interfaceMonoid : Type -> Type
  Sets equipped with a single binary operation that is associative, along with
a neutral element for that binary operation. Must satisfy the following
laws:

+ Associativity of `<+>`:
forall a b c, a <+> (b <+> c) == (a <+> b) <+> c
+ Neutral for `<+>`:
forall a, a <+> neutral == a
forall a, neutral <+> a == a

Parameters: ty
Constraints: Semigroup ty
Constructor: MkMonoid
Methods:
neutral : ty

Implementations:
Monoid ()
Monoida => Monoidb => Monoid (a, b)
MonoidOrdering
Monoidb => Monoid (a -> b)
Monoid (Maybea)
Monoid (Lista)
MonoidString
interfaceSemigroup : Type -> Type
  Sets equipped with a single binary operation that is associative. Must
satisfy the following laws:

+ Associativity of `<+>`:
forall a b c, a <+> (b <+> c) == (a <+> b) <+> c

Parameters: ty
Constructor: MkSemigroup
Methods:
(<+>) : ty -> ty -> ty
Fixity Declaration: infixl operator, level 8

Implementations:
Semigroup ()
Semigroupa => Semigroupb => Semigroup (a, b)
SemigroupOrdering
Semigroupb => Semigroup (a -> b)
Semigroup (Maybea)
Semigroup (Lista)
SemigroupString
interfaceTraversable : (Type -> Type) -> Type
Parameters: t
Constraints: Functor t, Foldable t
Constructor: MkTraversable
Methods:
traverse : Applicativef => (a -> fb) -> ta -> f (tb)
  Map each element of a structure to a computation, evaluate those
computations and combine the results.

Implementations:
TraversableMaybe
Traversable (Eithere)
TraversableList
all : Foldablet => (a -> Bool) -> ta -> Bool
  The disjunction of the collective results of applying a predicate to all
elements of a structure. `all` short-circuits from left to right.

Totality: total
and : Foldablet => t Lazy Bool -> Bool
  The conjunction of all elements of a structure containing lazy boolean
values. `and` short-circuits from left to right, evaluating until either an
element is `False` or no elements remain.

Totality: total
any : Foldablet => (a -> Bool) -> ta -> Bool
  The disjunction of the collective results of applying a predicate to all
elements of a structure. `any` short-circuits from left to right.

Totality: total
bifoldl : Bifoldablep => (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> pab -> acc
Totality: total
bifoldr : Bifoldablep => (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> pab -> acc
Totality: total
bifor : (Bitraversablep, Applicativef) => pab -> (a -> fc) -> (b -> fd) -> f (pcd)
  Like `bitraverse` but with the arguments flipped.

Totality: total
bimap : Bifunctorf => (a -> c) -> (b -> d) -> fab -> fcd
  The action of the Bifunctor on pairs of morphisms

````idris example
bimap (\x => x + 1) reverse (1, "hello") == (2, "olleh")
````

Totality: total
binull : Bifoldablep => pab -> Lazy Bool
Totality: total
bisequence : (Bitraversablep, Applicativef) => p (fa) (fb) -> f (pab)
  Evaluate each computation in a structure and collect the results.

Totality: total
bitraverse : Bitraversablep => Applicativef => (a -> fc) -> (b -> fd) -> pab -> f (pcd)
  Map each element of a structure to a computation, evaluate those
computations and combine the results.

Totality: total
choice : (Foldablet, Alternativef) => t Lazy (fa) -> fa
  Fold using Alternative.

If you have a left-biased alternative operator `<|>`, then `choice` performs
left-biased choice from a list of alternatives, which means that it
evaluates to the left-most non-`empty` alternative.

If the list is empty, or all values in it are `empty`, then it evaluates to
`empty`.

Example:

```
-- given a parser expression like:
expr = literal <|> keyword <|> funcall

-- choice lets you write this as:
expr = choice [literal, keyword, funcall]
```

Note: In Haskell, `choice` is called `asum`.

Totality: total
choiceMap : (Foldablet, Alternativef) => (a -> fb) -> ta -> fb
  A fused version of `choice` and `map`.

Totality: total
concat : (Foldablet, Monoida) => ta -> a
  Combine each element of a structure into a monoid.

Totality: total
concatMap : (Foldablet, Monoidm) => (a -> m) -> ta -> m
  Combine into a monoid the collective results of applying a function to each
element of a structure.

Totality: total
empty : Alternativef => fa
Totality: total
foldMap : Foldablet => Monoidm => (a -> m) -> ta -> m
  Maps each element to a value and combine them.
For performance reasons, this should wherever
be implemented with tail recursion.
@ f The function to apply to each element.

Totality: total
foldl : Foldablet => (acc -> elem -> acc) -> acc -> telem -> acc
  The same as `foldr` but begins the folding from the element at the initial
position in the data structure i.e. the left-most position.
@ func The function used to 'fold' an element into the accumulated result
@ init The starting value the results are being combined into
@ input The parameterised type

Totality: total
foldlM : Foldablet => Monadm => (acc -> elem -> macc) -> acc -> telem -> macc
  Similar to `foldl`, but uses a function wrapping its result in a `Monad`.
Consequently, the final value is wrapped in the same `Monad`.

Totality: total
foldr : Foldablet => (elem -> acc -> acc) -> acc -> telem -> acc
  Successively combine the elements in a parameterised type using the
provided function, starting with the element that is in the final position
i.e. the right-most position.
@ func The function used to 'fold' an element into the accumulated result
@ init The starting value the results are being combined into
@ input The parameterised type

Totality: total
for : (Traversablet, Applicativef) => ta -> (a -> fb) -> f (tb)
  Like `traverse` but with the arguments flipped.

Totality: total
for_ : (Foldablet, Applicativef) => ta -> (a -> fb) -> f ()
  Like `traverse_` but with the arguments flipped.

Totality: total
guard : Alternativef => Bool -> f ()
  `guard a` is `pure ()` if `a` is `True` and `empty` if `a` is `False`.

Totality: total
ignore : Functorf => fa -> f ()
  Run something for effects, throwing away the return value.

Totality: total
join : Monadm => m (ma) -> ma
  Also called `flatten` or mu.

Totality: total
map : Functorf => (a -> b) -> fa -> fb
  Apply a function across everything of type 'a' in a parameterised type
@ f the parameterised type
@ func the function to apply

Totality: total
mapFst : Bifunctorf => (a -> c) -> fab -> fcb
  The action of the Bifunctor on morphisms pertaining to the first object

````idris example
mapFst (\x => x + 1) (1, "hello") == (2, "hello")
````

Totality: total
mapHom : Bifunctorf => (a -> b) -> faa -> fbb
Totality: total
mapSnd : Bifunctorf => (b -> d) -> fab -> fad
  The action of the Bifunctor on morphisms pertaining to the second object

````idris example
mapSnd reverse (1, "hello") == (1, "olleh")
````

Totality: total
neutral : Monoidty => ty
Totality: total
null : Foldablet => telem -> Lazy Bool
  Test whether the structure is empty.
@ acc The accumulator value which is specified to be lazy

Totality: total
or : Foldablet => t Lazy Bool -> Bool
  The disjunction of all elements of a structure containing lazy boolean
values. `or` short-circuits from left to right, evaluating either until an
element is `True` or no elements remain.

Totality: total
product : (Foldablet, Numa) => ta -> a
  Multiply together all elements of a structure.

Totality: total
product' : (Foldablet, Numa) => ta -> a
  Multiply together all elements of a structure.
Same as `product` but tail recursive.

Totality: total
pure : Applicativef => a -> fa
Totality: total
sequence : (Traversablet, Applicativef) => t (fa) -> f (ta)
  Evaluate each computation in a structure and collect the results.

Totality: total
sequence_ : (Foldablet, Applicativef) => t (fa) -> f ()
  Evaluate each computation in a structure and discard the results.

Totality: total
sum : (Foldablet, Numa) => ta -> a
  Add together all the elements of a structure.

Totality: total
sum' : (Foldablet, Numa) => ta -> a
  Add together all the elements of a structure.
Same as `sum` but tail recursive.

Totality: total
toList : Foldablet => telem -> Listelem
  Produce a list of the elements contained in the parametrised type.

Totality: total
traverse : Traversablet => Applicativef => (a -> fb) -> ta -> f (tb)
  Map each element of a structure to a computation, evaluate those
computations and combine the results.

Totality: total
traverse_ : (Foldablet, Applicativef) => (a -> fb) -> ta -> f ()
  Map each element of a structure to a computation, evaluate those
computations and discard the results.

Totality: total
unless : Applicativef => Bool -> Lazy (f ()) -> f ()
  Execute an applicative expression unless the boolean is true.

Totality: total
when : Applicativef => Bool -> Lazy (f ()) -> f ()
  Conditionally execute an applicative expression when the boolean is true.

Totality: total