typealias (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow as RuntimeFunction

pub suberror ControlFlow {
  Raise(RuntimeValue)
  Continue(Array[RuntimeValue])
  Break(RuntimeValue?)
  Return(RuntimeValue)
  Error(String)
}

pub(all) struct ClosureInterpreter {
  extern_fns : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]
  embedded_fns : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]
  embedded_methods : Map[String, Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]]
  main : RuntimeModule
  current_module : RuntimeModule
  state : InterpreterState
  call_stack : Array[RuntimeLocation]
}

pub(all) struct ConstructorField {
  name : String?
  value : RuntimeValue
  mutable : Bool
}

pub(all) struct ConstructorValue {
  name : String
  fields : Array[ConstructorField]
}

pub(all) enum InterpreterState {
  Running
  Stopped
}

pub struct ModuleMeta {
  name : String
  version : String?
  deps : Map[String, String]?
  readme : String?
  repository : String?
  license : String?
  keywords : Array[String]?
  description : String?
  source : String?
}

pub(all) struct RuntimeArgument {
  val : RuntimeValue
  kind : RuntimeArgumentKind
}

pub(all) enum RuntimeArgumentKind {
  Positional
  Labelled(String)
  LabelledOption(String)
}

pub(all) struct RuntimeEnvironment {
  traits : Map[String, 
@moonbitlang/parser/syntax.TraitDecl
TraitDecl]
  fn_aliases : Map[String, String]
  type_definitions : Map[String, 
@moonbitlang/parser/syntax.TypeDecl
TypeDecl]
  struct_methods : Map[String, Map[String, RuntimeValue]]
  type_environment : TypeEnvironment
  values : Map[String, RuntimeValue]
  mutable_vars : Map[String, Bool]
  parent : RuntimeEnvironment?
}

pub(all) struct RuntimeFunctionContext {
  context : ClosureInterpreter
  mod : RuntimeModule
  args : Array[RuntimeArgument]
}

pub enum RuntimeLocation {
  FunctionCall(String)
  ControlFlow(String)
  LetMut(String)
}

pub(all) struct RuntimeModule {
  meta : ModuleMeta
  env : RuntimeEnvironment
  deps : Map[String, RuntimeModule]
}

pub struct RuntimeType {
  pkg : String
  name : String
  env : RuntimeEnvironment
}

pub(all) enum RuntimeValue {
  Unit
  Bool(Bool)
  Int(Int)
  UInt(UInt)
  UInt16(UInt16)
  Int64(Int64)
  UInt64(UInt64)
  Float(Float)
  Double(Double)
  BigInt(
@moonbitlang/core/bigint.BigInt
BigInt)
  Char(Char)
  Byte(Byte)
  String(String)
  Bytes(Bytes)
  StringView(
@moonbitlang/core/string.View
View)
  Tuple(Array[RuntimeValue])
  Array(Array[RuntimeValue])
  ArrayView(ArrayView[RuntimeValue])
  UninitializedArray(UninitializedArray[RuntimeValue])
  Map(Map[RuntimeValue, RuntimeValue])
  Struct(WithType[Map[String, RuntimeValue]])
  Closure(
@moonbitlang/parser/syntax.Func
Func, RuntimeEnvironment)
  Constructor(WithType[ConstructorValue])
  Exception(String)
  Iter(Iter[RuntimeValue])
}

pub struct TypeEnvironment {
  type_bindings : Map[String, String]
  parent : TypeEnvironment?
}

pub struct WithType[T] {
  val : T
  type_info : RuntimeType
}

let array_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

let array_view_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

fn[T : Compare + Eq] compare(left : T, right : T, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn constant_infix(name : String, lhs : 
@moonbitlang/parser/syntax.Constant
Constant, rhs : 
@moonbitlang/parser/syntax.Constant
Constant) -> 
@moonbitlang/parser/syntax.Constant
Constant

#callsite(autofill(loc))
fn[A] error(msg : String, loc~ : SourceLoc) -> A raise ControlFlow

fn eval_double_op(left : Double, right : Double, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn eval_float_op(left : Double, right : Double, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn eval_int64_op(left : Int64, right : Int64, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn eval_int_op(left : Int, right : Int, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn eval_uint64_op(left : UInt64, right : UInt64, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

fn eval_uint_op(left : UInt, right : UInt, op : String) -> 
@moonbitlang/parser/syntax.Constant
Constant

let int_embedded_code : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

let int_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

fn is_comparison_op(op : String) -> Bool

let iter_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

let map_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

let option_methods : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

fn parse_code_to_expr(code : String) -> Result[
@moonbitlang/parser/syntax.Expr
Expr, String]

fn parse_code_to_impl(code : String) -> Result[
@moonbitlang/parser/syntax.Impl
Impl, String]

fn runtime_value_infix(op : String, lhs : RuntimeValue, rhs : RuntimeValue) -> RuntimeValue

let string_embedded_code : Map[String, (RuntimeFunctionContext) -> RuntimeValue raise ControlFlow]

fn type_to_string(ty : 
@moonbitlang/parser/syntax.Type
Type) -> String

fn unit(loc? : 
@moonbitlang/parser/basic.Location
Location) -> 
@moonbitlang/parser/syntax.Expr
Expr