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

Concise view

Type members

Classlikes

trait AbstractFuns

Attributes

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

Attributes

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

Attributes

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

Attributes

Companion:
object
Graph
Supertypes
trait Enum
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
object LinCheck

Attributes

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

Attributes

Graph
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])
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])
def fold: A -⚬ B
Generated with