matryoshka

Value Members

1. object EqualT extends Serializable

   

2. object ShowT extends Serializable

   

3. def coEnvHmap[F[_], G[_], A](f: ~>[F, G]): ~>[[γ$9$]CoEnv[A, F, γ$9$], [γ$10$]CoEnv[A, G, γ$10$]]

   

4. def coEnvHtraverse[G[_], F[_], H[_], A](f: ~>[F, [A]G[H[A]]])(implicit arg0: Applicative[G]): ~>[[γ$13$]CoEnv[A, F, γ$13$], [A]G[CoEnv[A, H, A]]]

   

5. implicit def coenvFunctor[F[_], E](implicit arg0: Functor[F]): Functor[[γ$42$]CoEnv[E, F, γ$42$]]

   

   Definition Classes

   CoEnvInstances

6. implicit def coenvTraverse[F[_], E](implicit arg0: Traverse[F]): Traverse[[γ$41$]CoEnv[E, F, γ$41$]]

   

   Definition Classes

   LowPriorityCoEnvImplicits

7. def distTraverse[F[_], G[_]](implicit arg0: Traverse[F], arg1: Applicative[G]): DistributiveLaw[F, G]

   

8. def elgotM[M[_], F[_], A, B](a: A)(φ: (F[B]) ⇒ M[B], ψ: (A) ⇒ M[\/[B, F[A]]])(implicit arg0: Monad[M], arg1: Traverse[F]): M[B]

   

9. implicit def envtEqual[E, F[_]](implicit arg0: Equal[E], F: Delay[Equal, F]): Delay[Equal, [γ$33$]EnvT[E, F, γ$33$]]

   

10. def envtHmap[F[_], G[_], E, A](f: ~>[F, G]): ~>[[γ$15$]EnvT[E, F, γ$15$], [γ$16$]EnvT[E, G, γ$16$]]

    

11. def envtHtraverse[G[_], F[_], H[_], A](f: ~>[F, [A]G[H[A]]])(implicit arg0: Applicative[G]): ~>[[γ$19$]EnvT[A, F, γ$19$], [A]G[EnvT[A, H, A]]]

    

12. def envtLowerNT[F[_], E]: ~>[[γ$39$]EnvT[E, F, γ$39$], F]

    

13. implicit def envtShow[E, F[_]](implicit arg0: Show[E], F: Delay[Show, F]): Delay[Show, [γ$35$]EnvT[E, F, γ$35$]]

    

14. implicit def envtTraverse[F[_], X](implicit arg0: Traverse[F]): Traverse[[γ$37$]EnvT[X, F, γ$37$]]

    

15. implicit def equalTEqual[T[_[_]], F[_]](implicit T: EqualT[T], F: Delay[Equal, F]): Equal[T[F]]

    

16. def freeCata[F[_], E, A](free: Free[F, E])(φ: Algebra[[γ$4$]CoEnv[E, F, γ$4$], A])(implicit arg0: Functor[F]): A

    

17. def freeCataM[M[_], F[_], E, A](free: Free[F, E])(φ: AlgebraM[M, [γ$5$]CoEnv[E, F, γ$5$], A])(implicit arg0: Monad[M], arg1: Traverse[F]): M[A]

    

18. def freeGcataM[W[_], M[_], F[_], E, A](free: Free[F, E])(k: DistributiveLaw[[γ$6$]CoEnv[E, F, γ$6$], W], φ: GAlgebraM[W, M, [γ$7$]CoEnv[E, F, γ$7$], A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], arg3: Traverse[F]): M[A]

    

19. def freeTransCata[T[_[_]], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$23$]CoEnv[B, G, γ$23$]]]) ⇒ CoEnv[B, G, T[[γ$24$]CoEnv[B, G, γ$24$]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Functor[G]): Free[G, B]

    

    Applies a transformation over Free, treating it like T[CoEnv].

20. def freeTransCataM[T[_[_]], M[_], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$26$]CoEnv[B, G, γ$26$]]]) ⇒ M[CoEnv[B, G, T[[γ$27$]CoEnv[B, G, γ$27$]]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Monad[M], arg3: Traverse[F], arg4: Functor[G]): M[Free[G, B]]

    

21. def freeTransFutu[T[_[_]], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$30$]CoEnv[A, F, γ$30$]]]) ⇒ CoEnv[B, G, Free[[γ$32$]CoEnv[B, G, γ$32$], T[[γ$31$]CoEnv[A, F, γ$31$]]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Traverse[G]): Free[G, B]

    

22. def ginterpretM[W[_], M[_], F[_], A, B](f: (A) ⇒ M[B], φ: GAlgebraM[W, M, F, B]): GAlgebraM[W, M, [γ$2$]CoEnv[A, F, γ$2$], B]

    

23. def interpret[F[_], A, B](f: (A) ⇒ B, φ: Algebra[F, B]): Algebra[[γ$0$]CoEnv[A, F, γ$0$], B]

    

    Algebra transformation that allows a standard algebra to be used on a CoEnv structure (given a function that converts the leaves to the result type).

24. def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$1$]CoEnv[A, F, γ$1$], B]

    

25. def recover[F[_], A](φ: Algebra[F, A]): Algebra[[γ$3$]CoEnv[A, F, γ$3$], A]

    

    A specialization of interpret where the leaves are of the result type.

26. implicit def showTShow[T[_[_]], F[_]](implicit T: ShowT[T], F: Delay[Show, F]): Show[T[F]]

    

27. def substitute[T[_[_]], F[_]](original: T[F], replacement: T[F])(implicit T: Equal[T[F]]): (T[F]) ⇒ \/[T[F], T[F]]

    

28. def transApoT[T[_[_]], F[_]](t: T[F])(f: (T[F]) ⇒ \/[T[F], T[F]])(implicit arg0: FunctorT[T], arg1: Functor[F]): T[F]

    

29. def transFutu[T[_[_]], F[_], G[_]](t: T[F])(f: GCoalgebraicTransform[T, [β$29$]Free[G, β$29$], F, G])(implicit arg0: FunctorT[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Traverse[G]): T[G]