libretto-core
API
Generated with
libretto-core/libretto/libretto.scaletto/libretto.scaletto.impl/FreeScaletto

FreeScaletto

libretto.scaletto.impl.FreeScaletto
See theFreeScaletto companion class
object FreeScaletto extends FreeScaletto, Scaletto

Attributes

Companion
class
Graph
Supertypes
trait Scaletto
trait InvertDSL
trait ClosedDSL
trait CrashDSL
trait TimerDSL
trait CoreDSL
class FreeScaletto
class Object
trait Matchable
class Any
Show all
Self type

Members list

Type members

Classlikes

override class NotLinearException(msg: String) extends Exception

Attributes

Supertypes
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
object ScalaFun extends ScalaFuns

Attributes

Supertypes
trait ScalaFuns
class Object
trait Matchable
class Any
Self type
ScalaFun.type
object UInt31 extends UInt31Scaletto

Attributes

Supertypes
trait UInt31s
class Object
trait Matchable
class Any
Self type
UInt31.type
override class UnboundVariablesException(vs: Set[VarOrigin]) extends Exception

Attributes

Supertypes
class Exception
class Throwable
trait Serializable
class Object
trait Matchable
class Any
Show all
object ℭ extends ClosedSymmetricMonoidalCategory[-⚬, |*|, One, =⚬]

Attributes

Supertypes
trait ClosedSymmetricMonoidalCategory[-⚬, |*|, One, =⚬]
trait SymmetricMonoidalCategory[-⚬, |*|, One]
trait MonoidalCategory[-⚬, |*|, One]
trait ClosedSymmetricSemigroupalCategory[-⚬, |*|, =⚬]
trait SymmetricSemigroupalCategory[-⚬, |*|]
trait ClosedSemigroupalCategory[-⚬, |*|, =⚬]
trait SemigroupalCategory[-⚬, |*|]
trait Category[-⚬]
trait Semigroupoid[-⚬]
class Object
trait Matchable
class Any
Show all
Self type
ℭ.type

Inherited classlikes

trait $Ops

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait FunExprOps
object *

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
object +

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
final class -[A]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
object -⚬

Attributes

Inherited from:
FreeScaletto
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
sealed trait -⚬[A, B]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Acquire[A, R, B]
class AndThen[A, B, C]
class AssocLR[A, B, C]
class AssocRL[A, B, C]
class Backvert[A]
class Choice[A, B, C]
class ChooseL[A, B]
class ChooseLOnPong[A, B]
class ChooseR[A, B]
class CoDistributeL[A, B, C]
class ConstNeg[A]
class ConstVal[A]
class CrashWhenDone[A, B]
class DebugPrint
class Delay
class DistributeInversion[A, B]
class DistributeL[A, B, C]
class Effect[R, A, B]
class EffectWr[R, A]
class EitherF[A, B, C]
class ElimFst[B]
class ElimSnd[A]
class FactorOutInversion[A, B]
class Forevert[A]
class Fork
class ForkNeed
class ForkPing
class ForkPong
class Id[A]
class InjectL[A, B]
class InjectLOnPing[A, B]
class InjectR[A, B]
class IntroFst[B]
class IntroSnd[A]
class Join
class JoinLTermini
class JoinNeed
class JoinPing
class JoinPong
class JoinRTermini
class LiftEither[A, B]
class LiftPair[A, B]
class MapVal[A, B]
class Neglect[A]
class NotifyChoice[A, B]
class NotifyDoneL
class NotifyEither[A, B]
class NotifyNeedL
class NotifyNeg[A]
class NotifyVal[A]
class Pack[F]
class Par[A1, A2, B1, B2]
class PingF
class PongF
class RacePair
class RecF[A, B]
class Release[R]
class ReleaseWith[R, A, B]
class SelectPair
class Swap[A, B]
class TryAcquire[A, R, B, E]
class TryEffectAcquire[R, A, S, B, E]
class TrySplitResource[R, A, S, T, B, E]
class TryTransformResource[R, A, S, B, E]
class UnliftPair[A, B]
class Unpack[F]
Show all
object ?

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
object Affine

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
trait Affine[A]

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
trait ClosureOps

Attributes

Inherited from:
ClosedDSL
Supertypes
class Object
trait Matchable
class Any
object Comonoid

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
trait Comonoid[A] extends Cosemigroup[A], Affine[A]

Attributes

Inherited from:
CoreDSL
Supertypes
trait Affine[A]
trait Cosemigroup[A]
class Object
trait Matchable
class Any
Known subtypes
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
final class ConcurrentPair[A, B]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
trait ConcurrentPairInvertOps extends ConcurrentPairOps

Attributes

Inherited from:
InvertDSL
Supertypes
class Object
trait Matchable
class Any
trait ConcurrentPairOps

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Cosemigroup

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
trait Cosemigroup[A]

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait Comonoid[A]
object comonoidNeed.type
object comonoidOne.type
object comonoidPing.type
object comonoidPong.type
object cosemigroupDone.type
object cosemigroupNeed.type
object cosemigroupPing.type
object cosemigroupPong.type
trait NComonoid[A]
Show all
final class Done

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
trait FunExprOps extends $Ops

Attributes

Inherited from:
ClosedDSL
Supertypes
trait $Ops
class Object
trait Matchable
class Any
implicit class FunctorOps[F[_], A](fa: $[F[A]])

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
final class LTerminus

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
trait LambdaOps

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
trait LambdaOpsWithClosures extends LambdaOps

Attributes

Inherited from:
ClosedDSL
Supertypes
trait LambdaOps
class Object
trait Matchable
class Any
final class Need

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class One

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class Ping

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class Pong

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class RTerminus

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class Rec[F[_]]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class Res[A]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
trait ScalaFuns

Attributes

Inherited from:
Scaletto
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object ScalaFun.type
trait UInt31Scaletto extends UInt31s

Attributes

Inherited from:
Scaletto
Supertypes
trait UInt31s
class Object
trait Matchable
class Any
Known subtypes
object UInt31.type
trait UInt31s

Attributes

Inherited from:
CoreDSL
Supertypes
class Object
trait Matchable
class Any
Known subtypes
object UInt31.type
final class Val[A]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
class ValSwitch[A, A0, R](a: $[Val[A]], pos: SourcePos, cases: Cases[A, A0, R])(using x$4: LambdaContext)

Type parameters

A

type of the scrutinee (the value to match on)

A0

subtype of A covered so far

R

result type that each case must produce

Attributes

Inherited from:
Scaletto
Supertypes
class Object
trait Matchable
class Any
object ValSwitch

Attributes

Inherited from:
Scaletto
Supertypes
class Object
trait Matchable
class Any
class ValSwitchInit[A](a: $[Val[A]], pos: SourcePos)(using x$3: LambdaContext)

Attributes

Inherited from:
Scaletto
Supertypes
class Object
trait Matchable
class Any
class ValSwitchInitCase[A, A0 <: A](a: $[Val[A]], pos: SourcePos, tt: TypeTest[A, A0], casePos: SourcePos)(using x$5: LambdaContext)

Attributes

Inherited from:
Scaletto
Supertypes
class Object
trait Matchable
class Any
object given_BiInjective_|*| extends BiInjective[|*|]

Attributes

Inherited from:
FreeScaletto
Supertypes
trait BiInjective[|*|]
class Object
trait Matchable
class Any
object producing

Attributes

Inherited from:
InvertDSL
Supertypes
class Object
trait Matchable
class Any
final class |&|[A, B]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any
final class |+|[A, B]

Attributes

Inherited from:
FreeScaletto
Supertypes
class Object
trait Matchable
class Any

Types

override type $[A] = Expr[A]

The type of auxiliary placeholder variables used in construction of λ-expressions.

The type of auxiliary placeholder variables used in construction of λ-expressions.

Attributes

override type ->[A, B] = A -⚬ B

Type of nested arrows.

Type of nested arrows.

Attributes

override type LambdaContext = Context
override type ScalaFun[A, B] = ScalaFunction[A, B]
type Var[A] = Var[VarOrigin, A]

Inherited types

override type =⚬[A, B] = -[A] |*| B

Linear function as data, that is, one that can be part of an input or output of a linear function (-⚬). While A -⚬ B is a morphism in a category, A =⚬ B is an object called the internal hom of A and B in a closed monoidal category.

Linear function as data, that is, one that can be part of an input or output of a linear function (-⚬). While A -⚬ B is a morphism in a category, A =⚬ B is an object called the internal hom of A and B in a closed monoidal category.

Attributes

Inherited from:
InvertDSL
opaque type ??[A]

Attributes

Inherited from:
InvertDSL
type Neg[A] = -[Val[A]]

Demand for a Scala value of type A.

Demand for a Scala value of type A.

Somewhat analogous to scala.concurrent.Promise

Attributes

Inherited from:
Scaletto
type NoCaptureException <: Throwable

Attributes

Inherited from:
ClosedDSL
final type UInt31 = Val[Int]

Attributes

Inherited from:
FreeScaletto
type Zero

Impossible resource. Analogous to Nothing. It is the identity element for |+|.

Impossible resource. Analogous to Nothing. It is the identity element for |+|.

Attributes

Inherited from:
CoreDSL
final type |*|[A, B] = ConcurrentPair[A, B]

Attributes

Inherited from:
FreeScaletto
type ⊕[A, B] = A |+| B

Alias for |+|.

Alias for |+|.

Attributes

Inherited from:
CoreDSL
type ⊗[A, B] = A |*| B

Alias for |*|.

Alias for |*|.

Attributes

Inherited from:
CoreDSL

Value members

Concrete methods

override def acquire[A, R, B](acquire: ScalaFunction[A, (R, B)], release: Option[ScalaFunction[R, Unit]]): Val[A] -⚬ ConcurrentPair[Res[R], Val[B]]

Attributes

Definition Classes
override def andThen[A, B, C](f: A -⚬ B, g: B -⚬ C): A -⚬ C

Attributes

Definition Classes
override def assocLR[A, B, C]: ConcurrentPair[ConcurrentPair[A, B], C] -⚬ ConcurrentPair[A, ConcurrentPair[B, C]]

Attributes

Definition Classes
override def assocRL[A, B, C]: ConcurrentPair[A, ConcurrentPair[B, C]] -⚬ ConcurrentPair[ConcurrentPair[A, B], C]

Attributes

Definition Classes
override def backvert[A]: ConcurrentPair[A, -[A]] -⚬ One 
 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎  A │┄┄┐   ┃
 ┟────┘  ┆   ┃
 ┃       ┆   ┃
 ┞────┐  ┆   ┃
 ╎-[A]│←┄┘   ┃
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

Definition Classes
override def choice[A, B, C](f: A -⚬ B, g: A -⚬ C): A -⚬ B |&| C

Attributes

Definition Classes
override def chooseL[A, B]: A |&| B -⚬ A

Attributes

Definition Classes
override def chooseLOnPong[A, B]: A |&| B -⚬ ConcurrentPair[Pong, A]

Attributes

Definition Classes
override def chooseR[A, B]: A |&| B -⚬ B

Attributes

Definition Classes
override def coDistributeL[A, B, C]: ConcurrentPair[A, B] |&| ConcurrentPair[A, C] -⚬ ConcurrentPair[A, B |&| C]

Inverse of coFactorL.

Inverse of coFactorL.

Attributes

Definition Classes
override def constNeg[A](a: A): Neg[A] -⚬ Need

Attributes

Definition Classes
override def constVal[A](a: A): Done -⚬ Val[A]

Attributes

Definition Classes
override def crashWhenDone[A, B](msg: String): ConcurrentPair[Done, A] -⚬ B

Starts propagating an error downstream (which might be through both the in-port and the out-port).

Starts propagating an error downstream (which might be through both the in-port and the out-port).

Use only for irrecoverable errors. Recoverable errors should be expressed in function signature and handled appropriately.

Done on the in-port is the trigger to crash. A on the in-port allows to consume any unhandled resources. B on the out-port allows to fulfill any obligation to produce resources.

Attributes

Definition Classes
override def debugPrint(msg: String): Ping -⚬ One

Prints the given message to the console, without creating an obligation to await.

Prints the given message to the console, without creating an obligation to await.

Attributes

Definition Classes
override def delay: Val[FiniteDuration] -⚬ Done

Attributes

Definition Classes
override def delayIndefinitely: Done -⚬ RTerminus

Attributes

Definition Classes
override def distributeInversion[A, B]: -[ConcurrentPair[A, B]] -⚬ ConcurrentPair[-[A], -[B]] 
 ┏━━━━━━━━━━━┓
 ┃           ┞────┐
 ┞────┐      ╎-[A]│
 ╎ ⎡A⎤│      ┟────┘
 ╎-⎢⊗⎥│      ┃
 ╎ ⎣B⎦│      ┞────┐
 ┟────┘      ╎-[B]│
 ┃           ┟────┘
 ┗━━━━━━━━━━━┛

Attributes

Definition Classes
override def distributeL[A, B, C]: ConcurrentPair[A, B |+| C] -⚬ ConcurrentPair[A, B] |+| ConcurrentPair[A, C]

Distribute the factor on the left into the summands on the right. Inverse of factorL.

Distribute the factor on the left into the summands on the right. Inverse of factorL.

Attributes

Definition Classes
override def effect[R, A, B](f: ScalaFunction[(R, A), B]): ConcurrentPair[Res[R], Val[A]] -⚬ ConcurrentPair[Res[R], Val[B]]

Attributes

Definition Classes
override def effectWr[R, A](f: ScalaFunction[(R, A), Unit]): ConcurrentPair[Res[R], Val[A]] -⚬ Res[R]

Attributes

Definition Classes
override def either[A, B, C](f: A -⚬ C, g: B -⚬ C): A |+| B -⚬ C

Attributes

Definition Classes
override def elimFst[B]: ConcurrentPair[One, B] -⚬ B

Attributes

Definition Classes
override def elimSnd[A]: ConcurrentPair[A, One] -⚬ A

Attributes

Definition Classes
override def factorOutInversion[A, B]: ConcurrentPair[-[A], -[B]] -⚬ -[ConcurrentPair[A, B]] 
 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎-[A]│      ┞────┐
 ┟────┘      ╎ ⎡A⎤│
 ┃           ╎-⎢⊗⎥│
 ┞────┐      ╎ ⎣B⎦│
 ╎-[B]│      ┟────┘
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

Definition Classes
override def forevert[A]: One -⚬ ConcurrentPair[-[A], A] 
 ┏━━━━━━┓
 ┃      ┞────┐
 ┃   ┌┄┄╎-[A]│
 ┃   ┆  ┟────┘
 ┃   ┆  ┃
 ┃   ┆  ┞────┐
 ┃   └┄→╎  A │
 ┃      ┟────┘
 ┗━━━━━━┛

Attributes

Definition Classes
override def fork: Done -⚬ ConcurrentPair[Done, Done]

Attributes

Definition Classes
override def forkNeed: ConcurrentPair[Need, Need] -⚬ Need

Attributes

Definition Classes
override def forkPing: Ping -⚬ ConcurrentPair[Ping, Ping]

Attributes

Definition Classes
override def forkPong: ConcurrentPair[Pong, Pong] -⚬ Pong

Attributes

Definition Classes
override def id[A]: A -⚬ A

Attributes

Definition Classes
override def injectL[A, B]: A -⚬ A |+| B

Attributes

Definition Classes
override def injectLOnPing[A, B]: ConcurrentPair[Ping, A] -⚬ A |+| B

Attributes

Definition Classes
override def injectR[A, B]: B -⚬ A |+| B

Attributes

Definition Classes
override def introFst[B]: B -⚬ ConcurrentPair[One, B]

Attributes

Definition Classes
override def introSnd[A]: A -⚬ ConcurrentPair[A, One]

Attributes

Definition Classes
override def join: ConcurrentPair[Done, Done] -⚬ Done

Attributes

Definition Classes
override def joinLTermini: LTerminus -⚬ ConcurrentPair[LTerminus, LTerminus]

Attributes

Definition Classes
override def joinNeed: Need -⚬ ConcurrentPair[Need, Need]

Attributes

Definition Classes
override def joinPing: ConcurrentPair[Ping, Ping] -⚬ Ping

Attributes

Definition Classes
override def joinPong: Pong -⚬ ConcurrentPair[Pong, Pong]

Attributes

Definition Classes
override def joinRTermini: ConcurrentPair[RTerminus, RTerminus] -⚬ RTerminus

Attributes

Definition Classes
override def lInvertPongPing: One -⚬ ConcurrentPair[Pong, Ping]

Attributes

Definition Classes
override def lInvertSignal: One -⚬ ConcurrentPair[Need, Done]

Reverses the Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow) into a Done signal (flowing in the positive direction, i.e. along the -⚬ arrow).

Reverses the Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow) into a Done signal (flowing in the positive direction, i.e. along the -⚬ arrow).

 ┏━━━━━━┓
 ┃      ┞────┐
 ┃   ┌┄┄╎Need│
 ┃   ┆  ┟────┘
 ┃   ┆  ┃
 ┃   ┆  ┞────┐
 ┃   └┄→╎Done│
 ┃      ┟────┘
 ┗━━━━━━┛

Attributes

Definition Classes
override def lInvertTerminus: One -⚬ ConcurrentPair[LTerminus, RTerminus]

Attributes

Definition Classes
override def liftEither[A, B]: Val[Either[A, B]] -⚬ Val[A] |+| Val[B]

Attributes

Definition Classes
override def liftPair[A, B]: Val[(A, B)] -⚬ ConcurrentPair[Val[A], Val[B]]

Attributes

Definition Classes
override def mapVal[A, B](f: ScalaFunction[A, B]): Val[A] -⚬ Val[B]

Attributes

Definition Classes
override def neglect[A]: Val[A] -⚬ Done

Attributes

Definition Classes
override def notifyChoice[A, B]: ConcurrentPair[Pong, A |&| B] -⚬ A |&| B

Signals (in the negative direction) when it is known which side of the choice (A |&| B) has been chosen.

Signals (in the negative direction) when it is known which side of the choice (A |&| B) has been chosen.

Attributes

Definition Classes
override def notifyDoneL: Done -⚬ ConcurrentPair[Ping, Done]

Attributes

Definition Classes
override def notifyEither[A, B]: A |+| B -⚬ ConcurrentPair[Ping, A |+| B]

Signals when it is decided whether A |+| B actually contains the left side or the right side.

Signals when it is decided whether A |+| B actually contains the left side or the right side.

Attributes

Definition Classes
override def notifyNeedL: ConcurrentPair[Pong, Need] -⚬ Need

Attributes

Definition Classes
override def notifyNeg[A]: ConcurrentPair[Pong, Neg[A]] -⚬ Neg[A]

Attributes

Definition Classes
override def notifyVal[A]: Val[A] -⚬ ConcurrentPair[Ping, Val[A]]

Attributes

Definition Classes
override def pack[F[_]]: F[Rec[F]] -⚬ Rec[F]

Hides one level of a recursive type definition.

Hides one level of a recursive type definition.

Attributes

Definition Classes
override def par[A, B, C, D](f: A -⚬ B, g: C -⚬ D): ConcurrentPair[A, C] -⚬ ConcurrentPair[B, D]

Attributes

Definition Classes
override def ping: One -⚬ Ping

Attributes

Definition Classes
override def pong: Pong -⚬ One

Attributes

Definition Classes
override def rInvertPingPong: ConcurrentPair[Ping, Pong] -⚬ One

Attributes

Definition Classes
override def rInvertSignal: ConcurrentPair[Done, Need] -⚬ One

Reverses the Done signal (flowing in the positive direction, i.e. along the -⚬ arrow) into a Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow).

Reverses the Done signal (flowing in the positive direction, i.e. along the -⚬ arrow) into a Need signal (flowing in the negative direciton, i.e. against the -⚬ arrow).

 ┏━━━━━━━━━━━┓
 ┞────┐      ┃
 ╎Done│┄┄┐   ┃
 ┟────┘  ┆   ┃
 ┃       ┆   ┃
 ┞────┐  ┆   ┃
 ╎Need│←┄┘   ┃
 ┟────┘      ┃
 ┗━━━━━━━━━━━┛

Attributes

Definition Classes
override def rInvertTerminus: ConcurrentPair[RTerminus, LTerminus] -⚬ One

Attributes

Definition Classes
override def racePair: ConcurrentPair[Ping, Ping] -⚬ One |+| One

Races the two Ping signals. Produces left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, returns left.

Races the two Ping signals. Produces left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, returns left.

Attributes

Definition Classes
override def rec[A, B](f: A -⚬ B => A -⚬ B): A -⚬ B

Attributes

Definition Classes
override def regressInfinitely: LTerminus -⚬ Need

Attributes

Definition Classes
override def release[R]: Res[R] -⚬ Done

Releases a resource using the release function registered during resource acquisition.

Releases a resource using the release function registered during resource acquisition.

Attributes

Definition Classes
override def releaseWith[R, A, B](f: ScalaFunction[(R, A), B]): ConcurrentPair[Res[R], Val[A]] -⚬ Val[B]

Attributes

Definition Classes
override def selectPair: One |&| One -⚬ ConcurrentPair[Pong, Pong]

Races the two Pong signals (traveling from right to left). Chooses left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, chooses left.

Races the two Pong signals (traveling from right to left). Chooses left if the first signal wins and right if the second signal wins. It is biased to the left: if both signals have arrived by the time of inquiry, chooses left.

Attributes

Definition Classes
override def strengthenPing: Ping -⚬ Done

Attributes

Definition Classes
override def strengthenPong: Need -⚬ Pong

Attributes

Definition Classes
override def swap[A, B]: ConcurrentPair[A, B] -⚬ ConcurrentPair[B, A]

Attributes

Definition Classes
override def switchVal[A, R](a: Expr[Val[A]], cases: Cases[A, A, R])(pos: SourcePos)(using Context): Expr[R]

Attributes

Definition Classes
override def tryAcquire[A, R, B, E](acquire: ScalaFunction[A, Either[E, (R, B)]], release: Option[ScalaFunction[R, Unit]]): Val[A] -⚬ Val[E] |+| ConcurrentPair[Res[R], Val[B]]

Attributes

Definition Classes
override def tryEffectAcquire[R, A, S, B, E](f: ScalaFunction[(R, A), Either[E, (S, B)]], release: Option[ScalaFunction[S, Unit]]): ConcurrentPair[Res[R], Val[A]] -⚬ ConcurrentPair[Res[R], Val[E] |+| ConcurrentPair[Res[S], Val[B]]]

Attributes

Definition Classes
override def trySplitResource[R, A, S, T, B, E](f: ScalaFunction[(R, A), Either[E, (S, T, B)]], release1: Option[ScalaFunction[S, Unit]], release2: Option[ScalaFunction[T, Unit]]): ConcurrentPair[Res[R], Val[A]] -⚬ Val[E] |+| ConcurrentPair[ConcurrentPair[Res[S], Res[T]], Val[B]]

Attributes

Definition Classes
override def tryTransformResource[R, A, S, B, E](f: ScalaFunction[(R, A), Either[E, (S, B)]], release: Option[ScalaFunction[S, Unit]]): ConcurrentPair[Res[R], Val[A]] -⚬ Val[E] |+| ConcurrentPair[Res[S], Val[B]]

Attributes

Definition Classes
override def unliftPair[A, B]: ConcurrentPair[Val[A], Val[B]] -⚬ Val[(A, B)]

Attributes

Definition Classes
override def unpack[F[_]]: Rec[F] -⚬ F[Rec[F]]

Unpacks one level of a recursive type definition.

Unpacks one level of a recursive type definition.

Attributes

Definition Classes

Inherited methods

def acquire[A, R, B](acquire: A => (R, B), release: Option[R => Unit]): Val[A] -⚬ Res[R] |*| Val[B]

Acquires a resource of type R.

Acquires a resource of type R.

Type parameters

A

parameters of the acquire function

B

additional data produced by acquiring the resource

R

type of the resource

Value parameters

release

called to release the resource in case of a crash. None means no cleanup is needed

Attributes

Inherited from:
Scaletto
def acquireAsync[A, R, B](acquire: A => Async[(R, B)], release: Option[R => Async[Unit]]): Val[A] -⚬ Res[R] |*| Val[B]

Attributes

Inherited from:
Scaletto
def blocking[A, B](f: A => B): Val[A] -⚬ Val[B]

Executes a potentially blocking operation. The runtime will ensure that the blocking operation does not impede any of the concurrently happening non-blocking computations.

Executes a potentially blocking operation. The runtime will ensure that the blocking operation does not impede any of the concurrently happening non-blocking computations.

Attributes

Inherited from:
Scaletto
def chooseROnPong[A, B]: A |&| B -⚬ Pong |*| B

Attributes

Inherited from:
CoreDSL
def coDistributeR[A, B, C]: A |*| C |&| B |*| C -⚬ A |&| B |*| C

Inverse of coFactorR.

Inverse of coFactorR.

Attributes

Inherited from:
CoreDSL
def coFactorL[A, B, C]: A |*| B |&| C -⚬ A |*| B |&| A |*| C

Attributes

Inherited from:
CoreDSL
def coFactorR[A, B, C]: A |&| B |*| C -⚬ A |*| C |&| B |*| C

Attributes

Inherited from:
CoreDSL
def constant[A](f: One -⚬ A)(using SourcePos, LambdaContext): $[A]

Attributes

Inherited from:
CoreDSL
def constantVal[A](a: A)(using SourcePos, LambdaContext): $[Val[A]]

Attributes

Inherited from:
Scaletto
def contramapNeg[A, B](f: A => B): Neg[B] -⚬ Neg[A]

Lifts an ordinary Scala function to a linear function on demands, in opposite direction.

Lifts an ordinary Scala function to a linear function on demands, in opposite direction.

Attributes

Inherited from:
Scaletto
def contrapositive[A, B](f: A -⚬ B): -[B] -⚬ -[A]

Attributes

Inherited from:
InvertDSL
def crashNow[A, B](msg: String): A -⚬ B

Attributes

Inherited from:
CrashDSL
def crashWhenNeed[A, B](msg: String): A -⚬ Need |*| B

Attributes

Inherited from:
CrashDSL
def crashd(msg: String): Done -⚬ Done

Attributes

Inherited from:
CrashDSL
def crashn(msg: String): Need -⚬ Need

Attributes

Inherited from:
CrashDSL
override def curry[A, B, C](f: ConcurrentPair[A, B] -⚬ C): A -⚬ B =⚬ C

Attributes

Definition Classes
Inherited from:
InvertDSL
override def delay(d: FiniteDuration): Done -⚬ Done

Attributes

Definition Classes
Inherited from:
Scaletto
def delayNeed: Need -⚬ Neg[FiniteDuration]

Attributes

Inherited from:
Scaletto
def delayNeed(d: FiniteDuration): Need -⚬ Need

Attributes

Inherited from:
TimerDSL
def demand[A]: One -⚬ -[A] |*| A

Creates a demand on the first out-port, channeling the provided resource to the second out-port. Alias for forevert.

Creates a demand on the first out-port, channeling the provided resource to the second out-port. Alias for forevert.

Attributes

Inherited from:
InvertDSL
def demandChoice[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]

Converts an obligation to handle either demand to an obligation to supply a choice. Alias for factorInversionOutOf_|+|.

Converts an obligation to handle either demand to an obligation to supply a choice. Alias for factorInversionOutOf_|+|.

Attributes

Inherited from:
InvertDSL
def demandChosen[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]

Converts a demand for choice to a demand of the chosen side. Alias for distributeInversionInto_|&amp;|.

Converts a demand for choice to a demand of the chosen side. Alias for distributeInversionInto_|&amp;|.

Attributes

Inherited from:
InvertDSL
def demandEither[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]

Converts choice of demands to demand of either. Alias for factorInversionOutOf_|&amp;|.

Converts choice of demands to demand of either. Alias for factorInversionOutOf_|&amp;|.

Attributes

Inherited from:
InvertDSL
def demandSeparately[A, B]: -[A |*| B] -⚬ -[A] |*| -[B]

Alias for distributeInversion

Alias for distributeInversion

Attributes

Inherited from:
InvertDSL
def demandTogether[A, B]: -[A] |*| -[B] -⚬ -[A |*| B]

Alias for factorOutInversion.

Alias for factorOutInversion.

Attributes

Inherited from:
InvertDSL
def die[A]: -[-[A]] -⚬ A

Double-inversion elimination.

Double-inversion elimination.

Attributes

Inherited from:
InvertDSL
def dii[A]: A -⚬ -[-[A]]

Double-inversion introduction.

Double-inversion introduction.

Attributes

Inherited from:
InvertDSL
def dismissPing: Ping -⚬ One

Attributes

Inherited from:
CoreDSL
def dismissPong: One -⚬ Pong

Attributes

Inherited from:
CoreDSL
def distributeInversionInto_|&|[A, B]: -[A |&| B] -⚬ -[A] |+| -[B]

Attributes

Inherited from:
InvertDSL
def distributeInversionInto_|+|[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]

Attributes

Inherited from:
InvertDSL
def distributeR[A, B, C]: A |+| B |*| C -⚬ A |*| C |+| B |*| C

Distribute the factor on the right into the summands on the left. Inverse of factorR.

Distribute the factor on the right into the summands on the left. Inverse of factorR.

Attributes

Inherited from:
CoreDSL
def done: One -⚬ Done

Attributes

Inherited from:
CoreDSL
def doneAsInvertedNeed: Done -⚬ -[Need]

Attributes

Inherited from:
InvertDSL
def doubleDemandElimination[A]: -[-[A]] -⚬ A

Alias for die.

Alias for die.

Attributes

Inherited from:
InvertDSL
def doubleDemandIntroduction[A]: A -⚬ -[-[A]]

Alias for dii.

Alias for dii.

Attributes

Inherited from:
InvertDSL
def dup[A]: Val[A] -⚬ Val[A] |*| Val[A]

Attributes

Inherited from:
Scaletto
def dupNeg[A]: Neg[A] |*| Neg[A] -⚬ Neg[A]

Attributes

Inherited from:
Scaletto
def effect[R, A, B](f: (R, A) => B): Res[R] |*| Val[A] -⚬ Res[R] |*| Val[B]

Performs a (potentially) effectful operation on a resource, producing some output.

Performs a (potentially) effectful operation on a resource, producing some output.

Type parameters

A

additional parameter of the operation

B

additional output of the operation

R

type of the resource

Value parameters

f

the effectful operation

Attributes

Inherited from:
Scaletto
def effectAsync[R, A, B](f: (R, A) => Async[B]): Res[R] |*| Val[A] -⚬ Res[R] |*| Val[B]

Attributes

Inherited from:
Scaletto
def effectWr[R, A](f: (R, A) => Unit): Res[R] |*| Val[A] -⚬ Res[R]

Variant of effect that does not produce output in addition to performing the effect. Can be viewed as ''wr''iting an A into the resource.

Variant of effect that does not produce output in addition to performing the effect. Can be viewed as ''wr''iting an A into the resource.

Attributes

Inherited from:
Scaletto
def effectWrAsync[R, A](f: (R, A) => Async[Unit]): Res[R] |*| Val[A] -⚬ Res[R]

Attributes

Inherited from:
Scaletto
def elimFst[A, B](f: A -⚬ One): A |*| B -⚬ B

Attributes

Inherited from:
CoreDSL
def elimSnd[A, B](f: B -⚬ One): A |*| B -⚬ A

Attributes

Inherited from:
CoreDSL
override def eval[A, B]: A =⚬ B |*| A -⚬ B

Attributes

Definition Classes
Inherited from:
InvertDSL
def factorInversionOutOf_|&|[A, B]: -[A] |&| -[B] -⚬ -[A |+| B]

Attributes

Inherited from:
InvertDSL
def factorInversionOutOf_|+|[A, B]: -[A] |+| -[B] -⚬ -[A |&| B]

Attributes

Inherited from:
InvertDSL
def factorL[A, B, C]: A |*| B |+| A |*| C -⚬ A |*| B |+| C

Factor out the factor A on the left of both summands.

Factor out the factor A on the left of both summands.

Attributes

Inherited from:
CoreDSL
def factorR[A, B, C]: A |*| C |+| B |*| C -⚬ A |+| B |*| C

Factor out the factor C on the right of both summands.

Factor out the factor C on the right of both summands.

Attributes

Inherited from:
CoreDSL
def forkMap[A, B](f: Done -⚬ A, g: Done -⚬ B): Done -⚬ A |*| B

Attributes

Inherited from:
CoreDSL
def forkMapNeed[A, B](f: A -⚬ Need, g: B -⚬ Need): A |*| B -⚬ Need

Attributes

Inherited from:
CoreDSL
def fst[A, B, C](f: A -⚬ B): A |*| C -⚬ B |*| C

Attributes

Inherited from:
CoreDSL
def fulfill[A]: Val[A] |*| Neg[A] -⚬ One

Uses the value (eventually) produced by Val to satisfy the demand of Neg.

Uses the value (eventually) produced by Val to satisfy the demand of Neg.

Attributes

Inherited from:
Scaletto
def inflate[A]: Need -⚬ Neg[A]

Attributes

Inherited from:
Scaletto
def injectROnPing[A, B]: Ping |*| B -⚬ A |+| B

Attributes

Inherited from:
CoreDSL
def introFst[A, X](f: One -⚬ X): A -⚬ X |*| A

Attributes

Inherited from:
CoreDSL
def introSnd[A, X](f: One -⚬ X): A -⚬ A |*| X

Attributes

Inherited from:
CoreDSL
def invertClosure[A, B]: -[A =⚬ B] -⚬ B =⚬ A

Attributes

Inherited from:
InvertDSL
def invertOne: One -⚬ -[One]

Attributes

Inherited from:
InvertDSL
def invertedDoneAsNeed: -[Done] -⚬ Need

Attributes

Inherited from:
InvertDSL
def invertedNeedAsDone: -[Need] -⚬ Done

Attributes

Inherited from:
InvertDSL
def invertedPingAsPong: -[Ping] -⚬ Pong

Attributes

Inherited from:
InvertDSL
def invertedPongAsPing: -[Pong] -⚬ Ping

Attributes

Inherited from:
InvertDSL
def joinAll(a: Expr[Done], as: Expr[Done]*)(using pos: SourcePos, ctx: LambdaContext): $[Done]

Attributes

Inherited from:
CoreDSL
def joinMap[A, B](f: A -⚬ Done, g: B -⚬ Done): A |*| B -⚬ Done

Attributes

Inherited from:
CoreDSL
def joinMapNeed[A, B](f: Need -⚬ A, g: Need -⚬ B): Need -⚬ A |*| B

Attributes

Inherited from:
CoreDSL
def liftNegPair[A, B]: Neg[(A, B)] -⚬ Neg[A] |*| Neg[B]

Attributes

Inherited from:
Scaletto
def mapVal[A, B](f: A => B): Val[A] -⚬ Val[B]

Lifts an ordinary Scala function to a linear function on Vals.

Lifts an ordinary Scala function to a linear function on Vals.

Attributes

Inherited from:
Scaletto
def need: Need -⚬ One

Attributes

Inherited from:
CoreDSL
def needAsInvertedDone: Need -⚬ -[Done]

Attributes

Inherited from:
InvertDSL
def notifyDoneR: Done -⚬ Done |*| Ping

Attributes

Inherited from:
CoreDSL
def notifyNeedR: Need |*| Pong -⚬ Need

Attributes

Inherited from:
CoreDSL
def obj[A, B](f: A -⚬ B): One -⚬ A =⚬ B

Turn a function into a function object.

Turn a function into a function object.

Attributes

Inherited from:
ClosedDSL
override def out[A, B, C](f: B -⚬ C): A =⚬ B -⚬ A =⚬ C

Map the output of a function object.

Map the output of a function object.

Attributes

Definition Classes
Inherited from:
InvertDSL
def packDemand[F[_]]: -[F[Rec[F]]] -⚬ -[Rec[F]]

Attributes

Inherited from:
InvertDSL
def pingAsInvertedPong: Ping -⚬ -[Pong]

Attributes

Inherited from:
InvertDSL
def pongAsInvertedPing: Pong -⚬ -[Ping]

Attributes

Inherited from:
InvertDSL
def promise[A]: One -⚬ Neg[A] |*| Val[A]

Creates an entangled pair of demand (Neg) and supply (Val) such that when the demand is fulfilled with a value, that value will be produced by the supply.

Creates an entangled pair of demand (Neg) and supply (Val) such that when the demand is fulfilled with a value, that value will be produced by the supply.

Attributes

Inherited from:
Scaletto
def release[R, A, B](f: (R, A) => B): Res[R] |*| Val[A] -⚬ Val[B]

Releases a resource using the given function. The release function previously registered during resource acquisition is not used.

Releases a resource using the given function. The release function previously registered during resource acquisition is not used.

Type parameters

A

additional parameter of the release function

B

additional data produced by the release function

R

type of the resource

Value parameters

f

the release function

Attributes

Inherited from:
Scaletto
def releaseAsync[R, A, B](f: (R, A) => Async[B]): Res[R] |*| Val[A] -⚬ Val[B]

Attributes

Inherited from:
Scaletto
def returning[A](a: ??[A], as: ??[One]*)(using pos: SourcePos, ctx: LambdaContext): ??[A]

Attributes

Inherited from:
InvertDSL
def returning[A](a: Expr[A], as: Expr[One]*)(using pos: SourcePos, ctx: LambdaContext): $[A]

Attributes

Inherited from:
CoreDSL
def snd[A, B, C](f: B -⚬ C): A |*| B -⚬ A |*| C

Attributes

Inherited from:
CoreDSL
def splitResource[R, A, S, T, B](f: (R, A) => (S, T, B), release1: Option[S => Unit], release2: Option[T => Unit]): Res[R] |*| Val[A] -⚬ Res[S] |*| Res[T] |*| Val[B]

Attributes

Inherited from:
Scaletto
def splitResource[R, A, S, T, B](f: ScalaFunction[(R, A), (S, T, B)], release1: Option[ScalaFunction[S, Unit]], release2: Option[ScalaFunction[T, Unit]]): Res[R] |*| Val[A] -⚬ Res[S] |*| Res[T] |*| Val[B]

Attributes

Inherited from:
Scaletto
def splitResourceAsync[R, A, S, T, B](f: (R, A) => Async[(S, T, B)], release1: Option[S => Async[Unit]], release2: Option[T => Async[Unit]]): Res[R] |*| Val[A] -⚬ Res[S] |*| Res[T] |*| Val[B]

Attributes

Inherited from:
Scaletto
def supply[A]: A |*| -[A] -⚬ One

Uses the resource from the first in-port to satisfy the demand from the second in-port. Alias for backvert.

Uses the resource from the first in-port to satisfy the demand from the second in-port. Alias for backvert.

Attributes

Inherited from:
InvertDSL
def switch[A](using pos: SourcePos)(a: Expr[Val[A]])(using LambdaContext): ValSwitchInit[A]

Attributes

Inherited from:
Scaletto
def toChoiceOfDemands[A, B]: -[A |+| B] -⚬ -[A] |&| -[B]

Converts demand for either to a choice of which side to supply. Alias for distributeInversionInto_|+|.

Converts demand for either to a choice of which side to supply. Alias for distributeInversionInto_|+|.

Attributes

Inherited from:
InvertDSL
def transformResource[R, A, S, B](f: (R, A) => (S, B), release: Option[S => Unit]): Res[R] |*| Val[A] -⚬ Res[S] |*| Val[B]

Transforms a resource into a resource of (possibly) different type.

Transforms a resource into a resource of (possibly) different type.

Type parameters

A

additional parameter of the transformation

B

additional output of the transformation

R

type of the input resource

S

type of the output resource

Value parameters

f

the transformation function. It receives the input resource and additional input of type A. It returns the new resource and additional output of type B.

release

called to release the new resource in case of a crash. None means no cleanup is needed

Attributes

Inherited from:
Scaletto
def transformResourceAsync[R, A, S, B](f: (R, A) => Async[(S, B)], release: Option[S => Async[Unit]]): Res[R] |*| Val[A] -⚬ Res[S] |*| Val[B]

Attributes

Inherited from:
Scaletto
def tryAcquire[A, R, B, E](acquire: A => Either[E, (R, B)], release: Option[R => Unit]): Val[A] -⚬ Val[E] |+| Res[R] |*| Val[B]

Acquires a resource of type R. Might fail with an error of type E.

Acquires a resource of type R. Might fail with an error of type E.

Type parameters

A

parameters of the acquire function

B

additional data produced by acquiring the resource

E

type of the error

R

type of the resource

Value parameters

release

called to release the resource in case of a crash. None means no cleanup is needed

Attributes

Inherited from:
Scaletto
def trySplitResource[R, A, S, T, B, E](f: (R, A) => Either[E, (S, T, B)], release1: Option[S => Unit], release2: Option[T => Unit]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Res[T] |*| Val[B]

Attributes

Inherited from:
Scaletto
def trySplitResourceAsync[R, A, S, T, B, E](f: (R, A) => Async[Either[E, (S, T, B)]], release1: Option[S => Async[Unit]], release2: Option[T => Async[Unit]]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Res[T] |*| Val[B]

Attributes

Inherited from:
Scaletto
def tryTransformResource[R, A, S, B, E](f: (R, A) => Either[E, (S, B)], release: Option[S => Unit]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Val[B]

Transforms a resource into a resource of (possibly) different type. Might fail with an error of type E.

Transforms a resource into a resource of (possibly) different type. Might fail with an error of type E.

Type parameters

A

additional parameter of the transformation

B

additional output of the transformation

E

type of the error

R

type of the input resource

S

type of the output resource

Value parameters

f

the transformation function. It receives the input resource and additional input of type A. It returns either an error of type E or the new resource and additional output of type B. In case the transformation results in an error, the original resource is ''not'' released automatically— the passing of the original resource R to the transformation function f indicates transfer of responsibility for the resource to the function f.

release

called to release the new resource in case of a crash. None means no cleanup is needed

Attributes

Inherited from:
Scaletto
def tryTransformResourceAsync[R, A, S, B, E](f: (R, A) => Async[Either[E, (S, B)]], release: Option[S => Async[Unit]]): Res[R] |*| Val[A] -⚬ Val[E] |+| Res[S] |*| Val[B]

Attributes

Inherited from:
Scaletto
def tuple[A, B, C, D, E, F](a: Expr[Val[A]], b: Expr[Val[B]], c: Expr[Val[C]], d: Expr[Val[D]], e: Expr[Val[E]], f: Expr[Val[F]])(using SourcePos, LambdaContext): $[Val[(A, B, C, D, E, F)]]

Attributes

Inherited from:
Scaletto
def tuple[A, B, C, D, E](a: Expr[Val[A]], b: Expr[Val[B]], c: Expr[Val[C]], d: Expr[Val[D]], e: Expr[Val[E]])(using SourcePos, LambdaContext): $[Val[(A, B, C, D, E)]]

Attributes

Inherited from:
Scaletto
def tuple[A, B, C, D](a: Expr[Val[A]], b: Expr[Val[B]], c: Expr[Val[C]], d: Expr[Val[D]])(using SourcePos, LambdaContext): $[Val[(A, B, C, D)]]

Attributes

Inherited from:
Scaletto
def tuple[A, B, C](a: Expr[Val[A]], b: Expr[Val[B]], c: Expr[Val[C]])(using SourcePos, LambdaContext): $[Val[(A, B, C)]]

Attributes

Inherited from:
Scaletto
def tuple[A, B](a: Expr[Val[A]], b: Expr[Val[B]])(using SourcePos, LambdaContext): $[Val[(A, B)]]

Attributes

Inherited from:
Scaletto
def unContrapositive[A, B](f: -[A] -⚬ -[B]): B -⚬ A

Attributes

Inherited from:
InvertDSL
def unInvertClosure[A, B]: A =⚬ B -⚬ -[B =⚬ A]

Attributes

Inherited from:
InvertDSL
def unInvertOne: -[One] -⚬ One

Attributes

Inherited from:
InvertDSL
def uncurry[A, B, C](f: A -⚬ B =⚬ C): A |*| B -⚬ C

Attributes

Inherited from:
ClosedDSL
def unliftEither[A, B]: Val[A] |+| Val[B] -⚬ Val[Either[A, B]]

Attributes

Inherited from:
Scaletto
def unliftNegPair[A, B]: Neg[A] |*| Neg[B] -⚬ Neg[(A, B)]

Attributes

Inherited from:
Scaletto
def unpackDemand[F[_]]: -[Rec[F]] -⚬ -[F[Rec[F]]]

Attributes

Inherited from:
InvertDSL

Deprecated and Inherited methods

def Λ[A, B](using SourcePos, LambdaContext)(f: Expr[A] => Expr[B]): $[A =⚬ B]

Alias for λ.closure.apply.

Alias for λ.closure.apply.

Attributes

Deprecated
[Since version 0.2]
Inherited from:
ClosedDSL

Concrete fields

override val $: FunExprOps
val lambdas: Lambdas[-⚬, |*|, VarOrigin]
override val λ: LambdaOpsWithClosures

Givens

Givens

given ℭ: ℭ.type

Inherited givens

given given_BiInjective_|*|: given_BiInjective_|*|.type

Attributes

Inherited from:
FreeScaletto

Extensions

Inherited extensions

extension [A](a: Expr[A])
def asOutput[B](rInvert: ConcurrentPair[A, B] -⚬ One)(using pos: SourcePos, ctx: LambdaContext): ??[B]

Attributes

Inherited from:
InvertDSL
def supplyTo(out: Expr[-[A]])(using pos: SourcePos, ctx: LambdaContext): $[One]

Attributes

Inherited from:
InvertDSL
extension [A](a: $[A])
def :>:(b: ??[A]): ??[One]

Attributes

Inherited from:
InvertDSL
extension [A](a: ??[-[A]])
def asInput(using pos: SourcePos, ctx: LambdaContext): $[A]

Attributes

Inherited from:
InvertDSL
extension [A](a: Expr[A])
def :>>[B](f: A -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[B]

Reverse application: pass this expression into the given function.

Reverse application: pass this expression into the given function.

Attributes

Inherited from:
CoreDSL
def >[B](f: A -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[B]

Alias for :&gt;&gt;

Alias for :&gt;&gt;

Attributes

Inherited from:
CoreDSL
def also[B](f: One -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[A |*| B]

Attributes

Inherited from:
CoreDSL
def alsoElim(unit: Expr[One])(using pos: SourcePos, ctx: LambdaContext): $[A]

Attributes

Inherited from:
CoreDSL
def alsoFst[X](f: One -⚬ X)(using pos: SourcePos, ctx: LambdaContext): $[X |*| A]

Attributes

Inherited from:
CoreDSL
def |*|[B](b: Expr[B])(using pos: SourcePos, ctx: LambdaContext): $[A |*| B]

Attributes

Inherited from:
CoreDSL
extension (d: Expr[Done])
def alsoJoin(others: Expr[Done]*)(using pos: SourcePos, ctx: LambdaContext): $[Done]

Attributes

Inherited from:
CoreDSL
extension [B](expr: Expr[-[B]])
def contramap[A](f: A -⚬ B)(using pos: SourcePos, ctx: LambdaContext): $[-[A]]

Attributes

Inherited from:
InvertDSL
def unInvertWith[A](lInvert: One -⚬ ConcurrentPair[A, B])(using pos: SourcePos, ctx: LambdaContext): $[A]

Attributes

Inherited from:
InvertDSL
extension [B](expr: ??[B])
def :=(value: Expr[B])(using pos: SourcePos, ctx: LambdaContext): ??[One]

Attributes

Inherited from:
InvertDSL
def alsoElim(that: ??[One])(using pos: SourcePos, ctx: LambdaContext): ??[B]

Attributes

Inherited from:
InvertDSL
def asInput[A](lInvert: One -⚬ ConcurrentPair[B, A])(using pos: SourcePos, ctx: LambdaContext): $[A]

Attributes

Inherited from:
InvertDSL
def |*|[C](that: ??[C])(using pos: SourcePos, ctx: LambdaContext): ??[B |*| C]

Attributes

Inherited from:
InvertDSL
extension [A, B](f: ScalaFunction[A, B])
def adapt[Z, C](pre: Z => A, post: B => C): ScalaFun[Z, C]

Attributes

Inherited from:
Scaletto
def adaptPost[C](post: B => C): ScalaFun[A, C]

Attributes

Inherited from:
Scaletto
def adaptPre[Z](pre: Z => A): ScalaFun[Z, B]

Attributes

Inherited from:
Scaletto
def adaptWith[Z, P, C](pre: Z => (P, A), post: (P, B) => C): ScalaFun[Z, C]

Attributes

Inherited from:
Scaletto
extension [A, B](f: A -⚬ B)
def >>:(expr: ??[B]): ??[A]

Attributes

Inherited from:
InvertDSL
extension [A, B](f: A -⚬ B)
def apply(a: Expr[A])(using pos: SourcePos, ctx: LambdaContext): $[B]

Attributes

Inherited from:
CoreDSL
extension [A, B](x: ??[A |&| B])
def switch[C](f: LambdaContext ?=> Either[??[A], ??[B]] => ??[C])(using pos: SourcePos, ctx: LambdaContext): ??[C]

Attributes

Inherited from:
InvertDSL
extension [A, B](x: Expr[A |+| B])
def switch[C](f: LambdaContext ?=> Either[Expr[A], Expr[B]] => Expr[C])(using pos: SourcePos, ctx: LambdaContext): $[C]

Attributes

Inherited from:
CoreDSL

Implicits

Inherited implicits

final implicit def FunctorOps[F[_], A](fa: Expr[F[A]]): FunctorOps[F, A]

Attributes

Inherited from:
CoreDSL
Generated with