fp - quasar.fp

Type Members

trait CatchableOps[F[_], A] extends Ops[F[A]]

Definition Classes
ToCatchableOps
type EnumT[F[_], A] = EnumeratorT[A, F]
implicit class PFOps[A, B] extends AnyRef

Definition Classes
PartialFunctionOps
implicit class PrOps[F[_], O] extends AnyRef

Definition Classes
ProcessOps
implicit class ProcessOfTaskOps[O] extends AnyRef

Definition Classes
ProcessOps
class SeqW[A] extends AnyRef

Definition Classes
ListMapInstances
implicit final class StringOps extends AnyRef

Definition Classes
StringOps
implicit class TaskOps[A] extends AnyRef

Definition Classes
ProcessOps
implicit final class ToQFoldableOps[F[_], A] extends AnyRef

Definition Classes
QFoldableOps
implicit class eitherTOps[F[_], A, B] extends AnyRef

Definition Classes
EitherTInstances

Value Members

implicit val BooleanRenderTree: RenderTree[Boolean]

Definition Classes
TreeInstances
implicit val DoubleRenderTree: RenderTree[Double]

Definition Classes
TreeInstances
implicit def EitherRenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[\/[A, B]]

Definition Classes
TreeInstances
implicit def EqualEqualF[F[_], A, FF[A] <: F[A]](implicit arg0: Equal[A], FE: EqualF[F]): Equal[FF[A]]
implicit def EqualFNT[F[_]](implicit EF: EqualF[F]): ~>[Equal, [α]Equal[F[α]]]
implicit val IntRenderTree: RenderTree[Int]

Definition Classes
TreeInstances
implicit def LeftTuple3RenderTree[A, B, C](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C]): RenderTree[((A, B), C)]

Definition Classes
LowPriorityTreeInstances
implicit def LeftTuple4RenderTree[A, B, C, D](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C], RD: RenderTree[D]): RenderTree[(((A, B), C), D)]

Definition Classes
TreeInstances
implicit def ListMapRenderTree[K, V](implicit RV: RenderTree[V]): RenderTree[ListMap[K, V]]

Definition Classes
TreeInstances
implicit def ListRenderTree[A](implicit RA: RenderTree[A]): RenderTree[List[A]]

Definition Classes
TreeInstances
implicit def OptionRenderTree[A](implicit RA: RenderTree[A]): RenderTree[Option[A]]

Definition Classes
TreeInstances
implicit def PathRenderTree[B, T, S]: RenderTree[Path[B, T, S]]

Definition Classes
TreeInstances
implicit def RenderTreeToShow[N](implicit arg0: RenderTree[N]): Show[N]

Definition Classes
TreeInstances
implicit def ShowFNT[F[_]](implicit SF: ShowF[F]): ~>[Show, [α]Show[F[α]]]
implicit def ShowShowF[F[_], A, FF[A] <: F[A]](implicit arg0: Show[A], FS: ShowF[F]): Show[FF[A]]
implicit val StringRenderTree: RenderTree[String]

Definition Classes
TreeInstances
implicit val SymbolEqual: Equal[Symbol]

Definition Classes
TreeInstances
implicit def ToCatchableOpsFromCatchable[F[_], A](a: F[A]): CatchableOps[F, A]

Definition Classes
ToCatchableOps
implicit def TraverseListMap[K]: Traverse[[β$0$]ListMap[K, β$0$]] with IsEmpty[[β$1$]ListMap[K, β$1$]]

Definition Classes
ListMapInstances
implicit def Tuple2RenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[(A, B)]

Definition Classes
LowerPriorityTreeInstances
implicit def VectorRenderTree[A](implicit RA: RenderTree[A]): RenderTree[Vector[A]]

Definition Classes
TreeInstances
def coEnvHtraverse[G[_], F[_], H[_], A, B](fa: CoEnv[A, F, B])(f: ~>[F, [A]G[H[A]]])(implicit arg0: Applicative[G]): G[CoEnv[A, H, B]]
implicit def coenvFunctor[F[_], E](implicit arg0: Functor[F]): Functor[[γ$23$]CoEnv[E, F, γ$23$]]

Definition Classes
CoEnvInstances
implicit def coenvTraverse[F[_], E](implicit arg0: Traverse[F]): Traverse[[γ$22$]CoEnv[E, F, γ$22$]]

Definition Classes
LowPriorityCoEnvImplicits
implicit def constEqual[A](implicit arg0: Equal[A]): Delay[Equal, [β$36$]Const[A, β$36$]]
implicit def constShow[A](implicit arg0: Show[A]): Delay[Show, [β$38$]Const[A, β$38$]]
implicit def coproductEqual[F[_], G[_]](implicit F: Delay[Equal, F], G: Delay[Equal, G]): Delay[Equal, [γ$32$]Coproduct[F, G, γ$32$]]
implicit def coproductShow[F[_], G[_]](implicit F: Delay[Show, F], G: Delay[Show, G]): Delay[Show, [γ$34$]Coproduct[F, G, γ$34$]]
def decodeJson[A](text: String)(implicit DA: DecodeJson[A]): \/[String, A]

Definition Classes
JsonOps
implicit def eitherTCatchable[F[_], E](implicit arg0: Catchable[F], arg1: Functor[F]): Catchable[[γ$4$]EitherT[F, E, γ$4$]]

Definition Classes
EitherTInstances
implicit def eitherTMonadState[F[_], S, E](implicit F: MonadState[F, S]): MonadState[[γ$6$]EitherT[F, E, γ$6$], S]

Definition Classes
EitherTInstances
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]
implicit def equalTEqual[T[_[_]], F[_]](implicit T: EqualT[T], F: Delay[Equal, F]): Equal[T[F]]
implicit val equalTFix: EqualT[Fix]
def evalNT[F[_], S](initial: S)(implicit arg0: Monad[F]): ~>[[γ$26$]IndexedStateT[F, S, S, γ$26$], F]
implicit def finEqual[N <: Succ[_]]: Equal[Fin[N]]
implicit def finShow[N <: Succ[_]]: Show[Fin[N]]
def freeCata[F[_], E, A](free: Free[F, E])(φ: Algebra[[γ$44$]CoEnv[E, F, γ$44$], A])(implicit arg0: Traverse[F]): A
def freeCataM[M[_], F[_], E, A](free: Free[F, E])(φ: AlgebraM[M, [γ$45$]CoEnv[E, F, γ$45$], A])(implicit arg0: Monad[M], arg1: Traverse[F]): M[A]
def freeTransCata[T[_[_]], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$49$]CoEnv[B, G, γ$49$]]]) ⇒ CoEnv[B, G, T[[γ$50$]CoEnv[B, G, γ$50$]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Functor[G]): Free[G, B]
def freeTransCataM[T[_[_]], M[_], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$52$]CoEnv[B, G, γ$52$]]]) ⇒ M[CoEnv[B, G, T[[γ$53$]CoEnv[B, G, γ$53$]]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Monad[M], arg3: Traverse[F], arg4: Functor[G]): M[Free[G, B]]
def ginterpretM[W[_], M[_], F[_], A, B](f: (A) ⇒ M[B], φ: GAlgebraM[W, M, F, B]): GAlgebraM[W, M, [γ$42$]CoEnv[A, F, γ$42$], B]
def ignore[A](a: A): Unit
def interpret[F[_], A, B](f: (A) ⇒ B, φ: Algebra[F, B]): Algebra[[γ$40$]CoEnv[A, F, γ$40$], B]
def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$41$]CoEnv[A, F, γ$41$], B]
def liftCo[T[_[_]], F[_], A](f: (F[T[[γ$55$]CoEnv[A, F, γ$55$]]]) ⇒ CoEnv[A, F, T[[γ$56$]CoEnv[A, F, γ$56$]]]): (CoEnv[A, F, T[[γ$57$]CoEnv[A, F, γ$57$]]]) ⇒ CoEnv[A, F, T[[γ$58$]CoEnv[A, F, γ$58$]]]
def liftFF[F[_], G[_], A](orig: (F[A]) ⇒ F[A])(implicit F: :<:[F, G]): (G[A]) ⇒ G[A]
def liftFG[F[_], G[_], A](orig: (F[A]) ⇒ G[A])(implicit F: :<:[F, G]): (G[A]) ⇒ G[A]
def liftMT[F[_], G[_[_], _]](implicit arg0: Monad[F], arg1: MonadTrans[G]): ~>[F, [β$24$]G[F, β$24$]]
val minspace: PrettyParams

Definition Classes
JsonOps
val multiline: PrettyParams

Definition Classes
JsonOps
implicit def natEqual[N <: Nat]: Equal[N]
implicit def natShow[N <: Nat]: Show[N]
implicit def optionTCatchable[F[_]](implicit arg0: Catchable[F], arg1: Functor[F]): Catchable[[β$16$]OptionT[F, β$16$]]

Definition Classes
OptionTInstances
def optional[A](cur: ACursor)(implicit arg0: DecodeJson[A]): DecodeResult[Option[A]]

Definition Classes
JsonOps
def orElse[A](cur: ACursor, default: ⇒ A)(implicit arg0: DecodeJson[A]): DecodeResult[A]

Definition Classes
JsonOps
def pointNT[F[_]](implicit arg0: Applicative[F]): ~>[scalaz.Scalaz.Id, F]
def recover[F[_], A](φ: Algebra[F, A]): Algebra[[γ$43$]CoEnv[A, F, γ$43$], A]
def reflNT[F[_]]: ~>[F, F]
implicit def seqW[A](xs: Seq[A]): SeqW[A]

Definition Classes
ListMapInstances
implicit val showTFix: ShowT[Fix]
implicit def showTShow[T[_[_]], F[_]](implicit T: ShowT[T], F: Delay[Show, F]): Show[T[F]]
implicit def sizedEqual[A, N <: Nat](implicit arg0: Equal[A]): Equal[Sized[A, N]]
implicit def sizedShow[A, N <: Nat](implicit arg0: Show[A]): Show[Sized[A, N]]
implicit def stateTCatchable[F[_], S](implicit arg0: Catchable[F], arg1: Monad[F]): Catchable[[γ$18$]IndexedStateT[F, S, S, γ$18$]]

Definition Classes
StateTInstances
def substitute[T[_[_]], F[_]](original: T[F], replacement: T[F])(implicit T: Equal[T[F]]): (T[F]) ⇒ \/[T[F], T[F]]
def transApoT[T[_[_]], F[_]](t: T[F])(f: (T[F]) ⇒ \/[T[F], T[F]])(implicit arg0: FunctorT[T], arg1: Functor[F]): T[F]
def unzipDisj[A, B](ds: List[\/[A, B]]): (List[A], List[B])
implicit def writerTCatchable[F[_], W](implicit arg0: Catchable[F], arg1: Functor[F], arg2: Monoid[W]): Catchable[[γ$20$]WriterT[F, W, γ$20$]]

Definition Classes
WriterTInstances
def ι[A]: (A) ⇒ A

Definition Classes
SKI
def κ[A, B, C, D, E, F, G](x: G): (A, B, C, D, E, F) ⇒ G

Definition Classes
SKI
def κ[A, B, C, D](x: D): (A, B, C) ⇒ D

Definition Classes
SKI
def κ[A, B, C](x: C): (A, B) ⇒ C

Definition Classes
SKI
def κ[A, B](x: B): (A) ⇒ B

Definition Classes
SKI
def σ[A, B, C](x: (A) ⇒ (B) ⇒ C, y: (A) ⇒ B, z: A): C

Definition Classes
SKI

fp

package fp

Type Members

trait CatchableOps[F[_], A] extends Ops[F[A]]

type EnumT[F[_], A] = EnumeratorT[A, F]

implicit class PFOps[A, B] extends AnyRef

implicit class PrOps[F[_], O] extends AnyRef

implicit class ProcessOfTaskOps[O] extends AnyRef

class SeqW[A] extends AnyRef

implicit final class StringOps extends AnyRef

implicit class TaskOps[A] extends AnyRef

implicit final class ToQFoldableOps[F[_], A] extends AnyRef

implicit class eitherTOps[F[_], A, B] extends AnyRef

Value Members

implicit val BooleanRenderTree: RenderTree[Boolean]

implicit val DoubleRenderTree: RenderTree[Double]

implicit def EitherRenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[\/[A, B]]

implicit def EqualEqualF[F[_], A, FF[A] <: F[A]](implicit arg0: Equal[A], FE: EqualF[F]): Equal[FF[A]]

implicit def EqualFNT[F[_]](implicit EF: EqualF[F]): ~>[Equal, [α]Equal[F[α]]]

implicit val IntRenderTree: RenderTree[Int]

implicit def LeftTuple3RenderTree[A, B, C](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C]): RenderTree[((A, B), C)]

implicit def LeftTuple4RenderTree[A, B, C, D](implicit RA: RenderTree[A], RB: RenderTree[B], RC: RenderTree[C], RD: RenderTree[D]): RenderTree[(((A, B), C), D)]

implicit def ListMapRenderTree[K, V](implicit RV: RenderTree[V]): RenderTree[ListMap[K, V]]

implicit def ListRenderTree[A](implicit RA: RenderTree[A]): RenderTree[List[A]]

implicit def OptionRenderTree[A](implicit RA: RenderTree[A]): RenderTree[Option[A]]

implicit def PathRenderTree[B, T, S]: RenderTree[Path[B, T, S]]

implicit def RenderTreeToShow[N](implicit arg0: RenderTree[N]): Show[N]

implicit def ShowFNT[F[_]](implicit SF: ShowF[F]): ~>[Show, [α]Show[F[α]]]

implicit def ShowShowF[F[_], A, FF[A] <: F[A]](implicit arg0: Show[A], FS: ShowF[F]): Show[FF[A]]

implicit val StringRenderTree: RenderTree[String]

implicit val SymbolEqual: Equal[Symbol]

implicit def ToCatchableOpsFromCatchable[F[_], A](a: F[A]): CatchableOps[F, A]

implicit def TraverseListMap[K]: Traverse[[β$0$]ListMap[K, β$0$]] with IsEmpty[[β$1$]ListMap[K, β$1$]]

implicit def Tuple2RenderTree[A, B](implicit RA: RenderTree[A], RB: RenderTree[B]): RenderTree[(A, B)]

implicit def VectorRenderTree[A](implicit RA: RenderTree[A]): RenderTree[Vector[A]]

def coEnvHtraverse[G[_], F[_], H[_], A, B](fa: CoEnv[A, F, B])(f: ~>[F, [A]G[H[A]]])(implicit arg0: Applicative[G]): G[CoEnv[A, H, B]]

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

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

implicit def constEqual[A](implicit arg0: Equal[A]): Delay[Equal, [β$36$]Const[A, β$36$]]

implicit def constShow[A](implicit arg0: Show[A]): Delay[Show, [β$38$]Const[A, β$38$]]

implicit def coproductEqual[F[_], G[_]](implicit F: Delay[Equal, F], G: Delay[Equal, G]): Delay[Equal, [γ$32$]Coproduct[F, G, γ$32$]]

implicit def coproductShow[F[_], G[_]](implicit F: Delay[Show, F], G: Delay[Show, G]): Delay[Show, [γ$34$]Coproduct[F, G, γ$34$]]

def decodeJson[A](text: String)(implicit DA: DecodeJson[A]): \/[String, A]

implicit def eitherTCatchable[F[_], E](implicit arg0: Catchable[F], arg1: Functor[F]): Catchable[[γ$4$]EitherT[F, E, γ$4$]]

implicit def eitherTMonadState[F[_], S, E](implicit F: MonadState[F, S]): MonadState[[γ$6$]EitherT[F, E, γ$6$], S]

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]

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

implicit val equalTFix: EqualT[Fix]

def evalNT[F[_], S](initial: S)(implicit arg0: Monad[F]): ~>[[γ$26$]IndexedStateT[F, S, S, γ$26$], F]

implicit def finEqual[N <: Succ[_]]: Equal[Fin[N]]

implicit def finShow[N <: Succ[_]]: Show[Fin[N]]

def freeCata[F[_], E, A](free: Free[F, E])(φ: Algebra[[γ$44$]CoEnv[E, F, γ$44$], A])(implicit arg0: Traverse[F]): A

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

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

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

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

def ignore[A](a: A): Unit

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

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

def liftCo[T[_[_]], F[_], A](f: (F[T[[γ$55$]CoEnv[A, F, γ$55$]]]) ⇒ CoEnv[A, F, T[[γ$56$]CoEnv[A, F, γ$56$]]]): (CoEnv[A, F, T[[γ$57$]CoEnv[A, F, γ$57$]]]) ⇒ CoEnv[A, F, T[[γ$58$]CoEnv[A, F, γ$58$]]]

def liftFF[F[_], G[_], A](orig: (F[A]) ⇒ F[A])(implicit F: :<:[F, G]): (G[A]) ⇒ G[A]

def liftFG[F[_], G[_], A](orig: (F[A]) ⇒ G[A])(implicit F: :<:[F, G]): (G[A]) ⇒ G[A]

def liftMT[F[_], G[_[_], _]](implicit arg0: Monad[F], arg1: MonadTrans[G]): ~>[F, [β$24$]G[F, β$24$]]

val minspace: PrettyParams

val multiline: PrettyParams

implicit def natEqual[N <: Nat]: Equal[N]

implicit def natShow[N <: Nat]: Show[N]

implicit def optionTCatchable[F[_]](implicit arg0: Catchable[F], arg1: Functor[F]): Catchable[[β$16$]OptionT[F, β$16$]]

def optional[A](cur: ACursor)(implicit arg0: DecodeJson[A]): DecodeResult[Option[A]]

def orElse[A](cur: ACursor, default: ⇒ A)(implicit arg0: DecodeJson[A]): DecodeResult[A]

def pointNT[F[_]](implicit arg0: Applicative[F]): ~>[scalaz.Scalaz.Id, F]

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

def reflNT[F[_]]: ~>[F, F]

implicit def seqW[A](xs: Seq[A]): SeqW[A]

implicit val showTFix: ShowT[Fix]

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

implicit def sizedEqual[A, N <: Nat](implicit arg0: Equal[A]): Equal[Sized[A, N]]

implicit def sizedShow[A, N <: Nat](implicit arg0: Show[A]): Show[Sized[A, N]]

implicit def stateTCatchable[F[_], S](implicit arg0: Catchable[F], arg1: Monad[F]): Catchable[[γ$18$]IndexedStateT[F, S, S, γ$18$]]

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