object
Category
extends AnyRef
Type Members
-
trait
<*>
[F[_], G[_]]
extends AnyRef
-
case class
<=
[A, B]
(value: (B) ⇒ A) extends NewType[(B) ⇒ A] with Product with Serializable
-
type
<=>
[A, B]
= Iso[Function1, A, B]
-
type
<~>
[F[_], G[_]]
= Iso2[~>, F, G]
-
type
<~~>
[F[_, _], G[_, _]]
= Iso3[~~>, F, G]
-
type
Adjunction
[F[_], U[_]]
= Iso3[~~>, [A, B](F[A]) ⇒ B, [A, B](A) ⇒ U[B]]
-
type
Alpha
[Arr[_, _], X, Y]
= ~>[[α]Arr[α, X], [α]Arr[α, Y]]
-
case class
Compose
[F[_], G[_], Arr[_, _], X]
(value: F[G[X]]) extends NewType[F[G[X]]] with Product with Serializable
-
case class
Discrete
[X, A, B]
(value: (X) ⇒ X) extends NewType[(X) ⇒ X] with Product with Serializable
-
type
GeneralAdjunction
[P[_, _], Q[_, _], F[_], U[_]]
= Iso3[~~>, [A, B]P[F[A], B], [A, B]Q[A, U[B]]]
-
-
trait
GeneralizedFunctor
[C[_, _], D[_, _], F[_]]
extends AnyRef
-
case class
Iso
[Arr[_, _], A, B]
(to: Arr[A, B], from: Arr[B, A]) extends Product with Serializable
-
case class
Iso2
[Arr[_[_], _[_]], F[_], G[_]]
(to: Arr[F, G], from: Arr[G, F]) extends Product with Serializable
-
case class
Iso3
[Arr[_[_, _], _[_, _]], F[_, _], G[_, _]]
(to: Arr[F, G], from: Arr[G, F]) extends Product with Serializable
-
class
MonoidCategory
[M]
extends GeneralizedCategory with Hom
-
trait
Nat
[Arr[_, _], F[_], G[_]]
extends AnyRef
-
class
Ord2
[X, A, B]
extends AnyRef
-
trait
P
[+IX, +IY]
extends AnyRef
-
case class
ProductCategory
[UX <: Hom, UY <: Hom]
(_1: GeneralizedCategory { type U = UX }, _2: GeneralizedCategory { type U = UY }) extends GeneralizedCategory with Hom with Product with Serializable
-
trait
Reader
[R]
extends AnyRef
-
trait
Writer
[R]
extends AnyRef
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
implicit val
<:<_Category
: Category[<:<]
-
implicit val
=:=_Category
: Category[=:=]
-
def
==
(arg0: AnyRef): Boolean
-
def
==
(arg0: Any): Boolean
-
implicit def
CokleisliCategory
[M[_]]
(implicit arg0: Comonad[M]): Category[[α, β]Cokleisli[M, α, β]]
-
implicit def
ComposeContravariants
[F[_], G[_]]
(implicit arg0: Contravariant[F], arg1: Contravariant[G]): Functor[[X]Compose[F, G, <=, X]]
-
implicit def
ComposeFunctors
[F[_], G[_]]
(implicit arg0: Functor[F], arg1: Functor[G]): Functor[[X]Compose[F, G, Function1, X]]
-
implicit def
DiscreteCategory
[X]
: Category[[α, β]Discrete[X, α, β]]
-
implicit val
Function1Category
: Category[Function1]
-
implicit def
KleisliCategory
[M[_]]
(implicit arg0: Monad[M]): Category[[α, β]Kleisli[M, α, β]]
-
implicit def
MorphismToObject
[A, B, C]
(a: Const2[A, B, C]): A
-
implicit def
ObjectToMorphism
[A, B, C]
(a: A): Const2[A, Unit, Unit]
-
implicit val
OpCategory
: Category[<=]
-
implicit def
PartialFunctionCategory
: Category[PartialFunction]
-
implicit def
PosetCategory
[X]
(implicit arg0: Order[X]): Category[[α, β]Ord2[X, α, β]]
-
def
asInstanceOf
[T0]
: T0
-
def
clone
(): AnyRef
-
-
def
endoFunctorInScala
[F[_]]
(f: Functor[F]): GeneralizedFunctor[Function1, Function1, F]
-
def
eq
(arg0: AnyRef): Boolean
-
def
equals
(arg0: Any): Boolean
-
def
finalize
(): Unit
-
implicit def
flipFunctorIso
[F[_], G[_]]
(implicit i: $less$tilde$greater[F, G]): $less$tilde$greater[G, F]
-
implicit def
flipIso
[A, B]
(implicit i: $less$eq$greater[A, B]): $less$eq$greater[B, A]
-
def
getClass
(): java.lang.Class[_]
-
def
hashCode
(): Int
-
def
isInstanceOf
[T0]
: Boolean
-
implicit def
monoidCategory
[M]
(implicit arg0: Monoid[M]): MonoidCategory[M]
-
def
ne
(arg0: AnyRef): Boolean
-
implicit def
newTypeIso
[A, B <: NewType[A]]
(implicit c: (A) ⇒ B): $less$eq$greater[A, B]
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
implicit def
opContravariant
[R]
: Contravariant[[α]<=[R, α]]
-
-
implicit def
reflFunctorIso
[F[_]]
: $less$tilde$greater[F, F]
-
def
reflectIso
[A1[_, _], A2[_, _], F[_], A, B]
(implicit c1: Category[A1], c2: Category[A2], f: GeneralizedFunctor[A2, A1, F]): ($less$tilde$tilde$greater[[A, B]A1[F[A], F[B]], A2]) ⇒ (Iso[A1, F[A], F[B]]) ⇒ Iso[A2, A, B]
-
def
stateAdjunction
[S]
: Adjunction[[S](S, S), [S](S) ⇒ S]
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
toString
(): String
-
implicit def
transFunctorIso
[F[_], G[_], H[_]]
(implicit fg: $less$tilde$greater[F, G], gh: $less$tilde$greater[G, H]): $less$tilde$greater[F, H]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
Inherited from AnyRef
Inherited from Any