Value Members

1.  implicit def AlgebraMZip[M[_], F[_]](implicit arg0: Applicative[M], arg1: Functor[F]): Zip[[γ$6$](F[γ$6$]) ⇒ M[γ$6$]]
2.  def applyTransforms[A](first: (A) ⇒ slamdata.Predef.Option[A], rest: (A) ⇒ slamdata.Predef.Option[A]*): (A) ⇒ slamdata.Predef.Option[A]

   Chains multiple transformations together, each of which can fail to change anything.

3.  def birecursiveIso[T, F[_]](implicit arg0: Functor[F], TC: Aux[T, F], TR: Aux[T, F]): Iso[T, F[T]]
4.  implicit def coproductOrder[F[_], G[_]](implicit F: Delay[Order, F], G: Delay[Order, G]): Delay[Order, [γ$4$]Coproduct[F, G, γ$4$]]
5.  implicit def delayOrder[F[_], A](implicit F: Delay[Order, F], A: Order[A]): Order[F[A]]
6.  def einterpret[W[_], F[_], A, B](f: (A) ⇒ B, φ: ElgotAlgebra[W, F, B])(implicit arg0: Traverse[W]): ElgotAlgebra[W, [γ$1$]CoEnv[A, F, γ$1$], B]
7.  def envT[E, W[_], A](e: E, wa: W[A]): EnvT[E, W, A]
8.  def envTIso[E, W[_], A]: Iso[EnvT[E, W, A], (E, W[A])]
9.  def forgetRecursive[T, E, F[_]](implicit T: Aux[T, [γ$2$]EnvT[E, F, γ$2$]]): Aux[T, F]

   Derive a recursive instance over the functor transformed by EnvT by forgetting the annotation.

10.  implicit def freeEqualT[A](implicit arg0: Equal[A]): EqualT[[α$10$[_$1]]Free[α$10$, A]]
11.  def ginterpret[W[_], F[_], A, B](f: (A) ⇒ B, φ: GAlgebra[W, F, B]): GAlgebra[W, [γ$0$]CoEnv[A, F, γ$0$], B]
12.  def project[T, F[_]](implicit arg0: Functor[F], T: Aux[T, F]): Getter[T, F[T]]
13.  def rememberCorecursive[T, E, F[_]](implicit arg0: Monoid[E], T: Aux[T, [γ$3$]EnvT[E, F, γ$3$]]): Aux[T, F]

    Derive a corecursive instance over the functor transformed by EnvT using the zero of the annotation monoid.

14.  def selfAndChildren[F[_], A](alg: Algebra[F, A])(implicit arg0: Functor[F], arg1: Foldable[F]): Algebra[F, (A, slamdata.Predef.List[A])]
15.  def totally[A](pf: slamdata.Predef.PartialFunction[A, A]): (A) ⇒ A

    Make a partial endomorphism total by returning the argument when undefined.

16.  def transHyloM[T, F[_], G[_], U, H[_], M[_]](t: T)(φ: (G[U]) ⇒ M[H[U]], ψ: (F[T]) ⇒ M[G[T]])(implicit arg0: Traverse[G], arg1: Traverse[H], arg2: Monad[M], T: Aux[T, F], U: Aux[U, H], BF: Traverse[F]): M[U]

    Annotations

    @SuppressWarnings()

17.  object OrderR
18.  object convertToFree