libretto-lambda
API
Generated with
libretto-lambda/libretto.lambda/Lambdas

Lambdas

libretto.lambda.Lambdas
See theLambdas companion object
trait Lambdas[-⚬[_, _], |*|[_, _], V]

Attributes

Companion
object
Graph
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class LambdasImpl[-⚬, |*|, V]

Members list

Type members

Classlikes

trait AbstractFuns

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object AbstractFun.type
trait Contexts

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Context.type
trait Exprs

Attributes

Supertypes
class Object
trait Matchable
class Any
Known subtypes
object Expr.type
enum LinCheck[A]

Attributes

Companion
object
Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object LinCheck

Attributes

Companion
enum
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
LinCheck.type
object given_UniqueTypeArg_Expr extends UniqueTypeArg[Expr]

Attributes

Supertypes
class Object
trait Matchable
class Any
Self type

Types

type AbsRes[A, B] = Abstracted[Expr, |*|, -⚬, V, A, B]
type AbstractFun[A, B]
type Abstracted[A, B] = Abstracted[Expr, |*|, AbstractFun, V, A, B]
type Context
type Expr[A]
final type Tupled[F[_], A] = Tupled[|*|, F, A]
type VFun[A, B] = (V, Context ?=> Expr[A] => Expr[B])

Value members

Abstract methods

def switch[<+>[_, _], A, B](cases: Sink[VFun, <+>, A, B], sum: [X, Y] => (x$1: X -⚬ B, x$2: Y -⚬ B) => <+>[X, Y] -⚬ B, distribute: [X, Y, Z] => (x$1: Unit) => X |*| <+>[Y, Z] -⚬ <+>[X |*| Y, X |*| Z])(using Context): AbsRes[A, B]

Concrete methods

def absNested[A, B](varName: V, f: Context ?=> Expr[A] => Expr[B])(using parent: Context): Abstracted[A, B]
def absTopLevel[A, B](varName: V, f: Context ?=> Expr[A] => Expr[B]): Abstracted[A, B]

Abstract fields

val Expr: Exprs

Givens

Givens

Extensions

Extensions

extension [A](a: Expr[A])(a: Expr[A])
def map[B](f: A -⚬ B)(resultVar: V)(using Context): Expr[B]
def resultVar: Var[V, A]
def zip[B](b: Expr[B])(resultVar: V)(using Context): Expr[A |*| B]
extension [A, B](f: AbstractFun[A, B])(f: AbstractFun[A, B])
def fold: A -⚬ B
Generated with