fp - quasar.fp

Type Members

sealed abstract class :/:[F[_], G[_]] extends CoM
sealed abstract class :\:[F[_], T <: CoM] extends CoM
sealed abstract class 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 DelayedA[A] extends AnyRef
trait DelayedFG[F[_], G[_]] 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.
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 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
implicit final class QuasarFreeOps[F[_], A] extends AnyVal
class SeqW[A] extends AnyRef

Definition Classes
ListMapInstances
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

Value Members

object Extern extends ExternallyManaged with Product with Serializable
object ExternallyManaged
implicit def ListMapEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[slamdata.Predef.ListMap[A, B]]

Definition Classes
ListMapInstances
object ProcessOps extends ProcessOps
object TaskRef
implicit def TraverseListMap[K]: Traverse[[β$0$]ListMap[K, β$0$]] with IsEmpty[[β$1$]ListMap[K, β$1$]]

Definition Classes
ListMapInstances
def applyCoEnvFrom[T[_[_]], F[_], A](modify: (T[[γ$27$]CoEnv[A, F, γ$27$]]) ⇒ T[[γ$28$]CoEnv[A, F, γ$28$]])(implicit arg0: BirecursiveT[T], arg1: Functor[F]): (Free[F, A]) ⇒ Free[F, A]
def applyFrom[A, B](bij: Bijection[A, B])(modify: (B) ⇒ B): (A) ⇒ A
package binder
def coenvBijection[T[_[_]], F[_], A](implicit arg0: BirecursiveT[T], arg1: Functor[F]): Bijection[Free[F, A], T[[γ$24$]CoEnv[A, F, γ$24$]]]
def coenvPrism[F[_], A]: PrismNT[[γ$19$]CoEnv[A, F, γ$19$], F]
implicit def constEqual[A](implicit arg0: Equal[A]): Delay[Equal, [β$14$]Const[A, β$14$]]
implicit def constShow[A](implicit arg0: Show[A]): Delay[Show, [β$16$]Const[A, β$16$]]
implicit def coproductEqual[F[_], G[_]](implicit F: Delay[Equal, F], G: Delay[Equal, G]): Delay[Equal, [γ$10$]Coproduct[F, G, γ$10$]]
implicit def coproductShow[F[_], G[_]](implicit F: Delay[Show, F], G: Delay[Show, G]): Delay[Show, [γ$12$]Coproduct[F, G, γ$12$]]
def decodeJson[A](text: slamdata.Predef.String)(implicit DA: DecodeJson[A]): \/[slamdata.Predef.String, A]

Definition Classes
JsonOps
def evalNT[F[_], S](initial: S)(implicit arg0: Monad[F]): ~>[[γ$8$]IndexedStateT[F, S, S, γ$8$], F]
implicit def finEqual[N <: Succ[_]]: Equal[Fin[N]]
implicit def finShow[N <: Succ[_]]: Show[Fin[N]]
package free
def idPrism[F[_]]: PrismNT[F, F]
def ignore[A](a: A): slamdata.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 injR[T[_[_]], F[_], G[_]](orig: T[F])(implicit arg0: BirecursiveT[T], arg1: Functor[F], arg2: Functor[G], F: :<:[F, G]): T[G]
def liftCo[T[_[_]], F[_], A, B](f: (F[B]) ⇒ CoEnv[A, F, B]): (CoEnv[A, F, B]) ⇒ CoEnv[A, F, B]
def liftCoM[T[_[_]], M[_], F[_], A, B](f: (F[B]) ⇒ M[CoEnv[A, F, B]])(implicit arg0: Applicative[M]): (CoEnv[A, F, B]) ⇒ M[CoEnv[A, F, B]]
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, [β$5$]G[F, β$5$]]

liftM as a natural transformation
liftM as a natural transformation
TODO: PR to scalaz
def liftR[T[_[_]], F[_], G[_]](orig: (T[F]) ⇒ T[F])(implicit arg0: BirecursiveT[T], arg1: Traverse[F], arg2: Traverse[G], F: :<:[F, G]): (T[G]) ⇒ T[G]
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
def optional[A](cur: ACursor)(implicit arg0: DecodeJson[A]): DecodeResult[slamdata.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 prjR[T[_[_]], F[_], G[_]](orig: T[G])(implicit arg0: BirecursiveT[T], arg1: Traverse[F], arg2: Traverse[G], F: :<:[F, G]): slamdata.Predef.Option[T[F]]
def reflNT[F[_]]: ~>[F, F]
implicit def seqW[A](xs: slamdata.Predef.Seq[A]): SeqW[A]

Definition Classes
ListMapInstances
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 val symbolEqual: Equal[slamdata.Predef.Symbol]
implicit val symbolShow: Show[slamdata.Predef.Symbol]
package tree

"Generic" types for building partially-constructed trees in some "functorized" type.
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)

fp

package fp

Type Members

sealed abstract class :/:[F[_], G[_]] extends CoM

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

sealed abstract class CoM extends AnyRef

trait DelayedA[A] extends AnyRef

trait DelayedFG[F[_], G[_]] extends AnyRef

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

sealed abstract class ExternallyManaged 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

implicit final class QuasarFreeOps[F[_], A] extends AnyVal

class SeqW[A] extends AnyRef

implicit class TaskOps[A] extends AnyRef

sealed abstract class TaskRef[A] extends AnyRef

implicit final class ToDebugOps[A] extends AnyRef

Value Members

object Extern extends ExternallyManaged with Product with Serializable

object ExternallyManaged

implicit def ListMapEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[slamdata.Predef.ListMap[A, B]]

object ProcessOps extends ProcessOps

object TaskRef

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

def applyCoEnvFrom[T[_[_]], F[_], A](modify: (T[[γ$27$]CoEnv[A, F, γ$27$]]) ⇒ T[[γ$28$]CoEnv[A, F, γ$28$]])(implicit arg0: BirecursiveT[T], arg1: Functor[F]): (Free[F, A]) ⇒ Free[F, A]

def applyFrom[A, B](bij: Bijection[A, B])(modify: (B) ⇒ B): (A) ⇒ A

package binder

def coenvBijection[T[_[_]], F[_], A](implicit arg0: BirecursiveT[T], arg1: Functor[F]): Bijection[Free[F, A], T[[γ$24$]CoEnv[A, F, γ$24$]]]

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

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

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

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

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

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

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

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

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

package free

def idPrism[F[_]]: PrismNT[F, F]

def ignore[A](a: A): slamdata.Predef.Unit

def injR[T[_[_]], F[_], G[_]](orig: T[F])(implicit arg0: BirecursiveT[T], arg1: Functor[F], arg2: Functor[G], F: :<:[F, G]): T[G]

def liftCo[T[_[_]], F[_], A, B](f: (F[B]) ⇒ CoEnv[A, F, B]): (CoEnv[A, F, B]) ⇒ CoEnv[A, F, B]

def liftCoM[T[_[_]], M[_], F[_], A, B](f: (F[B]) ⇒ M[CoEnv[A, F, B]])(implicit arg0: Applicative[M]): (CoEnv[A, F, B]) ⇒ M[CoEnv[A, F, B]]

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, [β$5$]G[F, β$5$]]

def liftR[T[_[_]], F[_], G[_]](orig: (T[F]) ⇒ T[F])(implicit arg0: BirecursiveT[T], arg1: Traverse[F], arg2: Traverse[G], F: :<:[F, G]): (T[G]) ⇒ T[G]

val minspace: PrettyParams

val multiline: PrettyParams

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

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

package numeric

def optional[A](cur: ACursor)(implicit arg0: DecodeJson[A]): DecodeResult[slamdata.Predef.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 prjR[T[_[_]], F[_], G[_]](orig: T[G])(implicit arg0: BirecursiveT[T], arg1: Traverse[F], arg2: Traverse[G], F: :<:[F, G]): slamdata.Predef.Option[T[F]]

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

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

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 val symbolEqual: Equal[slamdata.Predef.Symbol]

implicit val symbolShow: Show[slamdata.Predef.Symbol]

package tree

object zoomNT

Inherited from DebugOps

Inherited from ProcessOps

Inherited from JsonOps

Inherited from PartialFunctionOps

Inherited from ListMapInstances

Inherited from AnyRef

Inherited from Any

Ungrouped