libretto/libretto/ScalaLib

ScalaLib

class ScalaLib[DSL <: ScalaDSL, CoreLib <: CoreLib[DSL]](val dsl: DSL, val coreLib: CoreLib & CoreLib[DSL])
Companion
object
class Object
trait Matchable
class Any

Type members

Classlikes

object RefCounted
sealed trait ValMatcher[-U >: V, V, A, R]

Utility to construct a Libretto program that branches based on a Scala value inside a Val.

Utility to construct a Libretto program that branches based on a Scala value inside a Val.

Companion
object
object ValMatcher
Companion
class

Types

opaque type RefCounted[R]

Value members

Concrete methods

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

Variant of acquire that does not produce extra output in addition to the resource.

Variant of acquire that does not produce extra output in addition to the resource.

def acquireAsync0[A, R](acquire: A => Async[R], release: Option[R => Async[Unit]]): Val[A] -⚬ Res[R]

Variant of acquireAsync that does not produce extra output in addition to the resource.

Variant of acquireAsync that does not produce extra output in addition to the resource.

def alsoPrintLine: Val[String] -⚬ Val[String]
def alsoPrintLine[A](f: A => String): Val[A] -⚬ Val[A]
def alsoPrintLine[A](s: String)(S: Positive[A], J: Positive[A]): A -⚬ A
def const[A](a: A): One -⚬ Val[A]
def constList[A](as: List[A]): One -⚬ LList[Val[A]]
def constList1[A](a: A, as: List[A]): Done -⚬ LList1[Val[A]]
def constList1[A](as: ::[A]): Done -⚬ LList1[Val[A]]
def constList1Of[A](a: A, as: A*): Done -⚬ LList1[Val[A]]
def constListOf[A](as: A*): One -⚬ LList[Val[A]]
def constListOf1[A](a: A, as: A*): Done -⚬ LList[Val[A]]
def delayVal[A](by: Done -⚬ Done): Val[A] -⚬ Val[A]
def delayVal[A](by: FiniteDuration): Val[A] -⚬ Val[A]
def effect0[R](f: R => Unit): Res[R] -⚬ Res[R]

Variant of effect that does not take additional input and does not produce additional output.

Variant of effect that does not take additional input and does not produce additional output.

def effectAsync0[R](f: R => Async[Unit]): Res[R] -⚬ Res[R]

Variant of effectAsync that does not take additional input and does not produce additional output.

Variant of effectAsync that does not take additional input and does not produce additional output.

def effectRd[R, B](f: R => B): Res[R] -⚬ Res[R] |*| Val[B]
def equivBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(ord: Ordering[K]): A |*| B -⚬ A |*| B |+| A |*| B
def gtBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(ord: Ordering[K]): A |*| B -⚬ A |*| B |+| A |*| B
def gteqBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(ord: Ordering[K]): A |*| B -⚬ A |*| B |+| A |*| B
def isEq[A](ord: Ordering[A]): Val[A] |*| Val[A] -⚬ Bool
def isGt[A](ord: Ordering[A]): Val[A] |*| Val[A] -⚬ Bool
def isGteq[A](ord: Ordering[A]): Val[A] |*| Val[A] -⚬ Bool
def isLt[A](ord: Ordering[A]): Val[A] |*| Val[A] -⚬ Bool
def isLteq[A](ord: Ordering[A]): Val[A] |*| Val[A] -⚬ Bool
def liftBipredicate[A, B](p: (A, B) => Boolean): Val[A] |*| Val[B] -⚬ Bool
def liftBoolean: Val[Boolean] -⚬ Bool
def ltBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(ord: Ordering[K]): A |*| B -⚬ A |*| B |+| A |*| B
def lteqBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(ord: Ordering[K]): A |*| B -⚬ A |*| B |+| A |*| B
def mVal[A, R](init: A => R): Val[A] -⚬ Res[R]

Create a resource that is just a (potentially) mutable value which does not need any cleanup.

Create a resource that is just a (potentially) mutable value which does not need any cleanup.

Value Params
init

function that initializes the (potentially) mutable value from an immutable one.

def maybeToOption[A]: Maybe[Val[A]] -⚬ Val[Option[A]]
def mergeDemands[A]: Neg[A] |*| Neg[A] -⚬ Neg[A]
def optionToPMaybe[A]: Val[Option[A]] -⚬ PMaybe[Val[A]]
def pMaybeToOption[A]: PMaybe[Val[A]] -⚬ Val[Option[A]]
def printLine: Val[String] -⚬ Done
def printLine(s: String): Done -⚬ Done
def printLine[A](f: A => String): Val[A] -⚬ Done
def putStr: Val[String] -⚬ Done
def putStr(s: String): Done -⚬ Done
def readLine: Done -⚬ Val[String]
def release0[R, B](release: R => B): Res[R] -⚬ Val[B]

Variant of release that does not take additional input.

Variant of release that does not take additional input.

def releaseAsync0[R, B](release: R => Async[B]): Res[R] -⚬ Val[B]

Variant of releaseAsync that does not take additional input.

Variant of releaseAsync that does not take additional input.

def sortBy[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]])(`evidence$1`: Ordering[K]): A |*| B -⚬ A |*| B |+| B |*| A
def splitResource0[R, S, T](f: R => (S, T), release1: Option[S => Unit], release2: Option[T => Unit]): Res[R] -⚬ Res[S] |*| Res[T]
def splitResourceAsync0[R, S, T](f: R => Async[(S, T)], release1: Option[S => Async[Unit]], release2: Option[T => Async[Unit]]): Res[R] -⚬ Res[S] |*| Res[T]
def testByVals[A, B, K](aKey: Getter[A, Val[K]], bKey: Getter[B, Val[K]], pred: (K, K) => Boolean): A |*| B -⚬ A |*| B |+| A |*| B
def toScalaList[A]: LList[Val[A]] -⚬ Val[List[A]]
def transformResource0[R, S](f: R => S, release: Option[S => Unit]): Res[R] -⚬ Res[S]

Variant of transformResource that does not take additional input and does not produce additional output.

Variant of transformResource that does not take additional input and does not produce additional output.

def transformResourceAsync0[R, S](f: R => Async[S], release: Option[S => Async[Unit]]): Res[R] -⚬ Res[S]

Variant of transformResourceAsync that does not take additional input and does not produce additional output.

Variant of transformResourceAsync that does not take additional input and does not produce additional output.

def unliftBoolean: Bool -⚬ Val[Boolean]

Concrete fields

val coreLib: CoreLib & CoreLib[DSL]
val dsl: DSL

Implicits

Implicits

implicit def comparableVal[A](A: Ordering[A]): Comparable[Val[A], Val[A]]
implicit def junctionNeg[A]: Negative[Neg[A]]
implicit def junctionVal[A]: Positive[Val[A]]
implicit def nMonoidNeg[A]: NMonoid[Neg[A]]
implicit def negValDuality[A]: Dual[Neg[A], Val[A]]
implicit def pComonoidVal[A]: PComonoid[Val[A]]
implicit def signalingNeg[A]: Negative[Neg[A]]
implicit def signalingVal[A]: Positive[Val[A]]
implicit def valNegDuality[A]: Dual[Val[A], Neg[A]]