morphir-ir
API
Generated with
morphir-ir/morphir/morphir.ir/Value

Value

morphir.ir.Value
object Value

Generated based on IR.Value

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Value.type

Members list

Type members

Classlikes

final case class Definition[Ta, Va](inputTypes: List[(Name, Va, Type[Ta])], outputType: Type[Ta], body: Value[Ta, Va])

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Pattern

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
Pattern.type
sealed trait Pattern[A]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class AsPattern[A]
class EmptyListPattern[A]
class HeadTailPattern[A]
class LiteralPattern[A]
class TuplePattern[A]
class UnitPattern[A]
class WildcardPattern[A]
Show all
final case class Specification[Ta](inputs: List[(Name, Type[Ta])], output: Type[Ta])

Attributes

Supertypes
trait Serializable
trait Product
trait Equals
class Object
trait Matchable
class Any
Show all
object Value

Attributes

Companion
trait
Supertypes
trait Sum
trait Mirror
class Object
trait Matchable
class Any
Self type
Value.type
sealed trait Value[Ta, Va]

Attributes

Companion
object
Supertypes
class Object
trait Matchable
class Any
Known subtypes
class Apply[Ta, Va]
class Constructor[Ta, Va]
class Destructure[Ta, Va]
class Field[Ta, Va]
class FieldFunction[Ta, Va]
class IfThenElse[Ta, Va]
class Lambda[Ta, Va]
class LetDefinition[Ta, Va]
class LetRecursion[Ta, Va]
class List[Ta, Va]
class Literal[Ta, Va]
class PatternMatch[Ta, Va]
class Record[Ta, Va]
class Reference[Ta, Va]
class Tuple[Ta, Va]
class Unit[Ta, Va]
class UpdateRecord[Ta, Va]
class Variable[Ta, Va]
Show all

Types

type RawValue = Value[Unit, Unit]
type TypedValue = Value[Unit, Type[Unit]]

Value members

Concrete methods

def _toString[Ta, Va](value: Value[Ta, Va]): String
def apply[Ta, Va](attributes: Va)(function: Value[Ta, Va])(argument: Value[Ta, Va]): Value[Ta, Va]
def asPattern[A](attributes: A)(pattern: Pattern[A])(name: Name): Pattern[A]
def collectDefinitionAttributes[Ta, Va](d: Definition[Ta, Va]): List[Va]
def collectPatternAttributes[A](p: Pattern[A]): List[A]
def collectPatternReferences[Va](pattern: Pattern[Va]): Set[FQName]
def collectPatternVariables[Va](pattern: Pattern[Va]): Set[Name]
def collectReferences[Ta, Va](value: Value[Ta, Va]): Set[FQName]
def collectValueAttributes[Ta, Va](v: Value[Ta, Va]): List[Va]
def collectVariables[Ta, Va](value: Value[Ta, Va]): Set[Name]
def constructor[Ta, Va](attributes: Va)(fullyQualifiedName: FQName): Value[Ta, Va]
def constructorPattern[A](attributes: A)(constructorName: FQName)(argumentPatterns: List[Pattern[A]]): Pattern[A]
def countValueNodes[Ta, Va](value: Value[Ta, Va]): Int
def definitionToSpecification[Ta, Va](_def: Definition[Ta, Va]): Specification[Ta]
def definitionToValue[Ta, Va](_def: Definition[Ta, Va]): Value[Ta, Va]
def emptyListPattern[A](attributes: A): Pattern[A]
def field[Ta, Va](attributes: Va)(subjectValue: Value[Ta, Va])(fieldName: Name): Value[Ta, Va]
def fieldFunction[Ta, Va](attributes: Va)(fieldName: Name): Value[Ta, Va]
def generateUniqueName[Ta, Va](value: Value[Ta, Va]): Name
def headTailPattern[A](attributes: A)(headPattern: Pattern[A])(tailPattern: Pattern[A]): Pattern[A]
def ifThenElse[Ta, Va](attributes: Va)(condition: Value[Ta, Va])(thenBranch: Value[Ta, Va])(elseBranch: Value[Ta, Va]): Value[Ta, Va]
def indexedMapListHelp[A, B](f: Int => A => (B, Int))(baseIndex: Int)(elemList: List[A]): (List[B], Int)
def indexedMapPattern[A, B](f: Int => A => B)(baseIndex: Int)(pattern: Pattern[A]): (Pattern[B], Int)
def indexedMapValue[A, B, Ta](f: Int => A => B)(baseIndex: Int)(value: Value[Ta, A]): (Value[Ta, B], Int)
def isData[Ta, Va](value: Value[Ta, Va]): Bool
def lambda[Ta, Va](attributes: Va)(argumentPattern: Pattern[Va])(body: Value[Ta, Va]): Value[Ta, Va]
def letDef[Ta, Va](attributes: Va)(valueName: Name)(valueDefinition: Definition[Ta, Va])(inValue: Value[Ta, Va]): Value[Ta, Va]
def letDestruct[Ta, Va](attributes: Va)(pattern: Pattern[Va])(valueToDestruct: Value[Ta, Va])(inValue: Value[Ta, Va]): Value[Ta, Va]
def letRec[Ta, Va](attributes: Va)(valueDefinitions: Map[Name, Definition[Ta, Va]])(inValue: Value[Ta, Va]): Value[Ta, Va]
def list[Ta, Va](attributes: Va)(items: List[Value[Ta, Va]]): Value[Ta, Va]
def literal[Ta, Va](attributes: Va)(value: Literal): Value[Ta, Va]
def literalPattern[A](attributes: A)(value: Literal): Pattern[A]
def mapDefinition[E, Ta, Va](mapType: (Type[Ta]) => Result[E, Type[Ta]])(mapValue: (Value[Ta, Va]) => Result[E, Value[Ta, Va]])(_def: Definition[Ta, Va]): Result[List[E], Definition[Ta, Va]]
def mapDefinitionAttributes[Ta, Tb, Va, Vb](f: Ta => Tb)(g: Va => Vb)(d: Definition[Ta, Va]): Definition[Tb, Vb]
def mapPatternAttributes[A, B](f: A => B)(p: Pattern[A]): Pattern[B]
def mapSpecificationAttributes[A, B](f: A => B)(spec: Specification[A]): Specification[B]
def mapValueAttributes[Ta, Tb, Va, Vb](f: Ta => Tb)(g: Va => Vb)(v: Value[Ta, Va]): Value[Tb, Vb]
def patternAttribute[A](p: Pattern[A]): A
def patternMatch[Ta, Va](attributes: Va)(branchOutOn: Value[Ta, Va])(cases: List[(Pattern[Va], Value[Ta, Va])]): Value[Ta, Va]
def record[Ta, Va](attributes: Va)(fields: Map[Name, Value[Ta, Va]]): Value[Ta, Va]
def reduceValueBottomUp[Accumulator, TypeAttribute, ValueAttribute](mapNode: (Value[TypeAttribute, ValueAttribute]) => (List[Accumulator]) => Accumulator)(currentValue: Value[TypeAttribute, ValueAttribute]): Accumulator
def reference[Ta, Va](attributes: Va)(fullyQualifiedName: FQName): Value[Ta, Va]
def replaceVariables[Ta, Va](value: Value[Ta, Va])(mapping: Map[Name, Value[Ta, Va]]): Value[Ta, Va]
def rewriteMaybeToPatternMatch[Ta, Va](value: Value[Ta, Va]): Value[Ta, Va]
def rewriteValue[Ta, Va](f: (Value[Ta, Va]) => Maybe[Value[Ta, Va]])(value: Value[Ta, Va]): Value[Ta, Va]
def toRawValue[Ta, Va](value: Value[Ta, Va]): RawValue
def tuple[Ta, Va](attributes: Va)(elements: List[Value[Ta, Va]]): Value[Ta, Va]
def tuplePattern[A](attributes: A)(elementPatterns: List[Pattern[A]]): Pattern[A]
def typeAndValueToDefinition[Ta, Va](valueType: Type[Ta])(value: Value[Ta, Va]): Definition[Ta, Va]
def uncurryApply[Ta, Va](fun: Value[Ta, Va])(lastArg: Value[Ta, Va]): (Value[Ta, Va], List[Value[Ta, Va]])
def unit[Ta, Va](attributes: Va): Value[Ta, Va]
def update[Ta, Va](attributes: Va)(valueToUpdate: Value[Ta, Va])(fieldsToUpdate: Map[Name, Value[Ta, Va]]): Value[Ta, Va]
def valueAttribute[Ta, Va](v: Value[Ta, Va]): Va
def variable[Ta, Va](attributes: Va)(name: Name): Value[Ta, Va]
def wildcardPattern[A](attributes: A): Pattern[A]

Concrete fields

val Apply: Apply.type
val AsPattern: AsPattern.type
val Constructor: Constructor.type
val ConstructorPattern: ConstructorPattern.type
val Destructure: Destructure.type
val EmptyListPattern: EmptyListPattern.type
val Field: Field.type
val FieldFunction: FieldFunction.type
val HeadTailPattern: HeadTailPattern.type
val IfThenElse: IfThenElse.type
val Lambda: Lambda.type
val LetDefinition: LetDefinition.type
val LetRecursion: LetRecursion.type
val List: List.type
val Literal: Literal.type
val LiteralPattern: LiteralPattern.type
val PatternMatch: PatternMatch.type
val Record: Record.type
val Reference: Reference.type
val Tuple: Tuple.type
val TuplePattern: TuplePattern.type
val Unit: Unit.type
val UnitPattern: UnitPattern.type
val UpdateRecord: UpdateRecord.type
val Variable: Variable.type
val WildcardPattern: WildcardPattern.type

Implicits

Implicits

implicit val nameOrdering: Ordering[Name]
Generated with