JSPM

@effect/typeclass

0.38.0
  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 58657
  • Score
    100M100P100Q157253F
  • License MIT

A collection of reusable typeclasses for the Effect ecosystem

Package Exports

  • @effect/typeclass
  • @effect/typeclass/Alternative
  • @effect/typeclass/Applicative
  • @effect/typeclass/Bicovariant
  • @effect/typeclass/Bounded
  • @effect/typeclass/Chainable
  • @effect/typeclass/Contravariant
  • @effect/typeclass/Coproduct
  • @effect/typeclass/Covariant
  • @effect/typeclass/Filterable
  • @effect/typeclass/FlatMap
  • @effect/typeclass/Foldable
  • @effect/typeclass/Invariant
  • @effect/typeclass/Monad
  • @effect/typeclass/Monoid
  • @effect/typeclass/Of
  • @effect/typeclass/Pointed
  • @effect/typeclass/Product
  • @effect/typeclass/SemiAlternative
  • @effect/typeclass/SemiApplicative
  • @effect/typeclass/SemiCoproduct
  • @effect/typeclass/SemiProduct
  • @effect/typeclass/Semigroup
  • @effect/typeclass/Traversable
  • @effect/typeclass/TraversableFilterable
  • @effect/typeclass/data/Array
  • @effect/typeclass/data/BigInt
  • @effect/typeclass/data/Boolean
  • @effect/typeclass/data/Duration
  • @effect/typeclass/data/Effect
  • @effect/typeclass/data/Either
  • @effect/typeclass/data/Identity
  • @effect/typeclass/data/Micro
  • @effect/typeclass/data/Number
  • @effect/typeclass/data/Option
  • @effect/typeclass/data/Ordering
  • @effect/typeclass/data/Predicate
  • @effect/typeclass/data/Record
  • @effect/typeclass/data/String
  • @effect/typeclass/data/Tuple
  • @effect/typeclass/index
  • @effect/typeclass/package.json

Readme

Introduction

Welcome to the documentation for @effect/typeclass, a collection of re-usable typeclasses for the Effect ecosystem.

The functional abstractions in @effect/typeclass can be broadly divided into two categories.

  • Abstractions For Concrete Types - These abstractions define properties of concrete types, such as number and string, as well as ways of combining those values.
  • Abstractions For Parameterized Types - These abstractions define properties of parameterized types such as ReadonlyArray and Option and ways of combining them.

Concrete Types

Members and derived functions

Note: members are in bold.

Bounded

A type class used to name the lower limit and the upper limit of a type.

Extends:

  • Order
Name Given To
maxBound A
minBound A
reverse Bounded<A> Bounded<A>
clamp A A

Monoid

A Monoid is a Semigroup with an identity. A Monoid is a specialization of a Semigroup, so its operation must be associative. Additionally, x |> combine(empty) == empty |> combine(x) == x. For example, if we have Monoid<String>, with combine as string concatenation, then empty = "".

Extends:

  • Semigroup
Name Given To
empty A
combineAll Iterable<A> A
reverse Monoid<A> Monoid<A>
tuple [Monoid<A>, Monoid<B>, ...] Monoid<[A, B, ...]>
struct { a: Monoid<A>, b: Monoid<B>, ... } Monoid<{ a: A, b: B, ... }>
min Bounded<A> Monoid<A>
max Bounded<A> Monoid<A>

Semigroup

A Semigroup is any set A with an associative operation (combine):

x |> combine(y) |> combine(z) == x |> combine(y |> combine(z))

Name Given To
combine A, A A
combineMany A, Iterable<A> A
reverse Semigroup<A> Semigroup<A>
tuple [Semigroup<A>, Semigroup<B>, ...] Semigroup<[A, B, ...]>
struct { a: Semigroup<A>, b: Semigroup<B>, ... } Semigroup<{ a: A, b: B, ... }>
min Order<A> Semigroup<A>
max Order<A> Semigroup<A>
constant A Semigroup<A>
intercalate A, Semigroup<A> Semigroup<A>
first Semigroup<A>
last Semigroup<A>

Parameterized Types

Parameterized Types Hierarchy

flowchart TD
    Alternative --> SemiAlternative
    Alternative --> Coproduct
    Applicative --> Product
    Coproduct --> SemiCoproduct
    SemiAlternative --> Covariant
    SemiAlternative --> SemiCoproduct
    SemiApplicative --> SemiProduct
    SemiApplicative --> Covariant
    Applicative --> SemiApplicative
    Chainable --> FlatMap
    Chainable ---> Covariant
    Monad --> FlatMap
    Monad --> Pointed
    Pointed --> Of
    Pointed --> Covariant
    Product --> SemiProduct
    Product --> Of
    SemiProduct --> Invariant
    Covariant --> Invariant
    SemiCoproduct --> Invariant

Members and derived functions

Note: members are in bold.

Alternative

Extends:

  • SemiAlternative
  • Coproduct

Applicative

Extends:

  • SemiApplicative
  • Product
Name Given To
liftMonoid Monoid<A> Monoid<F<A>>

Bicovariant

A type class of types which give rise to two independent, covariant functors.

Name Given To
bimap F<E1, A>, E1 => E2, A => B F<E2, B>
mapLeft F<E1, A>, E1 => E2 F<E2, A>
map F<A>, A => B F<B>

Chainable

Extends:

  • FlatMap
  • Covariant
Name Given To
tap F<A>, A => F<B> F<A>
andThenDiscard F<A>, F<B> F<A>
bind F<A>, name: string, A => F<B> F<A & { [name]: B }>

Contravariant

Contravariant functors.

Extends:

  • Invariant
Name Given To
contramap F<A>, B => A F<B>
contramapComposition F<G<A>>, A => B F<G<B>>
imap contramap imap

Coproduct

Coproduct is a universal monoid which operates on kinds.

This type class is useful when its type parameter F<_> has a structure that can be combined for any particular type, and which also has a "zero" representation. Thus, Coproduct is like a Monoid for kinds (i.e. parametrized types).

A Coproduct<F> can produce a Monoid<F<A>> for any type A.

Here's how to distinguish Monoid and Coproduct:

  • Monoid<A> allows A values to be combined, and also means there is an "empty" A value that functions as an identity.

  • Coproduct<F> allows two F<A> values to be combined, for any A. It also means that for any A, there is an "zero" F<A> value. The combination operation and zero value just depend on the structure of F, but not on the structure of A.

Extends:

  • SemiCoproduct
Name Given To
zero F<A>
coproductAll Iterable<F<A>> F<A>
getMonoid Monoid<F<A>>

Covariant

Covariant functors.

Extends:

  • Invariant
Name Given To
map F<A>, A => B F<B>
mapComposition F<G<A>>, A => B F<G<B>>
imap map imap
flap A, F<A => B> F<B>
as F<A>, B F<B>
asUnit F<A> F<void>

Filterable

Filterable<F> allows you to map and filter out elements simultaneously.

Name Given To
partitionMap F<A>, A => Either<B, C> [F<B>, F<C>]
filterMap F<A>, A => Option<B> F<B>
compact F<Option<A>> F<A>
separate F<Either<A, B>> [F<A>, F<B>]
filter F<A>, A => boolean F<A>
partition F<A>, A => boolean [F<A>, F<A>]
partitionMapComposition F<G<A>>, A => Either<B, C> [F<G<B>>, F<G<C>>]
filterMapComposition F<G<A>>, A => Option<B> F<G<B>>

FlatMap

Name Given To
flatMap F<A>, A => F<B> F<B>
flatten F<F<A>> F<A>
andThen F<A>, F<B> F<B>
composeKleisliArrow A => F<B>, B => F<C> A => F<C>

Foldable

Data structures that can be folded to a summary value.

In the case of a collection (such as ReadonlyArray), these methods will fold together (combine) the values contained in the collection to produce a single result. Most collection types have reduce methods, which will usually be used by the associated Foldable<F> instance.

Name Given To
reduce F<A>, B, (B, A) => B B
reduceComposition F<G<A>>, B, (B, A) => B B
reduceRight F<A>, B, (B, A) => B B
foldMap F<A>, Monoid<M>, A => M M
toReadonlyArray F<A> ReadonlyArray<A>
toReadonlyArrayWith F<A>, A => B ReadonlyArray<B>
reduceKind Monad<G>, F<A>, B, (B, A) => G<B> G<B>
reduceRightKind Monad<G>, F<A>, B, (B, A) => G<B> G<B>
foldMapKind Coproduct<G>, F<A>, (A) => G<B> G<B>

Invariant

Invariant functors.

Name Given To
imap F<A>, A => B, B => A F<B>
imapComposition F<G<A>>, A => B, B => A F<G<B>>
bindTo F<A>, name: string F<{ [name]: A }>
tupled F<A> F<[A]>

Monad

Allows composition of dependent effectful functions.

Extends:

  • FlatMap
  • Pointed

Of

Name Given To
of A F<A>
ofComposition A F<G<A>>
unit F<void>
Do F<{}>

Pointed

Extends:

  • Covariant
  • Of

Product

Extends:

  • SemiProduct
  • Of
Name Given To
productAll Iterable<F<A>> F<ReadonlyArray<A>>
tuple [F<A>, F<B>, ...] F<[A, B, ...]>
struct { a: F<A>, b: F<B>, ... } F<{ a: A, b: B, ... }>

SemiAlternative

Extends:

  • SemiCoproduct
  • Covariant

SemiApplicative

Extends:

  • SemiProduct
  • Covariant
Name Given To
liftSemigroup Semigroup<A> Semigroup<F<A>>
ap F<A => B>, F<A> F<B>
andThenDiscard F<A>, F<B> F<A>
andThen F<A>, F<B> F<B>
lift2 (A, B) => C (F<A>, F<B>) => F<C>
lift3 (A, B, C) => D (F<A>, F<B>, F<C>) => F<D>

SemiCoproduct

SemiCoproduct is a universal semigroup which operates on kinds.

This type class is useful when its type parameter F<_> has a structure that can be combined for any particular type. Thus, SemiCoproduct is like a Semigroup for kinds (i.e. parametrized types).

A SemiCoproduct<F> can produce a Semigroup<F<A>> for any type A.

Here's how to distinguish Semigroup and SemiCoproduct:

  • Semigroup<A> allows two A values to be combined.

  • SemiCoproduct<F> allows two F<A> values to be combined, for any A. The combination operation just depends on the structure of F, but not the structure of A.

Extends:

  • Invariant
Name Given To
coproduct F<A>, F<B> F<A | B>
coproductMany Iterable<F<A>> F<A>
getSemigroup Semigroup<F<A>>
coproductEither F<A>, F<B> F<Either<A, B>>

SemiProduct

Extends:

  • Invariant
Name Given To
product F<A>, F<B> F<[A, B]>
productMany F<A>, Iterable<F<A>> F<[A, ...ReadonlyArray<A>]>
productComposition F<G<A>>, F<G<B>> F<G<[A, B]>>
productManyComposition F<G<A>>, Iterable<F<G<A>>> F<G<[A, ...ReadonlyArray<A>]>>
nonEmptyTuple [F<A>, F<B>, ...] F<[A, B, ...]>
nonEmptyStruct { a: F<A>, b: F<B>, ... } F<{ a: A, b: B, ... }>
andThenBind F<A>, name: string, F<B> F<A & { [name]: B }>
productFlatten F<A>, F<B> F<[...A, B]>

Traversable

Traversal over a structure with an effect.

Name Given To
traverse Applicative<F>, T<A>, A => F<B> F<T<B>>
traverseComposition Applicative<F>, T<G<A>>, A => F<B> F<T<G<B>>>
sequence Applicative<F>, T<F<A>> F<T<A>>
traverseTap Applicative<F>, T<A>, A => F<B> F<T<A>>

TraversableFilterable

TraversableFilterable, also known as Witherable, represents list-like structures that can essentially have a traverse and a filter applied as a single combined operation (traverseFilter).

Name Given To
traversePartitionMap Applicative<F>, T<A>, A => F<Either<B, C>> F<[T<B>, T<C>]>
traverseFilterMap Applicative<F>, T<A>, A => F<Option<B>> F<T<B>>
traverseFilter Applicative<F>, T<A>, A => F<boolean> F<T<A>>
traversePartition Applicative<F>, T<A>, A => F<boolean> F<[T<A>, T<A>]>

Adapted from: