fp - quasar.fp

Type Members

sealed trait :/:[F[_], G[_]] extends CoM
sealed trait :\:[F[_], T <: CoM] extends CoM
trait CatchableInstances extends AnyRef
implicit class CatchableOfDisjunctionOps[F[_], A, B] extends AnyRef

Definition Classes
CatchableInstances
trait CatchableOps[F[_], A] extends Ops[F[A]]

Definition Classes
ToCatchableOps
implicit final class CoEnvOps[T[_[_]], F[_], E] extends AnyVal
sealed trait CoM extends AnyRef

Builds nested scalaz Coproducts.
Builds nested scalaz Coproducts. Use like: * type MarkLogicFs[A] = ( Task :\: SessionIO :\: ContentSourceIO :\: GenUUID :\: MonotonicSeq :\: MLReadHandles :\: MLWriteHandles :/: MLResultHandles )#M[A]
trait EitherTInstances extends EitherTInstances0
trait EitherTInstances0 extends EitherTInstances1
trait EitherTInstances1 extends AnyRef
type EndoK[F[X]] = NaturalTransformation[F, F]

An endomorphism is a mapping from a category to itself.
An endomorphism is a mapping from a category to itself. It looks like scalaz already staked out "Endo" for the lower version.
type EnumT[F[_], A] = EnumeratorT[A, F]
trait EqualF[F[_]] extends Serializable
trait EqualT[T[_[_]]] extends Serializable
sealed abstract class ExternallyManaged extends AnyRef

Used for a normally-recursive parameter that has been “externalized”.
Used for a normally-recursive parameter that has been “externalized”. E.g., Tree[LogicalPlan[ExternallyManaged]] vs Fix[LogicalPlan]. This indicates that the recursive structure is intact, but is handled by some containing structure (Tree, in that example).
implicit final class FreeOps[F[_], E] extends AnyVal
trait KleisliInstances extends AnyRef
implicit final class ListOps[A] extends AnyVal
type NTComp[F[X], G[Y]] = NaturalTransformation[F, [A]G[F[A]]]
implicit class PFOps[A, B] extends AnyRef

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

Definition Classes
ProcessOps
final case class PrismNT[F[_], G[_]](get: ~>[F, [A]Option[G[A]]], reverseGet: ~>[G, F]) extends Product with Serializable

Just like Prism, but operates over Functors.
implicit class ProcessOfTaskOps[O] extends AnyRef

Definition Classes
ProcessOps
trait ProcessOps extends AnyRef
trait SemigroupF[F[_]] extends Serializable
class SeqW[A] extends AnyRef

Definition Classes
ListMapInstances
trait ShowF[F[_]] extends Serializable
trait ShowT[T[_[_]]] extends Serializable
implicit class TaskOps[A] extends AnyRef

Definition Classes
ProcessOps
sealed abstract class TaskRef[A] extends AnyRef

A thread-safe, atomically updatable mutable reference.
A thread-safe, atomically updatable mutable reference.
Cribbed from the IORef defined in oncue/remotely, an Apache 2 licensed project: https://github.com/oncue/remotely
implicit final class ToDebugOps[A] extends AnyRef

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

Definition Classes
QFoldableOps

Value Members

implicit val BooleanRenderTree: RenderTree[Predef.Boolean]

Definition Classes
TreeInstances
implicit val DoubleRenderTree: RenderTree[Predef.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]]
object EqualF extends Serializable
implicit def EqualFNT[F[_]](implicit EF: EqualF[F]): ~>[Equal, [α]Equal[F[α]]]
object EqualT extends Serializable
object Extern extends ExternallyManaged with Product with Serializable
object ExternallyManaged
object Inj
implicit val IntRenderTree: RenderTree[Predef.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 ListMapEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[Predef.ListMap[A, B]]

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

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

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

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

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

Definition Classes
TreeInstances
object SemigroupF extends Serializable
object ShowF extends Serializable
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]]
object ShowT extends Serializable
implicit val StringRenderTree: RenderTree[Predef.String]

Definition Classes
TreeInstances
implicit val SymbolEqual: Equal[Predef.Symbol]

Definition Classes
TreeInstances
object TaskRef
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[Predef.Vector[A]]

Definition Classes
TreeInstances
package binder
object catchable extends CatchableInstances
def coEnvHmap[F[_], G[_], A, B](fa: CoEnv[A, F, B])(f: ~>[F, G]): CoEnv[A, G, B]
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[[γ$11$]CoEnv[E, F, γ$11$]]

Definition Classes
CoEnvInstances
def coenvPrism[F[_], A]: PrismNT[[γ$54$]CoEnv[A, F, γ$54$], F]
implicit def coenvTraverse[F[_], E](implicit arg0: Traverse[F]): Traverse[[γ$10$]CoEnv[E, F, γ$10$]]

Definition Classes
LowPriorityCoEnvImplicits
implicit def constEqual[A](implicit arg0: Equal[A]): Delay[Equal, [β$23$]Const[A, β$23$]]
implicit def constShow[A](implicit arg0: Show[A]): Delay[Show, [β$25$]Const[A, β$25$]]
implicit def coproductEqual[F[_], G[_]](implicit F: Delay[Equal, F], G: Delay[Equal, G]): Delay[Equal, [γ$19$]Coproduct[F, G, γ$19$]]
implicit def coproductShow[F[_], G[_]](implicit F: Delay[Show, F], G: Delay[Show, G]): Delay[Show, [γ$21$]Coproduct[F, G, γ$21$]]
def decodeJson[A](text: Predef.String)(implicit DA: DecodeJson[A]): \/[Predef.String, A]

Definition Classes
JsonOps
def distTraverse[F[_], G[_]](implicit arg0: Traverse[F], arg1: Applicative[G]): DistributiveLaw[F, G]
object eitherT extends 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]
object enumeratee
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]): ~>[[γ$17$]IndexedStateT[F, S, S, γ$17$], F]
implicit def finEqual[N <: Succ[_]]: Equal[Fin[N]]
implicit def finShow[N <: Succ[_]]: Show[Fin[N]]
package free
def freeCata[F[_], E, A](free: Free[F, E])(φ: Algebra[[γ$31$]CoEnv[E, F, γ$31$], A])(implicit arg0: Functor[F]): A
def freeCataM[M[_], F[_], E, A](free: Free[F, E])(φ: AlgebraM[M, [γ$32$]CoEnv[E, F, γ$32$], A])(implicit arg0: Monad[M], arg1: Traverse[F]): M[A]
def freeGcataM[W[_], M[_], F[_], E, A](free: Free[F, E])(k: DistributiveLaw[[γ$33$]CoEnv[E, F, γ$33$], W], φ: GAlgebraM[W, M, [γ$34$]CoEnv[E, F, γ$34$], A])(implicit arg0: Comonad[W], arg1: Traverse[W], arg2: Monad[M], arg3: Traverse[F]): M[A]
def freeTransCata[T[_[_]], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$39$]CoEnv[B, G, γ$39$]]]) ⇒ CoEnv[B, G, T[[γ$40$]CoEnv[B, G, γ$40$]]])(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].
def freeTransCataM[T[_[_]], M[_], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$42$]CoEnv[B, G, γ$42$]]]) ⇒ M[CoEnv[B, G, T[[γ$43$]CoEnv[B, G, γ$43$]]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Monad[M], arg3: Traverse[F], arg4: Functor[G]): M[Free[G, B]]
def freeTransFutu[T[_[_]], F[_], G[_], A, B](free: Free[F, A])(f: (CoEnv[A, F, T[[γ$46$]CoEnv[A, F, γ$46$]]]) ⇒ CoEnv[B, G, Free[[γ$48$]CoEnv[B, G, γ$48$], T[[γ$47$]CoEnv[A, F, γ$47$]]]])(implicit arg0: Recursive[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Traverse[G]): Free[G, B]
def ginterpretM[W[_], M[_], F[_], A, B](f: (A) ⇒ M[B], φ: GAlgebraM[W, M, F, B]): GAlgebraM[W, M, [γ$29$]CoEnv[A, F, γ$29$], B]
def idPrism[F[_]]: PrismNT[F, F]
def ignore[A](a: A): Predef.Unit

Accept a value (forcing the argument expression to be evaluated for its effects), and then discard it, returning Unit.
Accept a value (forcing the argument expression to be evaluated for its effects), and then discard it, returning Unit. Makes it explicit that you're discarding the result, and effectively suppresses the "NonUnitStatement" warning from wartremover.
def interpret[F[_], A, B](f: (A) ⇒ B, φ: Algebra[F, B]): Algebra[[γ$27$]CoEnv[A, F, γ$27$], 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).
def interpretM[M[_], F[_], A, B](f: (A) ⇒ M[B], φ: AlgebraM[M, F, B]): AlgebraM[M, [γ$28$]CoEnv[A, F, γ$28$], B]
object kleisli extends KleisliInstances
def liftCo[T[_[_]], F[_], A](f: (F[T[[γ$49$]CoEnv[A, F, γ$49$]]]) ⇒ CoEnv[A, F, T[[γ$50$]CoEnv[A, F, γ$50$]]]): (CoEnv[A, F, T[[γ$51$]CoEnv[A, F, γ$51$]]]) ⇒ CoEnv[A, F, T[[γ$52$]CoEnv[A, F, γ$52$]]]
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 liftFGM[M[_], F[_], G[_], A](orig: (F[A]) ⇒ M[G[A]])(implicit arg0: Monad[M], F: :<:[F, G]): (G[A]) ⇒ M[G[A]]
def liftMT[F[_], G[_[_], _]](implicit arg0: Monad[F], arg1: MonadTrans[G]): ~>[F, [β$14$]G[F, β$14$]]

liftM as a natural transformation
liftM as a natural transformation
TODO: PR to scalaz
val minspace: PrettyParams

Definition Classes
JsonOps
val multiline: PrettyParams

Nicely formatted, order-preserving, 2-space indented.
Nicely formatted, order-preserving, 2-space indented.

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

Definition Classes
OptionTInstances
def optional[A](cur: ACursor)(implicit arg0: DecodeJson[A]): DecodeResult[Predef.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]

point as a natural transformation
def recover[F[_], A](φ: Algebra[F, A]): Algebra[[γ$30$]CoEnv[A, F, γ$30$], A]

A specialization of interpret where the leaves are of the result type.
def reflNT[F[_]]: ~>[F, F]
implicit def seqW[A](xs: Predef.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[[γ$6$]IndexedStateT[F, S, S, γ$6$]]

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 transFutu[T[_[_]], F[_], G[_]](t: T[F])(f: GCoalgebraicTransform[T, [β$45$]Free[G, β$45$], F, G])(implicit arg0: FunctorT[T], arg1: Corecursive[T], arg2: Functor[F], arg3: Traverse[G]): T[G]
package tree

"Generic" types for building partially-constructed trees in some "functorized" type.
def unzipDisj[A, B](ds: Predef.List[\/[A, B]]): (Predef.List[A], Predef.List[B])
implicit def writerTCatchable[F[_], W](implicit arg0: Catchable[F], arg1: Functor[F], arg2: Monoid[W]): Catchable[[γ$8$]WriterT[F, W, γ$8$]]

Definition Classes
WriterTInstances
object zoomNT

Lift a State computation to operate over a "larger" state given a Lens.
Lift a State computation to operate over a "larger" state given a Lens.
NB: Uses partial application of F[_] for better type inference, usage:
zoomNT[F](lens)
def ι[A]: (A) ⇒ A

A shorter name for the identity function.
A shorter name for the identity function.

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

A shorter name for the constant function of 1, 2, 3, or 6 args.
A shorter name for the constant function of 1, 2, 3, or 6 args. NB: the argument is eager here, so use _ => ... instead if you need it to be thunked.

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

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

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

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

Probably not useful; implemented here mostly because it's amusing.
Probably not useful; implemented here mostly because it's amusing.

Definition Classes
SKI

fp

package fp

Type Members

sealed trait :/:[F[_], G[_]] extends CoM

sealed trait :\:[F[_], T <: CoM] extends CoM

trait CatchableInstances extends AnyRef

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

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

implicit final class CoEnvOps[T[_[_]], F[_], E] extends AnyVal

sealed trait CoM extends AnyRef

trait EitherTInstances extends EitherTInstances0

trait EitherTInstances0 extends EitherTInstances1

trait EitherTInstances1 extends AnyRef

type EndoK[F[X]] = NaturalTransformation[F, F]

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

trait EqualF[F[_]] extends Serializable

trait EqualT[T[_[_]]] extends Serializable

sealed abstract class ExternallyManaged extends AnyRef

implicit final class FreeOps[F[_], E] extends AnyVal

trait KleisliInstances extends AnyRef

implicit final class ListOps[A] extends AnyVal

type NTComp[F[X], G[Y]] = NaturalTransformation[F, [A]G[F[A]]]

implicit class PFOps[A, B] extends AnyRef

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

final case class PrismNT[F[_], G[_]](get: ~>[F, [A]Option[G[A]]], reverseGet: ~>[G, F]) extends Product with Serializable

implicit class ProcessOfTaskOps[O] extends AnyRef

trait ProcessOps extends AnyRef

trait SemigroupF[F[_]] extends Serializable

class SeqW[A] extends AnyRef

trait ShowF[F[_]] extends Serializable

trait ShowT[T[_[_]]] extends Serializable

implicit class TaskOps[A] extends AnyRef

sealed abstract class TaskRef[A] extends AnyRef

implicit final class ToDebugOps[A] extends AnyRef

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

Value Members

implicit val BooleanRenderTree: RenderTree[Predef.Boolean]

implicit val DoubleRenderTree: RenderTree[Predef.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]]

object EqualF extends Serializable

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

object EqualT extends Serializable

object Extern extends ExternallyManaged with Product with Serializable

object ExternallyManaged

object Inj

implicit val IntRenderTree: RenderTree[Predef.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 ListMapEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[Predef.ListMap[A, B]]

implicit def ListMapRenderTree[K, V](implicit arg0: Show[K], RV: RenderTree[V]): RenderTree[Predef.ListMap[K, V]]

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

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

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

object ProcessOps extends ProcessOps

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

object SemigroupF extends Serializable

object ShowF extends Serializable

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]]

object ShowT extends Serializable

implicit val StringRenderTree: RenderTree[Predef.String]

implicit val SymbolEqual: Equal[Predef.Symbol]

object TaskRef

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[Predef.Vector[A]]

package binder

object catchable extends CatchableInstances

def coEnvHmap[F[_], G[_], A, B](fa: CoEnv[A, F, B])(f: ~>[F, G]): CoEnv[A, G, B]

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[[γ$11$]CoEnv[E, F, γ$11$]]

def coenvPrism[F[_], A]: PrismNT[[γ$54$]CoEnv[A, F, γ$54$], F]

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

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

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

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

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

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