cat/instances/applicative
Applicative instances: Identity, Option, List, Const, Tuple, Pair, Either, Triple Writer, Reader, Function.
Values
pub fn const_monoid_applicative(
mono: monoid.Monoid(m),
) -> applicative.Applicative(
types.ConstF(m),
a,
b,
cat.Const(m, a),
cat.Const(m, b),
cat.Const(m, fn(a) -> b),
)Applicative instance for Const given Monoid instance.
Examples
{
const_monoid_applicative(all_monoid()).pure(fn(x) { x * 2 }) // True
|> const_monoid_applicative(any_monoid()).apply // ||
}(const_monoid_applicative(all_monoid()).pure(7)) // False
// -> Const(True)
pub fn either_applicative(
,
) -> applicative.Applicative(
types.EitherF(e),
a,
b,
cat.Either(e, a),
cat.Either(e, b),
cat.Either(e, fn(a) -> b),
)Applicative instance for Either.
Examples
let e_plus =
fn(x) { x + 2 }
|> either_applicative().pure()
|> either_applicative().apply()
e_plus(Left("Unexpected"))
// -> Left("Unexpected")
e_plus(Right(1))
// -> Right(3)
pub fn function_applicative(
,
) -> applicative.Applicative(
types.FunctionF(r),
a,
b,
fn(r) -> a,
fn(r) -> b,
fn(r) -> fn(a) -> b,
)Applicative instance for (->).
Examples
let ff = fn(x) { fn(y) { x * y } }
let f = fn(x) { x + 5 }
let g = function_applicative().apply(ff)(f)
g(2) // 2 * (2 + 5)
// -> 14
pub fn identity_applicative(
,
) -> applicative.Applicative(
types.IdentityF,
a,
b,
cat.Identity(a),
cat.Identity(b),
cat.Identity(fn(a) -> b),
)Applicative instance for Identity.
Examples
let identity_f =
fn(x: Int, y: String) { int.to_string(x) <> y }
|> curry()
|> identity_applicative().pure()
identity_applicative().apply(
identity_applicative().apply
(identity_f)
(Identity(6))
)(Identity(" apples"))
// -> Identity("6 apples")
pub fn list_applicative(
,
) -> applicative.Applicative(
types.ListF,
a,
b,
List(a),
List(b),
List(fn(a) -> b),
)Instance for Applicative List.
instance Applicative [] where
// pure :: a -> [a]
pure x = [x]
// (<*>) :: [a -> b] -> [a] -> [b]
fs <*> xs = [f x | f <- fs, x <- xs]
Examples
[1, 2, 3]
|> {
[fn(x) { x * 2 }, fn(x) { x + 10 }]
|> apply(list_applicative())
}
// -> [2, 4, 6, 11, 12, 13]
pub fn option_applicative(
,
) -> applicative.Applicative(
types.OptionF,
a,
b,
option.Option(a),
option.Option(b),
option.Option(fn(a) -> b),
)Instance for Applicative Option.
instance Applicative Maybe where
// pure :: a -> Maybe a
pure x = Just x
// (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b
Nothing <*> _ = Nothing
Just(f) <*> m = fmap f m
Examples
9
|> { option_applicative() |> pure() }
// -> Some(9)
let option_f =
int.to_string
|> { option_applicative() |> pure() }
|> { option_applicative() |> apply() }
None
|> option_f()
// -> None
Some(12)
|> option_f()
// -> Some("12")
pub fn pair_monoid_applicative(
mono: monoid.Monoid(m),
) -> applicative.Applicative(
types.PairF(m),
a,
b,
cat.Pair(m, a),
cat.Pair(m, b),
cat.Pair(m, fn(a) -> b),
)Applicative instance for Pair given Monoid instance.
Examples
let prod = int_prod_monoid()
{
{
fn(x) { fn(y) { x * 10 + y } }
|> pair_monoid_applicative(prod).pure()
|> pair_monoid_applicative(prod).apply()
}(Pair(3, 9))
|> pair_monoid_applicative(prod).apply()
}(Pair(4, 1))
// -> Pair(12, 91)
pub fn reader_applicative(
,
) -> applicative.Applicative(
types.ReaderF(r),
a,
b,
cat.Reader(r, a),
cat.Reader(r, b),
cat.Reader(r, fn(a) -> b),
)Applicative instance for Reader.
Examples
let rff = Reader(fn(x) { fn(y) { x * y } })
let rf = Reader(fn(x) { x + 5 })
let rg = reader_applicative().apply(rff)(rf)
rg.apply(2) // 2 * (2 + 5)
// -> 14
pub fn result_applicative(
,
) -> applicative.Applicative(
types.ResultF(e),
a,
b,
Result(a, e),
Result(b, e),
Result(fn(a) -> b, e),
)Applicative instance for Result.
Examples
let resf =
result_applicative().pure(fn(x) { x * 10 })
|> result_applicative().apply
resf(Ok(7))
// -> Ok(70)
resf(Error("Not a number"))
// -> Error("Not a number")
pub fn triple_monoid_applicative(
mono1: monoid.Monoid(c),
mono2: monoid.Monoid(d),
) -> applicative.Applicative(
types.TripleF(c, d),
a,
b,
#(c, d, a),
#(c, d, b),
#(c, d, fn(a) -> b),
)Applicative instance for Triple given 2 Monoid instances.
Examples
let sum = int_sum_monoid()
let prod = int_prod_monoid()
let triple_plus =
fn(x) { fn(y) { x + y } }
|> triple_monoid_applicative(sum, prod).pure()
|> triple_monoid_applicative(sum, prod).apply()
// Final instance for binding the generic types:
let triple = triple_monoid_applicative(sum, prod)
// Applicative function chain:
triple.apply(triple_plus(#(3, 3, 20)))(#(4, 4, 15))
// -> #(7, 12, 35)
pub fn tuple_monoid_applicative(
mono: monoid.Monoid(m),
) -> applicative.Applicative(
types.TupleF(m),
a,
b,
#(m, a),
#(m, b),
#(m, fn(a) -> b),
)Applicative instance for Tuple given Monoid instance.
Examples
let sum = int_sum_monoid()
{
{
fn(x) { fn(y) { x * 10 + y } }
|> tuple_monoid_applicative(sum).pure()
|> tuple_monoid_applicative(sum).apply()
}(#(3, 7))
|> tuple_monoid_applicative(sum).apply()
}(#(2, 4))
// -> #(5, 74)
pub fn writer_applicative(
,
) -> applicative.Applicative(
types.WriterF,
a,
b,
cat.Writer(a),
cat.Writer(b),
cat.Writer(fn(a) -> b),
)Applicative instance for Writer.
Examples
let log_plus =
Writer(fn(x) { x + 2 }, "[plus two]")
|> writer_applicative().apply()
log_plus(Writer(7, " seven"))
// -> Writer(9, "[plus two] seven")