p
matryoshka
package matryoshka
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- matryoshka
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Type Members
- type Algebra[F[_], A] = (F[A]) ⇒ A
- type AlgebraIso[F[_], A] = PIso[F[scalaz.Scalaz.Id[A]], F[scalaz.Scalaz.Id[A]], A, A]
- type AlgebraM[M[_], F[_], A] = (F[A]) ⇒ M[A]
- type AlgebraPrism[F[_], A] = PPrism[F[A], F[A], A, A]
- type AlgebraicGTransform[W[_], T, F[_], G[_]] = (F[W[T]]) ⇒ G[T]
- type AlgebraicGTransformM[W[_], M[_], T, F[_], G[_]] = (F[W[T]]) ⇒ M[G[T]]
- type Coalgebra[F[_], A] = (A) ⇒ F[A]
- type CoalgebraM[M[_], F[_], A] = (A) ⇒ M[F[A]]
- type CoalgebraPrism[F[_], A] = PPrism[A, A, F[A], F[A]]
- type CoalgebraicElgotTransform[N[_], T, F[_], G[_]] = (F[T]) ⇒ N[G[T]]
- type CoalgebraicGTransform[N[_], T, F[_], G[_]] = (F[T]) ⇒ G[N[T]]
- type CoalgebraicGTransformM[N[_], M[_], T, F[_], G[_]] = (F[T]) ⇒ M[G[N[T]]]
- type DistributiveLaw[F[_], G[_]] = NaturalTransformation[[A]F[G[A]], [A]G[F[A]]]
- type ElgotAlgebra[W[_], F[_], A] = (W[F[A]]) ⇒ scalaz.Scalaz.Id[A]
- type ElgotAlgebraIso[W[_], N[_], F[_], A] = PIso[W[F[A]], N[F[A]], A, A]
- type ElgotAlgebraM[W[_], M[_], F[_], A] = (W[F[A]]) ⇒ M[A]
- type ElgotCoalgebra[E[_], F[_], A] = (A) ⇒ E[F[A]]
- type ElgotCoalgebraM[E[_], M[_], F[_], A] = (A) ⇒ M[E[F[A]]]
- type EndoTransform[T, F[_]] = (F[T]) ⇒ F[T]
- type GAlgebra[W[_], F[_], A] = (F[W[A]]) ⇒ A
- type GAlgebraIso[W[_], N[_], F[_], A] = PIso[F[W[A]], F[N[A]], A, A]
- type GAlgebraM[W[_], M[_], F[_], A] = (F[W[A]]) ⇒ M[A]
- type GCoalgebra[N[_], F[_], A] = (A) ⇒ F[N[A]]
- type GCoalgebraM[N[_], M[_], F[_], A] = (A) ⇒ M[F[N[A]]]
- type Transform[T, F[_], G[_]] = (F[T]) ⇒ G[T]
- type TransformM[M[_], T, F[_], G[_]] = (F[T]) ⇒ M[G[T]]
Value Members
- implicit def AlgebraZip[F[_]](implicit arg0: Functor[F]): Zip[[γ$44$](F[scalaz.Scalaz.Id[γ$44$]]) ⇒ γ$44$]
- implicit def ElgotAlgebraMZip[W[_], M[_], F[_]](implicit arg0: Functor[W], arg1: Applicative[M], arg2: Functor[F]): Zip[[δ$46$](W[F[δ$46$]]) ⇒ M[δ$46$]]
- implicit def ElgotAlgebraZip[W[_], F[_]](implicit arg0: Functor[W], arg1: Functor[F]): Zip[[δ$46$](W[F[δ$46$]]) ⇒ scalaz.Scalaz.Id[δ$46$]]
- implicit def GAlgebraZip[W[_], F[_]](implicit arg0: Functor[W], arg1: Functor[F]): Zip[[γ$44$](F[W[γ$44$]]) ⇒ γ$44$]
- def alignThese[T, F[_]](implicit arg0: Align[F], T: Aux[T, F]): ElgotCoalgebra[[β$51$]\/[T, β$51$], F, \&/[T, T]]
- def attrK[F[_], A](k: A)(implicit arg0: Functor[F]): Algebra[F, Cofree[F, A]]
- def attrSelf[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): Algebra[F, Cofree[F, T]]
- def attributeAlgebra[F[_], A](f: Algebra[F, A])(implicit arg0: Functor[F]): Algebra[F, Cofree[F, A]]
- def attributeAlgebraM[F[_], M[_], A](f: AlgebraM[M, F, A])(implicit arg0: Functor[F], arg1: Functor[M]): AlgebraM[M, F, Cofree[F, A]]
- def attributeCoalgebra[F[_], B](ψ: Coalgebra[F, B]): Coalgebra[[γ$35$]EnvT[B, F, γ$35$], B]
- def binarySequence[A](relation: (A, A) ⇒ A): Coalgebra[[β$52$](A, β$52$), (A, A)]
- implicit def birecursiveTBirecursive[T[_[_]], F[_]](implicit arg0: BirecursiveT[T]): Aux[T[F], F]
- implicit def birecursiveTFunctor[T[_[_]], F[_, _]](implicit arg0: BirecursiveT[T], F: Bifunctor[F]): Functor[[α]T[[β$53$]F[α, β$53$]]]
- def builder[F[_], A, B](fa: F[A], children: slamdata.Predef.List[B])(implicit arg0: Traverse[F]): F[B]
- def chrono[F[_], A, B](a: A)(g: GAlgebra[[β$6$]Cofree[F, β$6$], F, B], f: GCoalgebra[[β$7$]Free[F, β$7$], F, A])(implicit arg0: Functor[F]): B
- def codyna[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: GCoalgebra[[β$1$]Free[F, β$1$], F, A])(implicit arg0: Functor[F]): B
- def codynaM[M[_], F[_], A, B](a: A)(φ: AlgebraM[M, F, B], ψ: GCoalgebraM[[β$3$]Free[F, β$3$], M, F, A])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]
- def coelgot[F[_], A, B](a: A)(φ: ElgotAlgebra[[β$16$](A, β$16$), F, B], ψ: Coalgebra[F, A])(implicit F: Functor[F]): B
- implicit def corecursiveTCorecursive[T[_[_]], F[_]](implicit arg0: CorecursiveT[T]): Aux[T[F], F]
- def count[T, F[_]](form: T)(implicit arg0: Equal[T], arg1: Functor[F], arg2: Foldable[F], T: Aux[T, F]): ElgotAlgebra[[β$50$](T, β$50$), F, slamdata.Predef.Int]
- def deattribute[F[_], A, B](φ: Algebra[F, B]): Algebra[[γ$36$]EnvT[A, F, γ$36$], B]
- implicit def delayEqual[F[_], A](implicit A: Equal[A], F: Delay[Equal, F]): Equal[F[A]]
- implicit def delayShow[F[_], A](implicit A: Show[A], F: Delay[Show, F]): Show[F[A]]
- def distAna[F[_]]: DistributiveLaw[scalaz.Scalaz.Id, F]
- def distApo[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): DistributiveLaw[[β$29$]\/[T, β$29$], F]
- def distApplicative[F[_], G[_]](implicit arg0: Traverse[F], arg1: Applicative[G]): DistributiveLaw[F, G]
- def distCata[F[_]]: DistributiveLaw[F, scalaz.Scalaz.Id]
- def distDistributive[F[_], G[_]](implicit arg0: Functor[F], arg1: Distributive[G]): DistributiveLaw[F, G]
- def distFutu[F[_]](implicit arg0: Functor[F]): DistributiveLaw[[β$32$]Free[F, β$32$], F]
- def distGApo[F[_], B](g: Coalgebra[F, B])(implicit arg0: Functor[F]): DistributiveLaw[[β$30$]\/[B, β$30$], F]
- def distGApoT[F[_], M[_], B](g: Coalgebra[F, B], k: DistributiveLaw[M, F])(implicit arg0: Functor[F], arg1: Functor[M]): DistributiveLaw[[γ$31$]EitherT[M, B, γ$31$], F]
- def distGFutu[H[_], F[_]](k: DistributiveLaw[H, F])(implicit arg0: Functor[H], F: Functor[F]): DistributiveLaw[[β$33$]Free[H, β$33$], F]
- def distGHisto[F[_], H[_]](k: DistributiveLaw[F, H])(implicit arg0: Functor[F], arg1: Functor[H]): DistributiveLaw[F, [β$28$]Cofree[H, β$28$]]
- def distHisto[F[_]](implicit arg0: Functor[F]): DistributiveLaw[F, [β$27$]Cofree[F, β$27$]]
- def distPara[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): DistributiveLaw[F, [β$22$](T, β$22$)]
- def distParaT[T, W[_], F[_]](t: DistributiveLaw[F, W])(implicit arg0: Comonad[W], arg1: Functor[F], T: Aux[T, F]): DistributiveLaw[F, [γ$23$]EnvT[T, W, γ$23$]]
- def distZygo[F[_], B](g: Algebra[F, B])(implicit arg0: Functor[F]): DistributiveLaw[F, [β$24$](B, β$24$)]
- def distZygoM[F[_], M[_], B](g: AlgebraM[M, F, B], k: DistributiveLaw[F, M])(implicit arg0: Functor[F], arg1: Monad[M]): DistributiveLaw[F, [A]M[(B, A)]]
- def distZygoT[F[_], W[_], B](g: Algebra[F, B], k: DistributiveLaw[F, W])(implicit arg0: Functor[F], arg1: Comonad[W]): DistributiveLaw[F, [γ$26$]EnvT[B, W, γ$26$]]
- def dyna[F[_], A, B](a: A)(φ: (F[Cofree[F, B]]) ⇒ B, ψ: Coalgebra[F, A])(implicit arg0: Functor[F]): B
- def elgot[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: ElgotCoalgebra[[β$10$]\/[B, β$10$], F, A])(implicit F: Functor[F]): B
- def elgotHylo[W[_], N[_], F[_], A, B](a: A)(kφ: DistributiveLaw[F, W], kψ: DistributiveLaw[N, F], φ: ElgotAlgebra[W, F, B], ψ: ElgotCoalgebra[N, F, A])(implicit arg0: Comonad[W], arg1: Monad[N], arg2: Functor[F]): B
- def elgotM[M[_], F[_], A, B](a: A)(φ: AlgebraM[M, F, B], ψ: ElgotCoalgebraM[[β$13$]\/[B, β$13$], M, F, A])(implicit M: Monad[M], F: Traverse[F]): M[B]
- implicit def equalTEqual[T[_[_]], F[_]](implicit arg0: Functor[F], T: EqualT[T], F: Delay[Equal, F]): Equal[T[F]]
- def find[T](f: (T) ⇒ slamdata.Predef.Boolean): (T) ⇒ \/[T, T]
- def foldIso[T, F[_], A](alg: AlgebraIso[F, A])(implicit arg0: Functor[F], T: Aux[T, F]): Iso[T, A]
- def foldPrism[T, F[_], A](alg: AlgebraPrism[F, A])(implicit arg0: Traverse[F], T: Aux[T, F]): Prism[T, A]
- def forgetAnnotation[T, R, F[_], A](t: T)(implicit arg0: Functor[F], T: Aux[T, [γ$37$]EnvT[A, F, γ$37$]], R: Aux[R, F]): R
- def ghylo[W[_], N[_], F[_], A, B](a: A)(w: DistributiveLaw[F, W], n: DistributiveLaw[N, F], f: GAlgebra[W, F, B], g: GCoalgebra[N, F, A])(implicit arg0: Comonad[W], arg1: Monad[N], arg2: Functor[F]): B
- def ghyloM[W[_], N[_], M[_], F[_], A, B](a: A)(w: DistributiveLaw[F, W], n: DistributiveLaw[N, F], f: GAlgebraM[W, M, F, B], g: GCoalgebraM[N, M, F, A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[N], arg3: Traverse[N], arg4: Monad[M], arg5: Traverse[F]): M[B]
- def height[F[_]](implicit arg0: Foldable[F]): Algebra[F, slamdata.Predef.Int]
- def holes[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): F[(A, Coalgebra[F, A])]
- def holesList[F[_], A](fa: F[A])(implicit arg0: Traverse[F]): slamdata.Predef.List[(A, Coalgebra[F, A])]
- def hylo[F[_], A, B](a: A)(φ: Algebra[F, B], ψ: Coalgebra[F, A])(implicit arg0: Functor[F]): B
- def hyloM[M[_], F[_], A, B](a: A)(f: AlgebraM[M, F, B], g: CoalgebraM[M, F, A])(implicit M: Monad[M], F: Traverse[F]): M[B]
- def join[A]: Algebra[[α]Option[(A, (α, α))], slamdata.Predef.List[A]]
- def liftT[F[_], A, B](φ: ElgotAlgebra[[β$38$](A, β$38$), F, B]): Algebra[[γ$39$]EnvT[A, F, γ$39$], B]
- def liftTM[M[_], F[_], A, B](φ: ElgotAlgebraM[[β$40$](A, β$40$), M, F, B]): AlgebraM[M, [γ$41$]EnvT[A, F, γ$41$], B]
- def mergeTuple[T, F[_]](implicit arg0: Functor[F], arg1: Merge[F], T: Aux[T, F]): CoalgebraM[slamdata.Predef.Option, F, (T, T)]
- def orDefault[A, B](default: B)(f: (A) ⇒ slamdata.Predef.Option[B]): (A) ⇒ B
- def orOriginal[A](f: (A) ⇒ slamdata.Predef.Option[A]): (A) ⇒ A
- def partition[A](implicit arg0: Order[A]): Coalgebra[[α]Option[(A, (α, α))], slamdata.Predef.List[A]]
- def project[F[_], A](index: slamdata.Predef.Int, fa: F[A])(implicit arg0: Foldable[F]): slamdata.Predef.Option[A]
- def quicksort[A](as: slamdata.Predef.List[A])(implicit arg0: Order[A]): slamdata.Predef.List[A]
- implicit def recursiveTFoldable[T[_[_]], F[_, _]](implicit arg0: RecursiveT[T], FB: Bifoldable[F], FF: Bifunctor[F]): Foldable[[α]T[[β$58$]F[α, β$58$]]]
- implicit def recursiveTRecursive[T[_[_]], F[_]](implicit arg0: RecursiveT[T]): Aux[T[F], F]
-
final
def
repeatedly[A](f: (A) ⇒ slamdata.Predef.Option[A])(expr: A): A
- Annotations
- @tailrec()
- def runT[F[_], A, B](ψ: ElgotCoalgebra[[β$42$]\/[A, β$42$], F, B]): Coalgebra[[γ$43$]CoEnv[A, F, γ$43$], B]
- implicit def showTShow[T[_[_]], F[_]](implicit arg0: Functor[F], T: ShowT[T], F: Delay[Show, F]): Show[T[F]]
- def size[F[_]](implicit arg0: Foldable[F]): Algebra[F, slamdata.Predef.Int]
- def substitute[T](original: T, replacement: T)(implicit arg0: Equal[T]): (T) ⇒ \/[T, T]
- def toTree[F[_]](implicit arg0: Functor[F], arg1: Foldable[F]): Algebra[F, Tree[F[slamdata.Predef.Unit]]]
- def unfoldPrism[T, F[_], A](coalg: CoalgebraPrism[F, A])(implicit arg0: Traverse[F], T: Aux[T, F]): Prism[A, T]
- def zipTuple[T, F[_]](implicit arg0: Functor[F], arg1: Zip[F], T: Aux[T, F]): Coalgebra[F, (T, T)]