gleamunison - v3.11.0

gleamunison/ast

Types

AbilityDeclaration

</> 
pub type AbilityDeclaration {
  AbilityDeclaration(
    name: identity.LocalVar,
    operations: List(Operation),
  )
}

Constructors

AbilityRef

</> 
pub type AbilityRef {
  AbilityRef(decl: identity.DefinitionRef)
}

Constructors

BuiltinType

</> 
pub type BuiltinType {
  IntType
  FloatType
  TextType
  BoolType
  ListType
  HandlerType
}

Constructors 

  • IntType
  • FloatType
  • TextType
  • BoolType
  • ListType
  • HandlerType

Case

</> 
pub type Case {
  Case(pattern: Pattern, guard: option.Option(Guard), body: Term)
}

Constructors

Constructor

</> 
pub type Constructor {
  Constructor(name: identity.LocalVar, args: List(TypeRef))
}

Constructors

Definition

</> 
pub type Definition {
  TermDef(term: Term, typ: Type)
  TypeDef(TypeDeclaration)
  AbilityDecl(AbilityDeclaration)
}

Constructors

Guard

</> 
pub type Guard {
  GuardTerm(term: Term)
}

Constructors 

  • GuardTerm(term: Term)

Operation

</> 
pub type Operation {
  Operation(
    name: identity.LocalVar,
    inputs: List(TypeRef),
    output: TypeRef,
  )
}

Constructors

Pattern

</> 
pub type Pattern {
  PatVar(identity.LocalVar)
  PatInt(Int)
  PatText(BitArray)
  PatCons(head: identity.LocalVar, tail: identity.LocalVar)
  PatEmptyList
  PatAs(bound: identity.LocalVar, inner: Pattern)
  PatConstructor(
    ctor_ref: identity.DefinitionRef,
    args: List(Pattern),
  )
}

Constructors

ReqElement

</> 
pub type ReqElement {
  Concrete(AbilityRef)
  ReqVar(index: Int)
}

Constructors

Requirement

</> 
pub type Requirement {
  Required(abilities: List(ReqElement))
}

Constructors

Term

</> 
pub type Term {
  RefTo(identity.DefinitionRef)
  LocalVarRef(identity.LocalVar)
  Int(Int)
  Float(Float)
  Text(BitArray)
  List(List(Term))
  Apply(function: Term, arg: Term)
  Lambda(binder: identity.LocalVar, body: Term)
  Let(binder: identity.LocalVar, value: Term, body: Term)
  Match(scrutinee: Term, cases: List(Case))
  Do(
    ability: identity.DefinitionRef,
    operation: identity.LocalVar,
    args: List(Term),
  )
  Handle(
    computation: Term,
    handler: Term,
    ability: identity.DefinitionRef,
  )
  Construct(ctor_ref: identity.DefinitionRef, args: List(Term))
  Hole
  Use(binder: identity.LocalVar, call: Term, body: Term)
}

Constructors

Type

</> 
pub type Type {
  TypeVar(index: Int)
  AbilityVar(index: Int)
  Fn(params: List(Type), result: Type, requires: Requirement)
  App(name: identity.DefinitionRef, args: List(Type))
  Builtin(BuiltinType)
}

Constructors

TypeDeclaration

</> 
pub type TypeDeclaration {
  Structural(
    name: identity.LocalVar,
    parameters: List(identity.LocalVar),
    constructors: List(Constructor),
  )
  Unique(
    name: identity.LocalVar,
    guid: String,
    parameters: List(identity.LocalVar),
    constructors: List(Constructor),
  )
}

Constructors

TypeRef

</> 
pub type TypeRef {
  TypeRefVar(identity.LocalVar)
  TypeCon(identity.DefinitionRef)
  TypeRefBuiltin(BuiltinType)
}

Constructors

Unit

</> 
pub type Unit {
  Unit(
    root: identity.DefinitionRef,
    defs: List(#(identity.DefinitionRef, Definition)),
  )
}

Constructors

✨ Search Document