#core

Core runtime data types and Unicode utilities used across the interpreter.

#Highlights

Datum, Value, and Primitive definitions
Runtime type records and continuations
Unicode category and normalization helpers

#Examples

///|
let folded = UnicodeString::new("StraSSE").foldcase().into_string()

///|
let nfc = UnicodeString::new("e\u{301}").normalize_nfc().into_string()

///|
test "unicode helpers" {
  inspect(UnicodeChar::new('A').general_category(), content="Lu")
  inspect(UnicodeChar::new('A').is_uppercase(), content="true")
  inspect(UnicodeString::new("ABC").foldcase().into_string(), content="abc")
  inspect(UnicodeString::new("AbC").downcase().into_string(), content="abc")
  inspect(UnicodeString::new("abc").upcase().into_string(), content="ABC")
  inspect(
    UnicodeString::new("e\u{301}").normalize_nfc().into_string(),
    content="\u{00e9}",
  )
  inspect(
    UnicodeString::new("\u{00e9}").normalize_nfd().into_string(),
    content="e\u{301}",
  )
  inspect(
    UnicodeString::new("e\u{301}").normalize_nfc().foldcase().into_string(),
    content="\u{00e9}",
  )
  inspect(
    UnicodeString::new("e\u{301}").normalize_nfkd().into_string(),
    content="e\u{301}",
  )
  inspect(
    UnicodeString::new("\u{212b}").normalize_nfkc().into_string(),
    content="\u{00c5}",
  )
  inspect(UnicodeString::new("Hi").into_string(), content="Hi")
}

///|
test "unicode empty normalization" {
  inspect(UnicodeString::new("").normalize_nfkc().into_string(), content="")
}

///|
test "unicode char case" {
  inspect(UnicodeChar::new('a').is_lowercase(), content="true")
  inspect(UnicodeChar::new('0').is_alphabetic(), content="false")
  match UnicodeChar::new('a').upcase() {
    'A' => ()
    _ => fail("expected A")
  }
  match UnicodeChar::new('A').downcase() {
    'a' => ()
    _ => fail("expected a")
  }
}

///|
test "unicode titlecase" {
  match UnicodeChar::new('\u{01C5}').general_category() {
    "Lt" => ()
    _ => fail("expected titlecase category")
  }
  match UnicodeChar::new('\u{01C5}').upcase() {
    '\u{01C4}' | '\u{01C5}' => ()
    _ => fail("expected titlecase upcase")
  }
  match UnicodeChar::new('\u{01C5}').downcase() {
    '\u{01C6}' | '\u{01C5}' => ()
    _ => fail("expected titlecase downcase")
  }
  match UnicodeChar::new('1').downcase() {
    '1' => ()
    _ => fail("expected unchanged")
  }
}

///|
test "unicode hangul normalization" {
  inspect(
    UnicodeString::new("\u{AC01}").normalize_nfd().into_string(),
    content="\u{1100}\u{1161}\u{11A8}",
  )
  inspect(
    UnicodeString::new("\u{1100}\u{1161}\u{11A8}").normalize_nfc().into_string(),
    content="\u{AC01}",
  )
  inspect(
    UnicodeString::new("\u{0301}A").normalize_nfd().into_string(),
    content="\u{0301}A",
  )
  inspect(
    UnicodeString::new("B\u{0301}").normalize_nfc().into_string(),
    content="B\u{0301}",
  )
  inspect(
    UnicodeString::new("\u{212B}").normalize_nfkd().into_string(),
    content="A\u{030A}",
  )
  inspect(
    UnicodeString::new("\u{2460}").normalize_nfkd().into_string(),
    content="1",
  )
}

///|
test "binding helpers" {
  let binding = Binding::new(1, Void)
  inspect(binding.id(), content="1")
  match binding.value() {
    Void => ()
    _ => fail("expected void")
  }
}

///|
test "record field binding helpers" {
  let binding = RecordFieldBinding::new("get", 0, None)
  inspect(binding.accessor(), content="get")
  inspect(binding.index(), content="0")
  debug_inspect(binding.mutator(), content="None")
}

///|
test "datum constructors" {
  match Datum::Int(42) {
    Int(42) => ()
    _ => fail("expected int datum")
  }
  let pair = Datum::Pair(Ref(Symbol("a")), Ref(Nil))
  match pair {
    Pair(car, cdr) =>
      match (car.val, cdr.val) {
        (Symbol("a"), Nil) => ()
        _ => fail("expected (a)")
      }
    _ => fail("expected pair")
  }
}

Env

source

type Env = Array[Map[String, Binding]]

An Array is a collection of values that supports random access and can grow in size.

EvalError

source

pub(all) suberror EvalError {
  EvalError(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for EvalError

EvalError::equal

source

fn EvalError::equal(EvalError, EvalError) -> Bool

EvalError::not_equal

source

fn EvalError::not_equal(x : EvalError, y : EvalError) -> Bool

EvalError::output

source

fn EvalError::output(self : EvalError, logger : &Logger) -> Unit

EvalError::to_repr

source

fn EvalError::to_repr(EvalError) -> @moonbitlang/core/debug.Repr
Repr

EvalError::to_string

source

fn EvalError::to_string(self : EvalError) -> String

ParseError

source

pub(all) suberror ParseError {
  ParseError(String)
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

impl Show for ParseError

ParseError::equal

source

fn ParseError::equal(ParseError, ParseError) -> Bool

ParseError::not_equal

source

fn ParseError::not_equal(x : ParseError, y : ParseError) -> Bool

ParseError::output

source

fn ParseError::output(self : ParseError, logger : &Logger) -> Unit

ParseError::to_repr

source

fn ParseError::to_repr(ParseError) -> @moonbitlang/core/debug.Repr
Repr

ParseError::to_string

source

fn ParseError::to_string(self : ParseError) -> String

Binding

source

pub struct Binding {
  id : Int
  value : Value
}

Binding::id

source

fn Binding::id(self : Binding) -> Int

Read the binding id.

Example

test "Binding::id" {
  let binding = Binding::new(7, Void)
  inspect(binding.id(), content="7")
}

Binding::new

source

fn Binding::new(id : Int, value : Value) -> Binding

Create a binding value with an id and value.

Example

test "Binding::new" {
  let binding = Binding::new(1, Void)
  inspect(binding.id(), content="1")
}

Binding::value

source

fn Binding::value(self : Binding) -> Value

Read the binding value.

Example

test "Binding::value" {
  let binding = Binding::new(1, Void)
  match binding.value() {
    Void => ()
    _ => fail("expected void")
  }
}

CaseClause

source

pub struct CaseClause {
  params : Array[String]
  rest : String?
  body : Array[Datum]
}

CaseClause::new

source

fn CaseClause::new(params : Array[String], rest : String?, body : Array[Datum]) -> CaseClause

CaseClosure

source

pub struct CaseClosure {
  id : Int
  clauses : Array[CaseClause]
  env : Array[Map[String, Binding]]
}

CaseClosure::new

source

fn CaseClosure::new(id : Int, clauses : Array[CaseClause], env : Array[Map[String, Binding]]) -> CaseClosure

Closure

source

pub struct Closure {
  id : Int
  params : Array[String]
  rest : String?
  body : Array[Datum]
  env : Array[Map[String, Binding]]
}

Closure::new

source

fn Closure::new(id : Int, params : Array[String], rest : String?, body : Array[Datum], env : Array[Map[String, Binding]]) -> Closure

Condition

source

pub struct Condition {
  id : Int
  components : Array[Record]
}

Condition value containing record components.

Condition::new

source

fn Condition::new(id : Int, components : Array[Record]) -> Condition

ConditionProc

source

pub struct ConditionProc {
  id : Int
  kind : ConditionProcKind
}

Condition-related procedure wrapper.

ConditionProc::new

source

fn ConditionProc::new(id : Int, kind : ConditionProcKind) -> ConditionProc

ConditionProcKind

source

pub(all) enum ConditionProcKind {
  Predicate(RecordType)
  Accessor(RecordType, Int)
}

Continuation

source

pub struct Continuation {
  id : Int
  kont : Kont
  handlers : Array[Value]
  winds : Array[Winder]
}

First-class continuation value.

Continuation::new

source

fn Continuation::new(id : Int, kont : Kont, handlers : Array[Value], winds : Array[Winder]) -> Continuation

Datum

source

pub(all) enum Datum {
  Nil
  Bool(Bool)
  Int(Int)
  BigInt(@moonbitlang/core/bigint.BigInt
BigInt)
  Rat(Int, Int)
  BigRat(@moonbitlang/core/bigint.BigInt
BigInt, @moonbitlang/core/bigint.BigInt
BigInt)
  Float(Float)
  Complex(@moonbitlang/core/ref.Ref
Ref[Datum], @moonbitlang/core/ref.Ref
Ref[Datum])
  Label(Int, @moonbitlang/core/ref.Ref
Ref[Datum])
  Char(Char)
  String(@moonbitlang/core/ref.Ref
Ref[String])
  Symbol(String)
  Pair(@moonbitlang/core/ref.Ref
Ref[Datum], @moonbitlang/core/ref.Ref
Ref[Datum])
  Vector(Array[Datum])
  ByteVector(Array[Int])
  Record(Record)
  Condition(Condition)
  Value(Value)
}

Datum is the reader-level data representation used by quote. It is also used to store list/vector elements, so it includes runtime-only variants for records/conditions even though the reader never produces them.

EnumSet

source

pub struct EnumSet {
  id : Int
  universe : Array[String]
  members : Array[Bool]
}

Enum set value with a fixed universe ordering.

EnumSet::new

source

fn EnumSet::new(id : Int, universe : Array[String], members : Array[Bool]) -> EnumSet

EnumSetProc

source

pub struct EnumSetProc {
  id : Int
  kind : EnumSetProcKind
}

EnumSetProc::new

source

fn EnumSetProc::new(id : Int, kind : EnumSetProcKind) -> EnumSetProc

EnumSetProcKind

source

pub(all) enum EnumSetProcKind {
  Constructor(EnumSet)
  Indexer(EnumSet)
}

EvalEnv

source

pub struct EvalEnv {
  id : Int
  env : Array[Map[String, Binding]]
}

EvalEnv::new

source

fn EvalEnv::new(id : Int, env : Array[Map[String, Binding]]) -> EvalEnv

Formals

source

pub struct Formals {
  params : Array[String]
  rest : String?
}

Formals::new

source

fn Formals::new(params : Array[String], rest : String?) -> Formals

GuardHandler

source

pub struct GuardHandler {
  id : Int
  name : String
  clauses : Array[Datum]
  env : Array[Map[String, Binding]]
  resume_value : Value
  handlers : Array[Value]
}

GuardHandler::new

source

fn GuardHandler::new(id : Int, name : String, clauses : Array[Datum], env : Array[Map[String, Binding]], resume_value : Value, handlers : Array[Value]) -> GuardHandler

GuardInfo

source

pub struct GuardInfo {
  condition : Value
  resume_value : Value
  handlers : Array[Value]
  raise_kont : Kont
  continuable : Bool
}

GuardInfo::new

source

fn GuardInfo::new(condition : Value, resume_value : Value, handlers : Array[Value], raise_kont : Kont, continuable : Bool) -> GuardInfo

Hashtable

source

pub struct Hashtable {
  id : Int
  mutable : Bool
  equiv : HashtableEquiv
  hash : Value?
  entries : @moonbitlang/core/ref.Ref
Ref[Array[HashtableEntry]]
}

Hashtable with configured equivalence and hash function.

Hashtable::new

source

fn Hashtable::new(id : Int, mutable : Bool, equiv : HashtableEquiv, hash : Value?, entries : Array[HashtableEntry]) -> Hashtable

HashtableEntry

source

pub struct HashtableEntry {
  key : Value
  value : @moonbitlang/core/ref.Ref
Ref[Value]
}

HashtableEntry::new

source

fn HashtableEntry::new(key : Value, value : Value) -> HashtableEntry

HashtableEquiv

source

pub(all) enum HashtableEquiv {
  Eq
  Eqv
  Equal
  Proc(Value)
}

HashtableOp

source

pub(all) enum HashtableOp {
  Ref(Value)
  Contains
  Set(Value)
  Delete
  Update(Value, Value)
}

Kont

source

pub(all) enum Kont {
  Halt
  If(Datum, Datum, Array[Map[String, Binding]], Kont)
  Begin(Array[Datum], Array[Map[String, Binding]], Kont)
  Set(String, Array[Map[String, Binding]], Kont)
  Define(String, Array[Map[String, Binding]], Kont)
  AppFun(Array[Datum], Array[Map[String, Binding]], Kont)
  AppArgs(Value, Array[Value], Array[Datum], Array[Map[String, Binding]], Kont)
  And(Array[Datum], Array[Map[String, Binding]], Kont)
  Or(Array[Datum], Array[Map[String, Binding]], Kont)
  Cond(Array[Datum], Array[Datum], Array[Map[String, Binding]], Kont)
  CondArrow(Value, Kont)
  Let(Array[(String, Datum)], Int, Array[Value], Array[Map[String, Binding]], Array[Datum], Kont)
  LetStar(Array[(String, Datum)], Int, Array[Map[String, Binding]], Array[Datum], Kont)
  LetRec(Array[(String, Datum)], Int, Array[Map[String, Binding]], Array[Datum], Kont)
  LetRecInit(Array[(String, Datum)], Int, Array[Value], Array[Map[String, Binding]], Array[Datum], Kont)
  LetValues(Array[(Formals, Datum)], Int, Array[Array[(String, Value)]], Array[Map[String, Binding]], Array[Datum], Kont)
  LetStarValues(Array[(Formals, Datum)], Int, Array[Map[String, Binding]], Array[Datum], Kont)
  DefineValues(Formals, Array[Map[String, Binding]], Kont)
  SyntaxCase(Array[Datum], Array[Map[String, Binding]], Kont)
  ParameterizeParam(Array[(Datum, Datum)], Int, Array[Parameter], Array[Value], Array[Map[String, Binding]], Array[Datum], Kont)
  ParameterizeValue(Array[(Datum, Datum)], Int, Array[Parameter], Array[Value], Array[Map[String, Binding]], Array[Datum], Kont)
  ParameterizeConvert(Array[(Datum, Datum)], Int, Array[Parameter], Array[Value], Array[Map[String, Binding]], Array[Datum], Kont)
  MakeParameter(Value, Kont)
  SetParameter(Parameter, Kont)
  GuardResult(GuardInfo)
  GuardCond(Array[Datum], Array[Datum], Array[Map[String, Binding]], GuardInfo)
  GuardCondArrow(Value, GuardInfo)
  Case(Array[Datum], Array[Map[String, Binding]], Kont)
  CaseArrow(Value, Kont)
  CallWithValues(Value, Kont)
  RecordConstructorDone(Kont)
  RecordProtocolNApply(RecordType, Array[Value], Kont)
  RecordProtocolNResult(RecordType, Kont)
  DefineRecordType(String, String, RecordType, Array[RecordFieldBinding], Array[Map[String, Binding]], Kont)
  DefineConditionType(String, String, RecordType, Array[RecordFieldBinding], Array[Map[String, Binding]], Kont)
  HashtableFindResult(Hashtable, Value, Int, HashtableOp, Kont)
  HashtableUpdateApply(Hashtable, Value, Int, Bool, Kont)
  MapStep(Value, Array[Datum], Array[Datum], Bool, Kont)
  VectorMapFinalize(Kont)
  StringMapFinalize(Kont)
  WindEnter(Value, Winder, Kont)
  WindExit(Winder, Kont)
  WindActions(Array[WindAction], Value, Kont, Array[Value])
  WindPush(Winder, Array[WindAction], Value, Kont, Array[Value])
  ForcePromise(Promise, Kont)
  RaiseNonCont
  RaiseCont(Kont)
  RestoreHandlers(Array[Value], Kont)
}

Continuation frames for the evaluator.

MacroTransformer

source

pub(all) enum MacroTransformer {
  Rules(SyntaxRules)
  Procedure(Value, Array[Map[String, Binding]])
}

ParamBinding

source

pub struct ParamBinding {
  param : Parameter
  old_value : Value
  new_value : Value
}

ParamBinding::new

source

fn ParamBinding::new(param : Parameter, old_value : Value, new_value : Value) -> ParamBinding

Parameter

source

pub struct Parameter {
  id : Int
  value : @moonbitlang/core/ref.Ref
Ref[Value]
  converter : Value?
}

Parameter::new

source

fn Parameter::new(id : Int, value : Value, converter : Value?) -> Parameter

Port

source

pub struct Port {
  id : Int
  kind : PortKind
}

Runtime port descriptor.

Port::new_output_string

source

fn Port::new_output_string(id : Int, initial : String) -> Port

PortKind

source

pub enum PortKind {
  OutputString(@moonbitlang/core/ref.Ref
Ref[String])
}

Kinds of runtime ports.

Primitive

source

pub(all) enum Primitive {
  Add
  Sub
  Mul
  Div
  NumEq
  Less
  Greater
  LessEq
  GreaterEq
  Eq
  Eqv
  Equal
  Cons
  Car
  Cdr
  List
  NullP
  PairP
  SymbolP
  SymbolEq
  IdentifierP
  SyntaxP
  FreeIdentifierEq
  BoundIdentifierEq
  SymbolToString
  StringToSymbol
  StringHash
  StringCiHash
  SymbolHash
  EqualHash
  SyntaxToDatum
  DatumToSyntax
  BooleanP
  BooleanEq
  NumberP
  IntegerP
  ExactIntegerP
  RationalP
  RealP
  ComplexP
  ExactP
  InexactP
  ZeroP
  PositiveP
  NegativeP
  OddP
  EvenP
  FiniteP
  InfiniteP
  NanP
  ProcedureP
  RecordP
  RecordRtd
  RecordTypeDescriptorP
  RecordConstructorDescriptorP
  RecordTypeName
  RecordTypeParent
  RecordTypeUid
  RecordTypeGenerativeP
  RecordTypeSealedP
  RecordTypeOpaqueP
  RecordTypeFieldNames
  RecordTypeFieldMutableP
  RecordConstructorDescriptor
  RecordConstructor
  RecordPredicate
  RecordAccessor
  RecordMutator
  MakeRecordTypeDescriptor
  MakeRecordConstructorDescriptor
  Condition
  ConditionP
  SimpleConditions
  ConditionPredicate
  ConditionAccessor
  MakeEqHashtable
  MakeEqvHashtable
  MakeHashtable
  HashtableP
  HashtableSize
  HashtableRef
  HashtableSet
  HashtableDelete
  HashtableContainsP
  HashtableUpdate
  HashtableCopy
  HashtableClear
  HashtableKeys
  HashtableEntries
  HashtableEquivalenceFunction
  HashtableHashFunction
  HashtableMutableP
  MakeEnumeration
  EnumSetUniverse
  EnumSetIndexer
  EnumSetConstructor
  EnumSetP
  EnumSetMemberP
  EnumSetSubsetP
  EnumSetEq
  EnumSetUnion
  EnumSetIntersection
  EnumSetDifference
  EnumSetComplement
  EnumSetProjection
  EnumSetToList
  Not
  Apply
  CallCC
  Values
  CallWithValues
  MakeParameter
  DynamicWind
  Eval
  Environment
  PromiseP
  MakePromise
  Force
  ExactToInexact
  InexactToExact
  ExactIntegerSqrt
  Rationalize
  NumberToString
  StringToNumber
  MakeRectangular
  MakePolar
  RealPart
  ImagPart
  Magnitude
  Angle
  Sqrt
  Exp
  Log
  Expt
  Sin
  Cos
  Tan
  Asin
  Acos
  Atan
  Numerator
  Denominator
  Abs
  Quotient
  Remainder
  Modulo
  Gcd
  Lcm
  Max
  Min
  Floor
  Ceiling
  Truncate
  Round
  BitwiseAnd
  BitwiseIor
  BitwiseXor
  BitwiseNot
  BitwiseIf
  ArithmeticShift
  BitwiseBitCount
  BitwiseLength
  BitwiseFirstBitSet
  BitwiseBitSetP
  BitwiseCopyBit
  BitwiseBitField
  BitwiseCopyBitField
  BitwiseRotateBitField
  BitwiseReverseBitField
  FixnumP
  FixnumWidth
  LeastFixnum
  GreatestFixnum
  FxEq
  FxLess
  FxGreater
  FxLessEq
  FxGreaterEq
  FxZeroP
  FxPositiveP
  FxNegativeP
  FxOddP
  FxEvenP
  FxMin
  FxMax
  FxAdd
  FxSub
  FxMul
  FxDiv
  FxMod
  FxDiv0
  FxMod0
  FxAddCarry
  FxSubCarry
  FxMulCarry
  FxNot
  FxAnd
  FxIor
  FxXor
  FxIf
  FxBitCount
  FxLength
  FxFirstBitSet
  FxBitSetP
  FxCopyBit
  FxBitField
  FxCopyBitField
  FxRotateBitField
  FxReverseBitField
  FxArithmeticShift
  FxArithmeticShiftLeft
  FxArithmeticShiftRight
  FlonumP
  RealToFlonum
  FixnumToFlonum
  FlEq
  FlLess
  FlGreater
  FlLessEq
  FlGreaterEq
  FlIntegerP
  FlZeroP
  FlPositiveP
  FlNegativeP
  FlOddP
  FlEvenP
  FlFiniteP
  FlInfiniteP
  FlNanP
  FlMax
  FlMin
  FlAdd
  FlMul
  FlSub
  FlDiv
  FlAbs
  FlDivAndMod
  FlDivInt
  FlMod
  FlDiv0AndMod0
  FlDiv0
  FlMod0
  FlNumerator
  FlDenominator
  FlFloor
  FlCeiling
  FlTruncate
  FlRound
  FlExp
  FlLog
  FlSin
  FlCos
  FlTan
  FlAsin
  FlAcos
  FlAtan
  FlSqrt
  FlExpt
  MakeVariableTransformer
  GenerateTemporaries
  ListP
  MakeList
  Length
  Append
  Reverse
  ListRef
  ListTail
  Cxr(String)
  Member
  Memq
  Memv
  Assoc
  Assq
  Assv
  Map
  ForEach
  SetCar
  SetCdr
  ListCopy
  CharEq
  CharLess
  CharGreater
  CharLessEq
  CharGreaterEq
  CharCiEq
  CharCiLess
  CharCiGreater
  CharCiLessEq
  CharCiGreaterEq
  CharP
  CharToInteger
  IntegerToChar
  CharAlphabeticP
  CharNumericP
  CharWhitespaceP
  CharUpperCaseP
  CharLowerCaseP
  CharUpcase
  CharDowncase
  CharFoldcase
  CharGeneralCategory
  StringEq
  StringLess
  StringGreater
  StringLessEq
  StringGreaterEq
  StringCiEq
  StringCiLess
  StringCiGreater
  StringCiLessEq
  StringCiGreaterEq
  String
  MakeString
  StringP
  StringLength
  StringAppend
  StringRef
  StringSet
  StringCopy
  Substring
  StringCopyBang
  StringFill
  StringToList
  ListToString
  StringMap
  StringForEach
  StringUpcase
  StringDowncase
  StringFoldcase
  StringNormalizeNfc
  StringNormalizeNfd
  StringNormalizeNfkc
  StringNormalizeNfkd
  Vector
  MakeVector
  VectorP
  VectorLength
  VectorRef
  VectorSet
  VectorFill
  VectorToList
  ListToVector
  VectorCopy
  VectorCopyBang
  VectorAppend
  VectorMap
  VectorForEach
  ByteVector
  MakeByteVector
  ByteVectorP
  ByteVectorLength
  ByteVectorEq
  ByteVectorU8Ref
  ByteVectorU8Set
  ByteVectorCopy
  ByteVectorCopyBang
  ByteVectorAppend
  ByteVectorFill
  ByteVectorToU8List
  U8ListToByteVector
  StringToUtf8
  Utf8ToString
  NativeEndianness
  ByteVectorUintRef
  ByteVectorSintRef
  ByteVectorUintSet
  ByteVectorSintSet
  Display
  Write
  Newline
  OpenOutputString
  GetOutputString
  CurrentOutputPort
  WithExceptionHandler
  Raise
  RaiseContinuable
  Error
  AssertionViolation
  ImplementationRestrictionViolation
  UndefinedViolation
  SyntaxViolation
} derive(Eq)

Primitive::equal

source

fn Primitive::equal(Primitive, Primitive) -> Bool

Primitive::not_equal

source

fn Primitive::not_equal(x : Primitive, y : Primitive) -> Bool

Promise

source

pub struct Promise {
  id : Int
  state : @moonbitlang/core/ref.Ref
Ref[PromiseState]
}

Promise::new

source

fn Promise::new(id : Int, state : PromiseState) -> Promise

PromiseState

source

pub(all) enum PromiseState {
  Thunk(Value)
  Value(Value)
}

Record

source

pub struct Record {
  id : Int
  record_type : RecordType
  fields : Array[@moonbitlang/core/ref.Ref
Ref[Value]]
}

Record instance with boxed fields.

Record::new

source

fn Record::new(id : Int, record_type : RecordType, values : Array[Value]) -> Record

RecordConstructorDescriptor

source

pub struct RecordConstructorDescriptor {
  id : Int
  record_type : RecordType
  parent_desc : RecordConstructorDescriptor?
  protocol : Value?
}

RecordConstructorDescriptor::new

source

fn RecordConstructorDescriptor::new(id : Int, record_type : RecordType, parent_desc : RecordConstructorDescriptor?, protocol : Value?) -> RecordConstructorDescriptor

RecordField

source

pub struct RecordField {
  name : String
  mutable : Bool
}

RecordField::new

source

fn RecordField::new(name : String, mutable : Bool) -> RecordField

RecordFieldBinding

source

pub struct RecordFieldBinding {
  accessor : String
  index : Int
  mutator : String?
}

Record field binding details for generated accessors.

RecordFieldBinding::accessor

source

fn RecordFieldBinding::accessor(self : RecordFieldBinding) -> String

Return the accessor name.

RecordFieldBinding::index

source

fn RecordFieldBinding::index(self : RecordFieldBinding) -> Int

Return the field index.

RecordFieldBinding::mutator

source

fn RecordFieldBinding::mutator(self : RecordFieldBinding) -> String?

Return the mutator name, if any.

RecordFieldBinding::new

source

fn RecordFieldBinding::new(accessor : String, index : Int, mutator : String?) -> RecordFieldBinding

Create a record field binding.

Example

test "record field binding" {
  let binding = RecordFieldBinding::new("get", 0, None)
  inspect(binding.accessor(), content="get")
  inspect(binding.index(), content="0")
  debug_inspect(binding.mutator(), content="None")
}

RecordProc

source

pub struct RecordProc {
  id : Int
  kind : RecordProcKind
}

Record-related procedure wrapper.

RecordProc::new

source

fn RecordProc::new(id : Int, kind : RecordProcKind) -> RecordProc

RecordProcKind

source

pub(all) enum RecordProcKind {
  Constructor(RecordType)
  Predicate(RecordType)
  Accessor(RecordType, Int)
  Mutator(RecordType, Int)
  ProtocolN(RecordType, RecordConstructorDescriptor)
  ProtocolP(RecordType, Array[Value])
}

RecordType

source

pub struct RecordType {
  id : Int
  name : String
  parent : RecordType?
  is_sealed : Bool
  is_opaque : Bool
  uid : String?
  fields : Array[RecordField]
}

Record type metadata used by the runtime.

RecordType::new

source

fn RecordType::new(id : Int, name : String, parent : RecordType?, is_sealed : Bool, is_opaque : Bool, uid : String?, fields : Array[RecordField]) -> RecordType

RecordTypeDescriptor

source

pub struct RecordTypeDescriptor {
  id : Int
  record_type : RecordType
  constructor_desc : RecordConstructorDescriptor
}

RecordTypeDescriptor::new

source

fn RecordTypeDescriptor::new(id : Int, record_type : RecordType, constructor_desc : RecordConstructorDescriptor) -> RecordTypeDescriptor

SyntaxObject

source

pub struct SyntaxObject {
  datum : Datum
  scopes : Array[Int]
  binding_id : Int?
}

SyntaxObject::new

source

fn SyntaxObject::new(datum : Datum, scopes : Array[Int], binding_id : Int?) -> SyntaxObject

SyntaxRule

source

pub struct SyntaxRule {
  pattern : Datum
  template : Datum
  fender : Datum?
}

SyntaxRule::new

source

fn SyntaxRule::new(pattern : Datum, template : Datum, fender : Datum?) -> SyntaxRule

SyntaxRules

source

pub struct SyntaxRules {
  literals : Array[String]
  rules : Array[SyntaxRule]
  ellipsis : String
  kind : SyntaxRulesKind
  def_env : Array[Map[String, Binding]]
}

SyntaxRules::new

source

fn SyntaxRules::new(literals : Array[String], rules : Array[SyntaxRule], ellipsis : String, kind : SyntaxRulesKind, def_env : Array[Map[String, Binding]]) -> SyntaxRules

SyntaxRulesKind

source

pub(all) enum SyntaxRulesKind {
  SyntaxRules
  SyntaxCase
}

UnicodeChar

source

pub struct UnicodeChar {
  value : Char
}

UnicodeChar::downcase

source

fn UnicodeChar::downcase(self : UnicodeChar) -> Char

Lowercase a character using Unicode case mapping.

Example

test "char downcase" {
  inspect(UnicodeChar::new('A').downcase(), content="a")
}

UnicodeChar::foldcase

source

fn UnicodeChar::foldcase(self : UnicodeChar) -> Char

Case-fold a character for case-insensitive comparison.

Example

test "char foldcase" {
  inspect(UnicodeChar::new('A').foldcase(), content="a")
}

UnicodeChar::general_category

source

fn UnicodeChar::general_category(self : UnicodeChar) -> String

Return the general category tag for the character.

Example

test "general category" {
  inspect(UnicodeChar::new('A').general_category(), content="Lu")
}

UnicodeChar::is_alphabetic

source

fn UnicodeChar::is_alphabetic(self : UnicodeChar) -> Bool

Return true if the character is alphabetic.

Example

test "alphabetic predicate" {
  inspect(UnicodeChar::new('A').is_alphabetic(), content="true")
  inspect(UnicodeChar::new('1').is_alphabetic(), content="false")
}

UnicodeChar::is_lowercase

source

fn UnicodeChar::is_lowercase(self : UnicodeChar) -> Bool

Return true if the character is lowercase.

Example

test "lowercase predicate" {
  inspect(UnicodeChar::new('a').is_lowercase(), content="true")
  inspect(UnicodeChar::new('A').is_lowercase(), content="false")
}

UnicodeChar::is_uppercase

source

fn UnicodeChar::is_uppercase(self : UnicodeChar) -> Bool

Return true if the character is uppercase.

Example

test "uppercase predicate" {
  inspect(UnicodeChar::new('A').is_uppercase(), content="true")
  inspect(UnicodeChar::new('a').is_uppercase(), content="false")
}

UnicodeChar::new

source

fn UnicodeChar::new(ch : Char) -> UnicodeChar

Wrap a Char to access Unicode helpers with chaining.

Example

test "unicode char wrapper" {
  inspect(UnicodeChar::new('A').is_uppercase(), content="true")
}

UnicodeChar::upcase

source

fn UnicodeChar::upcase(self : UnicodeChar) -> Char

Uppercase a character using Unicode case mapping.

Example

test "char upcase" {
  inspect(UnicodeChar::new('a').upcase(), content="A")
}

UnicodeString

source

pub struct UnicodeString {
  value : String
}

UnicodeString::downcase

source

fn UnicodeString::downcase(self : UnicodeString) -> UnicodeString

Lowercase a string using Unicode case mapping.

Example

test "string downcase" {
  inspect(UnicodeString::new("ABC").downcase().into_string(), content="abc")
}

UnicodeString::foldcase

source

fn UnicodeString::foldcase(self : UnicodeString) -> UnicodeString

Case-fold a string for case-insensitive comparison.

Example

test "string foldcase" {
  inspect(UnicodeString::new("ABC").foldcase().into_string(), content="abc")
}

UnicodeString::into_string

source

fn UnicodeString::into_string(self : UnicodeString) -> String

Unwrap a Unicode string wrapper back into a String.

Example

test "unicode string into_string" {
  let wrapped = UnicodeString::new("Hi")
  inspect(wrapped.into_string(), content="Hi")
}

UnicodeString::new

source

fn UnicodeString::new(s : String) -> UnicodeString

Wrap a String to access Unicode helpers with chaining.

Example

test "unicode string wrapper" {
  inspect(
    UnicodeString::new("e\u{301}").normalize_nfc().foldcase().into_string(),
    content="\u{00e9}",
  )
}

UnicodeString::normalize_nfc

source

fn UnicodeString::normalize_nfc(self : UnicodeString) -> UnicodeString

Normalize a string to Unicode NFC.

Example

test "normalize nfc" {
  inspect(
    UnicodeString::new("e\u{301}").normalize_nfc().into_string(),
    content="\u{00e9}",
  )
}

UnicodeString::normalize_nfd

source

fn UnicodeString::normalize_nfd(self : UnicodeString) -> UnicodeString

Normalize a string to Unicode NFD.

Example

test "normalize nfd" {
  inspect(
    UnicodeString::new("\u{00e9}").normalize_nfd().into_string(),
    content="e\u{301}",
  )
}

UnicodeString::normalize_nfkc

source

fn UnicodeString::normalize_nfkc(self : UnicodeString) -> UnicodeString

Normalize a string to Unicode NFKC.

Example

test "normalize nfkc" {
  inspect(
    UnicodeString::new("\u{212b}").normalize_nfkc().into_string(),
    content="\u{00c5}",
  )
}

UnicodeString::normalize_nfkd

source

fn UnicodeString::normalize_nfkd(self : UnicodeString) -> UnicodeString

Normalize a string to Unicode NFKD.

Example

test "normalize nfkd" {
  inspect(
    UnicodeString::new("\u{212b}").normalize_nfkd().into_string(),
    content="A\u{30a}",
  )
}

UnicodeString::upcase

source

fn UnicodeString::upcase(self : UnicodeString) -> UnicodeString

Uppercase a string using Unicode case mapping.

Example

test "string upcase" {
  inspect(UnicodeString::new("abc").upcase().into_string(), content="ABC")
}

Value

source

pub(all) enum Value {
  Void
  Datum(Datum)
  Primitive(Primitive)
  Closure(Closure)
  CaseClosure(CaseClosure)
  Values(Array[Value])
  GuardHandler(GuardHandler)
  Parameter(Parameter)
  Promise(Promise)
  EvalEnv(EvalEnv)
  Continuation(Continuation)
  Port(Port)
  Record(Record)
  RecordProc(RecordProc)
  ConditionProc(ConditionProc)
  Hashtable(Hashtable)
  EnumSet(EnumSet)
  EnumSetProc(EnumSetProc)
  RecordTypeDescriptor(RecordTypeDescriptor)
  RecordConstructorDescriptor(RecordConstructorDescriptor)
  SyntaxObject(SyntaxObject)
  SyntaxKeyword(String)
  Macro(MacroTransformer)
}

WindAction

source

pub(all) enum WindAction {
  After(Winder)
  Before(Winder)
  SwitchHandlers(Array[Value])
}

Winder

source

pub struct Winder {
  id : Int
  kind : WinderKind
}

Winder::new_params

source

fn Winder::new_params(id : Int, bindings : Array[ParamBinding]) -> Winder

Winder::new_proc

source

fn Winder::new_proc(id : Int, before : Value, after : Value) -> Winder

WinderKind

source

pub enum WinderKind {
  Proc(Value, Value)
  Params(Array[ParamBinding])
}

Source Files

Site source Report issue Packages Build queue Skills Statistics

#core

#Highlights

#Examples

#Env

#EvalError

#EvalError::equal

#EvalError::not_equal

#EvalError::output

#EvalError::to_repr

#EvalError::to_string

#ParseError

#ParseError::equal

#ParseError::not_equal

#ParseError::output

#ParseError::to_repr

#ParseError::to_string

#Binding

#Binding::id

Example

#Binding::new

Example

#Binding::value

Example

#CaseClause

#CaseClause::new

#CaseClosure

#CaseClosure::new

#Closure

#Closure::new

#Condition

#Condition::new

#ConditionProc

#ConditionProc::new

#ConditionProcKind

#Continuation

#Continuation::new

#Datum

#EnumSet

#EnumSet::new

#EnumSetProc

#EnumSetProc::new

#EnumSetProcKind

#EvalEnv

#EvalEnv::new

#Formals

#Formals::new

#GuardHandler

#GuardHandler::new

#GuardInfo

#GuardInfo::new

#Hashtable

#Hashtable::new

#HashtableEntry

#HashtableEntry::new

#HashtableEquiv

#HashtableOp

#Kont

#MacroTransformer

#ParamBinding

#ParamBinding::new

#Parameter

#Parameter::new

#Port

#Port::new_output_string

#PortKind

#Primitive

#Primitive::equal

#Primitive::not_equal

#Promise

#Promise::new

#PromiseState

#Record

#Record::new

#RecordConstructorDescriptor

#RecordConstructorDescriptor::new

#RecordField

#RecordField::new

#RecordFieldBinding

#RecordFieldBinding::accessor

#RecordFieldBinding::index

Env

EvalError

EvalError::equal

EvalError::not_equal

EvalError::output

EvalError::to_repr

EvalError::to_string

ParseError

ParseError::equal

ParseError::not_equal

ParseError::output

ParseError::to_repr

ParseError::to_string

Binding

Binding::id

Binding::new

Binding::value

CaseClause

CaseClause::new

CaseClosure

CaseClosure::new

Closure

Closure::new

Condition

Condition::new

ConditionProc

ConditionProc::new

ConditionProcKind

Continuation

Continuation::new

Datum

EnumSet

EnumSet::new

EnumSetProc

EnumSetProc::new

EnumSetProcKind

EvalEnv

EvalEnv::new

Formals

Formals::new

GuardHandler

GuardHandler::new

GuardInfo

GuardInfo::new

Hashtable

Hashtable::new

HashtableEntry

HashtableEntry::new

HashtableEquiv

HashtableOp

Kont

MacroTransformer

ParamBinding

ParamBinding::new

Parameter

Parameter::new

Port

Port::new_output_string

PortKind

Primitive

Primitive::equal

Primitive::not_equal

Promise

Promise::new

PromiseState

Record

Record::new

RecordConstructorDescriptor

RecordConstructorDescriptor::new

RecordField

RecordField::new

RecordFieldBinding

RecordFieldBinding::accessor

RecordFieldBinding::index

RecordFieldBinding::mutator

RecordFieldBinding::new

RecordProc

RecordProc::new

RecordProcKind

RecordType