package fp
- Alphabetic
- By Inheritance
- fp
- DebugOps
- ProcessOps
- JsonOps
- PartialFunctionOps
- ListMapInstances
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
implicit final
class
ToDebugOps[A] extends AnyRef
- Definition Classes
- DebugOps
-
class
SeqW[A] extends AnyRef
- Definition Classes
- ListMapInstances
-
implicit
class
PFOps[A, B] extends AnyRef
- Definition Classes
- PartialFunctionOps
- 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]]
vsFix[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]]]
-
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.
- trait ProcessOps extends AnyRef
-
implicit
class
PrOps[F[_], O] extends AnyRef
- Definition Classes
- ProcessOps
-
implicit
class
ProcessOfTaskOps[O] extends AnyRef
- Definition Classes
- ProcessOps
-
implicit
class
TaskOps[A] extends AnyRef
- Definition Classes
- ProcessOps
- implicit final class QuasarFreeOps[F[_], A] extends AnyVal
-
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
Value Members
-
implicit
def
ListMapEqual[A, B](implicit arg0: Equal[A], arg1: Equal[B]): Equal[slamdata.Predef.ListMap[A, B]]
- Definition Classes
- ListMapInstances
-
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[[γ$20$]CoEnv[A, F, γ$20$]]) ⇒ T[[γ$21$]CoEnv[A, F, γ$21$]])(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
- def coenvBijection[T[_[_]], F[_], A](implicit arg0: BirecursiveT[T], arg1: Functor[F]): Bijection[Free[F, A], T[[γ$17$]CoEnv[A, F, γ$17$]]]
- def coenvPrism[F[_], A]: PrismNT[[γ$4$]CoEnv[A, F, γ$4$], F]
- implicit def constEqual[A](implicit arg0: Equal[A]): Delay[Equal, [β$13$]Const[A, β$13$]]
- implicit def constShow[A](implicit arg0: Show[A]): Delay[Show, [β$15$]Const[A, β$15$]]
- implicit def coproductEqual[F[_], G[_]](implicit F: Delay[Equal, F], G: Delay[Equal, G]): Delay[Equal, [γ$9$]Coproduct[F, G, γ$9$]]
- implicit def coproductShow[F[_], G[_]](implicit F: Delay[Show, F], G: Delay[Show, G]): Delay[Show, [γ$11$]Coproduct[F, G, γ$11$]]
-
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]): ~>[[γ$7$]IndexedStateT[F, S, S, γ$7$], F]
- implicit def finEqual[N <: Succ[_]]: Equal[Fin[N]]
- implicit def finShow[N <: Succ[_]]: Show[Fin[N]]
- 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 liftFFTrans[F[_], G[_], A](prism: PrismNT[G, F])(f: (F[A]) ⇒ slamdata.Predef.Option[F[A]]): (G[A]) ⇒ slamdata.Predef.Option[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 liftFGTrans[F[_], G[_], A](prism: PrismNT[G, F])(f: (F[A]) ⇒ slamdata.Predef.Option[G[A]]): (G[A]) ⇒ slamdata.Predef.Option[G[A]]
-
def
liftMT[F[_], G[_[_], _]](implicit arg0: Monad[F], arg1: MonadTrans[G]): ~>[F, [β$4$]G[F, β$4$]]
liftM
as a natural transformationliftM
as a natural transformationTODO: 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]
-
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 symbolOrder: Order[slamdata.Predef.Symbol]
- implicit val symbolShow: Show[slamdata.Predef.Symbol]
- object Extern extends ExternallyManaged with Product with Serializable
- object ExternallyManaged
- object PrismNT extends Serializable
- object ProcessOps extends ProcessOps
- object TaskRef
-
object
zoomNT
Lift a
State
computation to operate over a "larger" state given aLens
.Lift a
State
computation to operate over a "larger" state given aLens
.NB: Uses partial application of
F[_]
for better type inference, usage:zoomNT[F](lens)