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

Types

opaque type RefCounted[R]

Value members

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.

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.

def const[A](a: A): One -⚬ Val[A]
def constList[A](as: List[A]): One -⚬ LList[Val[A]]
def constListOf[A](as: A*): One -⚬ LList[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.

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.

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.

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 readLine: Done -⚬ Val[String]
def release0[R, B](release: R => B): Res[R] -⚬ Val[B]

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.

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.

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.

def unliftBoolean: Bool -⚬ Val[Boolean]

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