🥮 mooncakes.io

    Milky2018/diago/ir does not have a README file

    CompileError

    source
    pub(all) suberror CompileError {
      InvalidKey(String)
      InvalidValue(String)
      DuplicateField(String)
      InvalidSubstitution(String)
      ImportError(String)
    } derive(Eq, 
    Debug    )

    Compilation error

    CompileError::equal

    source
    #deprecated("`CompileError::equal` is deprecated, use `Eq::equal` instead.")
    fn CompileError::equal(CompileError, CompileError) -> Bool

    CompileError::not_equal

    source
    #deprecated("`CompileError::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn CompileError::not_equal(x : CompileError, y : CompileError) -> Bool

    CompileError::output

    source
    #deprecated("`CompileError::output` is deprecated, use `Show::output` instead.")
    fn CompileError::output(self : CompileError, logger : &Logger) -> Unit

    CompileError::to_repr

    source
    #deprecated("`CompileError::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn CompileError::to_repr(CompileError) -> 
    Repr

    CompileError::to_string

    source
    fn CompileError::to_string(self : CompileError) -> String

    Composite

    source
    pub(all) enum Composite {
      Array(IRArray)
      Map(Map)
    } derive(Eq, 
    Debug    )

    Composite values (Array or Map)

    Composite::equal

    source
    #deprecated("`Composite::equal` is deprecated, use `Eq::equal` instead.")
    fn Composite::equal(Composite, Composite) -> Bool

    Composite::not_equal

    source
    #deprecated("`Composite::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Composite::not_equal(x : Composite, y : Composite) -> Bool

    Composite::to_repr

    source
    #deprecated("`Composite::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Composite::to_repr(Composite) -> 
    Repr

    Edge

    source
    pub struct Edge {
      id : EdgeID
      primary : Scalar?
      map : Map?
      references : Array[EdgeReference]
      import_ast : 
    Node    ?
      path : NodePath?
    } derive(Eq, 
    Debug    )

    An edge in the IR

    Edge::ast

    source

    Edge::copy

    source
    fn Edge::copy(self : Edge) -> Edge

    Edge::equal

    source
    #deprecated("`Edge::equal` is deprecated, use `Eq::equal` instead.")
    fn Edge::equal(Edge, Edge) -> Bool

    Edge::import_ast

    source
    fn Edge::import_ast(self : Edge) -> 
    Node    ?

    Edge::last_primary_key

    source
    fn Edge::last_primary_key(self : Edge) -> 
    Key    ?

    Edge::last_primary_ref

    source
    fn Edge::last_primary_ref(self : Edge) -> Reference?

    Edge::last_ref

    source
    fn Edge::last_ref(self : Edge) -> Reference?

    Edge::new

    source
    fn Edge::new(id : EdgeID, primary : Scalar?, map : Map?, references : Array[EdgeReference]) -> Edge

    Edge::not_equal

    source
    #deprecated("`Edge::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Edge::not_equal(x : Edge, y : Edge) -> Bool

    Edge::parent

    source
    fn Edge::parent(self : Edge, root : Map) -> Node?

    Edge::path

    source
    fn Edge::path(self : Edge) -> NodePath?

    Edge::to_repr

    source
    #deprecated("`Edge::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Edge::to_repr(Edge) -> 
    Repr

    EdgeID

    source
    pub struct EdgeID {
      src_path : Array[String]
      src_path_syntax : Array[
    StringValue    ]
      src_arrow : Bool
      dst_path : Array[String]
      dst_path_syntax : Array[
    StringValue    ]
      dst_arrow : Bool
      index : Int?
      glob : Bool
    } derive(Eq, 
    Debug    )

    Unique identifier for an edge

    EdgeID::copy

    source
    fn EdgeID::copy(self : EdgeID) -> EdgeID

    Create a copy of this EdgeID

    EdgeID::dst_path_syntax

    source

    EdgeID::equal

    source
    #deprecated("`EdgeID::equal` is deprecated, use `Eq::equal` instead.")
    fn EdgeID::equal(EdgeID, EdgeID) -> Bool

    EdgeID::matches

    source
    fn EdgeID::matches(self : EdgeID, other : EdgeID) -> Bool

    Check if this EdgeID matches another (for queries)

    EdgeID::new

    source
    fn EdgeID::new(src_path : Array[String], dst_path : Array[String], src_arrow : Bool, dst_arrow : Bool, src_path_syntax? : Array[
    StringValue    ]?, dst_path_syntax? : Array[
    StringValue    ]?) -> EdgeID

    EdgeID::not_equal

    source
    #deprecated("`EdgeID::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn EdgeID::not_equal(x : EdgeID, y : EdgeID) -> Bool

    EdgeID::src_path_syntax

    source

    EdgeID::to_repr

    source
    #deprecated("`EdgeID::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn EdgeID::to_repr(EdgeID) -> 
    Repr

    EdgeID::with_glob

    source
    fn EdgeID::with_glob(src_path : Array[String], dst_path : Array[String], src_arrow : Bool, dst_arrow : Bool, src_path_syntax? : Array[
    StringValue    ]?, dst_path_syntax? : Array[
    StringValue    ]?) -> EdgeID

    EdgeID::with_index

    source
    fn EdgeID::with_index(src_path : Array[String], dst_path : Array[String], src_arrow : Bool, dst_arrow : Bool, index : Int, src_path_syntax? : Array[
    StringValue    ]?, dst_path_syntax? : Array[
    StringValue    ]?) -> EdgeID

    EdgeReference

    source
    pub struct EdgeReference {
      range : 
    Range
      edge : 
    Edge    ?
      context : RefContext?
      edge_index : Int
      primary : Bool
      due_to_glob : Bool
      due_to_lazy_glob : Bool
    } derive(Eq, 
    Debug    )

    Reference to an edge from the AST

    EdgeReference::ast

    source

    EdgeReference::context

    source
    fn EdgeReference::context(self : EdgeReference) -> RefContext?

    EdgeReference::equal

    source
    #deprecated("`EdgeReference::equal` is deprecated, use `Eq::equal` instead.")
    fn EdgeReference::equal(EdgeReference, EdgeReference) -> Bool

    EdgeReference::from_ast

    source
    fn EdgeReference::from_ast(edge : 
    Edge    , edge_index : Int, primary : Bool, context : RefContext, due_to_glob? : Bool, due_to_lazy_glob? : Bool) -> EdgeReference

    EdgeReference::new

    source
    fn EdgeReference::new(range : 
    Range    , edge_index : Int, primary : Bool) -> EdgeReference

    EdgeReference::not_equal

    source
    #deprecated("`EdgeReference::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn EdgeReference::not_equal(x : EdgeReference, y : EdgeReference) -> Bool

    EdgeReference::to_repr

    source
    #deprecated("`EdgeReference::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn EdgeReference::to_repr(EdgeReference) -> 
    Repr

    Field

    source
    pub struct Field {
      name : String
      name_syntax : 
    StringValue    ?
      primary : Scalar?
      composite : Composite?
      references : Array[FieldReference]
      import_ast : 
    Node    ?
      path : NodePath?
    } derive(Eq, 
    Debug    )

    A field in the IR map

    Field::array

    source
    fn Field::array(self : Field) -> IRArray?

    Get the array composite if this field has one

    Field::ast

    source

    Field::copy

    source
    fn Field::copy(self : Field) -> Field

    Field::equal

    source
    #deprecated("`Field::equal` is deprecated, use `Eq::equal` instead.")
    fn Field::equal(Field, Field) -> Bool

    Field::has_composite

    source
    fn Field::has_composite(self : Field) -> Bool

    Check if this field has a composite value

    Field::has_primary

    source
    fn Field::has_primary(self : Field) -> Bool

    Check if this field has a primary value

    Field::import_ast

    source
    fn Field::import_ast(self : Field) -> 
    Node    ?

    Field::is_board_keyword_name

    source
    fn Field::is_board_keyword_name(self : Field) -> Bool

    Field::is_reserved_keyword_name

    source
    fn Field::is_reserved_keyword_name(self : Field) -> Bool

    Field::last_primary_key

    source
    fn Field::last_primary_key(self : Field) -> 
    Key    ?

    Field::last_primary_ref

    source
    fn Field::last_primary_ref(self : Field) -> Reference?

    Field::last_ref

    source
    fn Field::last_ref(self : Field) -> Reference?

    Field::map

    source
    fn Field::map(self : Field) -> Map?

    Get the map composite if this field has one

    Field::name_is_unquoted

    source
    fn Field::name_is_unquoted(self : Field) -> Bool

    Field::name_syntax

    source

    Field::new

    source
    fn Field::new(name : String, primary : Scalar?, composite : Composite?, references : Array[FieldReference], name_syntax? : 
    StringValue    ?) -> Field

    Field::not_equal

    source
    #deprecated("`Field::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Field::not_equal(x : Field, y : Field) -> Bool

    Field::parent

    source
    fn Field::parent(self : Field, root : Map) -> Node?

    Field::path

    source
    fn Field::path(self : Field) -> NodePath?

    Field::simple

    source
    fn Field::simple(name : String, name_syntax? : 
    StringValue    ?) -> Field

    Field::to_repr

    source
    #deprecated("`Field::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Field::to_repr(Field) -> 
    Repr

    FieldReference

    source
    pub struct FieldReference {
      range : 
    Range
      string : String
      syntax : 
    StringValue    ?
      key_path : 
    KeyPath    ?
      context : RefContext?
      key_path_index : Int
      primary : Bool
      due_to_glob : Bool
      due_to_lazy_glob : Bool
    } derive(Eq, 
    Debug    )

    Reference to a field from the AST

    FieldReference::ast

    source

    FieldReference::context

    source
    fn FieldReference::context(self : FieldReference) -> RefContext?

    FieldReference::equal

    source
    #deprecated("`FieldReference::equal` is deprecated, use `Eq::equal` instead.")
    fn FieldReference::equal(FieldReference, FieldReference) -> Bool

    FieldReference::from_ast

    source
    fn FieldReference::from_ast(syntax : 
    StringValue    , key_path : 
    KeyPath    , key_path_index : Int, primary : Bool, context : RefContext, due_to_glob? : Bool, due_to_lazy_glob? : Bool) -> FieldReference

    FieldReference::new

    source
    fn FieldReference::new(range : 
    Range    , string : String, key_path_index : Int, primary : Bool) -> FieldReference

    FieldReference::not_equal

    source
    #deprecated("`FieldReference::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn FieldReference::not_equal(x : FieldReference, y : FieldReference) -> Bool

    FieldReference::to_repr

    source
    #deprecated("`FieldReference::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn FieldReference::to_repr(FieldReference) -> 
    Repr

    FilterContext

    source
    pub struct FilterContext {
      field : Field
      parent_map : Map
    }

    Filter context for evaluating ampersand filters

    FilterContext::new

    source
    fn FilterContext::new(field : Field, parent_map : Map) -> FilterContext

    IRArray

    source
    pub struct IRArray {
      values : Array[Value]
      ast : 
    Node    ?
      source_path : String?
      path : NodePath?
    } derive(Eq, 
    Debug    )

    An array of values

    IRArray::ast

    source

    IRArray::copy

    source
    fn IRArray::copy(self : IRArray) -> IRArray

    IRArray::equal

    source
    #deprecated("`IRArray::equal` is deprecated, use `Eq::equal` instead.")
    fn IRArray::equal(IRArray, IRArray) -> Bool

    IRArray::from_ast

    source
    fn IRArray::from_ast(ast : 
    ArrayValue    , values : Array[Value], source_path? : String?) -> IRArray

    IRArray::new

    source
    fn IRArray::new(values : Array[Value]) -> IRArray

    IRArray::not_equal

    source
    #deprecated("`IRArray::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn IRArray::not_equal(x : IRArray, y : IRArray) -> Bool

    IRArray::parent

    source
    fn IRArray::parent(self : IRArray, root : Map) -> Node?

    IRArray::path

    source
    fn IRArray::path(self : IRArray) -> NodePath?

    IRArray::source_path

    source
    fn IRArray::source_path(self : IRArray) -> String?

    IRArray::to_repr

    source
    #deprecated("`IRArray::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn IRArray::to_repr(IRArray) -> 
    Repr

    ImportResolver

    source
    pub struct ImportResolver((String) -> String?)

    Import resolver function type Takes an import path and returns the file content, or None if not found

    ImportResolver::new

    source
    fn ImportResolver::new(f : (String) -> String?) -> ImportResolver

    Create a new import resolver from a function

    Map

    source
    pub struct Map {
      fields : Array[Field]
      edges : Array[Edge]
      ast : 
    Node    ?
      import_ast : 
    Node    ?
      source_path : String?
      path : NodePath?
    } derive(Eq, 
    Debug    )

    An IR Map containing fields and edges

    Map::add_edge

    source
    fn Map::add_edge(self : Map, edge : Edge) -> Unit

    Add an edge to the map

    Map::add_field

    source
    fn Map::add_field(self : Map, field : Field) -> Unit

    Add a field to the map

    Map::apply_glob_properties

    source
    fn Map::apply_glob_properties(self : Map, pattern : Array[String], properties : Map, filters : Array[(Bool, String, String)]) -> Unit

    Apply properties to fields matching a glob pattern If filters are provided, only apply to fields that pass all filters

    Map::ast

    source

    Map::copy

    source
    fn Map::copy(self : Map) -> Map

    Map::delete_field

    source
    fn Map::delete_field(self : Map, name : String) -> Field?

    Delete a field by name, returning it if found

    Map::double_glob

    source
    fn Map::double_glob(self : Map) -> Array[Field]

    Collect all fields matching a double glob (**) pattern This recursively collects all descendant fields except board keywords

    Map::ensure_field

    source
    fn Map::ensure_field(self : Map, name : String) -> Field

    Get or create a field by name

    Map::ensure_field_by_syntax

    source
    fn Map::ensure_field_by_syntax(self : Map, name : 
    StringValue    ) -> Field

    Map::equal

    source
    #deprecated("`Map::equal` is deprecated, use `Eq::equal` instead.")
    fn Map::equal(Map, Map) -> Bool

    Map::find_edges

    source
    fn Map::find_edges(self : Map, id : EdgeID) -> Array[Edge]

    Find edges matching an EdgeID

    Map::from_ast

    source
    fn Map::from_ast(ast : 
    Map    , source_path? : String?) -> Map

    Map::get_field

    source
    fn Map::get_field(self : Map, name : String) -> Field?

    Get a field by name (case-insensitive)

    Map::get_field_by_syntax

    source
    fn Map::get_field_by_syntax(self : Map, name : 
    StringValue    ) -> Field?

    Map::get_node

    source
    fn Map::get_node(self : Map, path : NodePath) -> Node?

    Map::has_field

    source
    fn Map::has_field(self : Map, name : String) -> Bool

    Check if map has a field with given name

    Map::import_ast

    source
    fn Map::import_ast(self : Map) -> 
    Node    ?

    Map::multi_glob

    source
    fn Map::multi_glob(self : Map, pattern : Array[String]) -> (Array[Field], Bool)

    Collect fields matching a multi-glob pattern (** or ***) Returns (fields, is_glob_pattern)

    Map::new

    source
    fn Map::new() -> Map

    Map::not_equal

    source
    #deprecated("`Map::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Map::not_equal(x : Map, y : Map) -> Bool

    Map::overlay

    source
    fn Map::overlay(self : Map, overlay : Map) -> Map

    Return a detached map created by overlaying overlay onto self.

    Map::parent

    source
    fn Map::parent(self : Map, root : Map) -> Node?

    Map::path

    source
    fn Map::path(self : Map) -> NodePath?

    Map::reindex_paths

    source
    fn Map::reindex_paths(self : Map) -> Map

    Map::single_glob

    source
    fn Map::single_glob(self : Map, pattern : Array[String]) -> Array[Field]

    Collect fields at one level matching a single glob pattern

    Map::source_path

    source
    fn Map::source_path(self : Map) -> String?

    Map::to_repr

    source
    #deprecated("`Map::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Map::to_repr(Map) -> 
    Repr

    Map::triple_glob

    source
    fn Map::triple_glob(self : Map) -> Array[Field]

    Collect all fields matching a triple glob (***) pattern This recursively collects all descendant fields including boards

    Node

    source
    pub(all) enum Node {
      Scalar(Scalar)
      Field(Field)
      Edge(Edge)
      IRArray(IRArray)
      Map(Map)
      Composite(Composite)
      Value(Value)
    } derive(Eq, 
    Debug    )

    Boxed IR node for generic traversal.

    Node::ast

    source

    Node::children

    source
    fn Node::children(self : Node) -> Array[Node]

    Node::copy

    source
    fn Node::copy(self : Node) -> Node

    Node::equal

    source
    #deprecated("`Node::equal` is deprecated, use `Eq::equal` instead.")
    fn Node::equal(Node, Node) -> Bool

    Node::import_ast

    source
    fn Node::import_ast(self : Node) -> 
    Node    ?

    Node::last_primary_key

    source
    fn Node::last_primary_key(self : Node) -> 
    Key    ?

    Node::last_primary_ref

    source
    fn Node::last_primary_ref(self : Node) -> Reference?

    Node::last_ref

    source
    fn Node::last_ref(self : Node) -> Reference?

    Node::node_type

    source
    fn Node::node_type(self : Node) -> String

    Node::not_equal

    source
    #deprecated("`Node::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Node::not_equal(x : Node, y : Node) -> Bool

    Node::parent

    source
    fn Node::parent(self : Node, root : Map) -> Node?

    Node::path

    source
    fn Node::path(self : Node) -> NodePath?

    Node::to_repr

    source
    #deprecated("`Node::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Node::to_repr(Node) -> 
    Repr

    NodePath

    source
    pub struct NodePath {
      segments : Array[NodePathSegment]
    } derive(Eq, 
    Debug    )

    Stable path to an IR node inside a compiled map.

    NodePath::append

    source
    fn NodePath::append(self : NodePath, segment : NodePathSegment) -> NodePath

    NodePath::equal

    source
    #deprecated("`NodePath::equal` is deprecated, use `Eq::equal` instead.")
    fn NodePath::equal(NodePath, NodePath) -> Bool

    NodePath::not_equal

    source
    #deprecated("`NodePath::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn NodePath::not_equal(x : NodePath, y : NodePath) -> Bool

    NodePath::parent

    source
    fn NodePath::parent(self : NodePath) -> NodePath?

    NodePath::root

    source
    fn NodePath::root() -> NodePath

    NodePath::to_repr

    source
    #deprecated("`NodePath::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn NodePath::to_repr(NodePath) -> 
    Repr

    NodePathSegment

    source
    pub(all) enum NodePathSegment {
      FieldStep(String, Bool)
      EdgeStep(EdgeID)
      PrimaryStep
      CompositeStep
      ArrayItemStep(Int)
    } derive(Eq, 
    Debug    )

    Stable path to an IR node inside a compiled map.

    NodePathSegment::equal

    source
    #deprecated("`NodePathSegment::equal` is deprecated, use `Eq::equal` instead.")
    fn NodePathSegment::equal(NodePathSegment, NodePathSegment) -> Bool

    NodePathSegment::not_equal

    source
    #deprecated("`NodePathSegment::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn NodePathSegment::not_equal(x : NodePathSegment, y : NodePathSegment) -> Bool

    NodePathSegment::to_repr

    source
    #deprecated("`NodePathSegment::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn NodePathSegment::to_repr(NodePathSegment) -> 
    Repr

    RefContext

    source
    pub struct RefContext {
      edge : 
    Edge    ?
      key : 
    Key    ?
      scope : 
    Map    ?
      source_path : String?
    } derive(Eq, 
    Debug    )

    Reference context for a field or edge reference.

    RefContext::equal

    source
    #deprecated("`RefContext::equal` is deprecated, use `Eq::equal` instead.")
    fn RefContext::equal(RefContext, RefContext) -> Bool

    RefContext::new

    source

    RefContext::not_equal

    source
    #deprecated("`RefContext::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn RefContext::not_equal(x : RefContext, y : RefContext) -> Bool

    RefContext::to_repr

    source
    #deprecated("`RefContext::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn RefContext::to_repr(RefContext) -> 
    Repr

    Reference

    source
    pub(all) enum Reference {
      FieldRef(FieldReference)
      EdgeRef(EdgeReference)
    } derive(Eq, 
    Debug    )

    Boxed reference for generic traversal.

    Reference::ast

    source

    Reference::context

    source
    fn Reference::context(self : Reference) -> RefContext?

    Reference::due_to_glob

    source
    fn Reference::due_to_glob(self : Reference) -> Bool

    Reference::due_to_lazy_glob

    source
    fn Reference::due_to_lazy_glob(self : Reference) -> Bool

    Reference::equal

    source
    #deprecated("`Reference::equal` is deprecated, use `Eq::equal` instead.")
    fn Reference::equal(Reference, Reference) -> Bool

    Reference::not_equal

    source
    #deprecated("`Reference::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Reference::not_equal(x : Reference, y : Reference) -> Bool

    Reference::primary

    source
    fn Reference::primary(self : Reference) -> Bool

    Reference::range

    source

    Reference::to_repr

    source
    #deprecated("`Reference::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Reference::to_repr(Reference) -> 
    Repr

    Scalar

    source
    pub struct Scalar {
      value : ScalarValue
      range : 
    Range
      ast : 
    Node    ?
      source_path : String?
      path : NodePath?
    } derive(Eq, 
    Debug    )

    A scalar value in the IR.

    Scalars carry a source range for error reporting and reference tracking.

    Scalar::as_bool

    source
    fn Scalar::as_bool(self : Scalar) -> Bool?

    Get boolean value if this is a boolean

    Scalar::as_double

    source
    fn Scalar::as_double(self : Scalar) -> Double?

    Scalar::as_int

    source
    fn Scalar::as_int(self : Scalar) -> Int?

    Scalar::as_string_value

    source

    Get underlying string value (including block-string metadata) if present

    Scalar::ast

    source

    Scalar::at

    source

    Scalar::block_string_tag

    source
    fn Scalar::block_string_tag(self : Scalar) -> String?

    Get block-string language tag if this scalar is a block string

    Scalar::bool

    source
    fn Scalar::bool(b : Bool) -> Scalar

    Scalar::copy

    source
    fn Scalar::copy(self : Scalar) -> Scalar

    Scalar::equal

    source
    #deprecated("`Scalar::equal` is deprecated, use `Eq::equal` instead.")
    fn Scalar::equal(Scalar, Scalar) -> Bool

    Scalar::from_ast

    source
    fn Scalar::from_ast(ast : 
    Node    , value : ScalarValue, source_path? : String?) -> Scalar

    Scalar::get_range

    source

    Scalar::is_bool

    source
    fn Scalar::is_bool(self : Scalar) -> Bool

    Check if scalar is a boolean

    Scalar::is_null

    source
    fn Scalar::is_null(self : Scalar) -> Bool

    Check if scalar is null

    Scalar::is_number

    source
    fn Scalar::is_number(self : Scalar) -> Bool

    Check if scalar is a number

    Scalar::is_string

    source
    fn Scalar::is_string(self : Scalar) -> Bool

    Check if scalar is a string

    Scalar::new

    source
    fn Scalar::new(value : ScalarValue) -> Scalar

    Scalar::not_equal

    source
    #deprecated("`Scalar::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Scalar::not_equal(x : Scalar, y : Scalar) -> Bool

    Scalar::null

    source
    fn Scalar::null() -> Scalar

    Scalar::number

    source
    fn Scalar::number(n : String) -> Scalar

    Scalar::parent

    source
    fn Scalar::parent(self : Scalar, root : Map) -> Node?

    Scalar::path

    source
    fn Scalar::path(self : Scalar) -> NodePath?

    Scalar::source_path

    source
    fn Scalar::source_path(self : Scalar) -> String?

    Scalar::string

    source
    fn Scalar::string(s : String) -> Scalar

    Scalar::to_repr

    source
    #deprecated("`Scalar::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Scalar::to_repr(Scalar) -> 
    Repr

    Scalar::to_string

    source
    fn Scalar::to_string(self : Scalar) -> String

    Get the string representation of a scalar value

    ScalarValue

    source
    pub(all) enum ScalarValue {
      Null
      Bool(String)
      Number(String)
      String(
    StringValue    )
    } derive(Eq, 
    Debug    )

    Types of scalar values

    ScalarValue::equal

    source
    #deprecated("`ScalarValue::equal` is deprecated, use `Eq::equal` instead.")
    fn ScalarValue::equal(ScalarValue, ScalarValue) -> Bool

    ScalarValue::not_equal

    source
    #deprecated("`ScalarValue::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn ScalarValue::not_equal(x : ScalarValue, y : ScalarValue) -> Bool

    ScalarValue::to_repr

    source
    #deprecated("`ScalarValue::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn ScalarValue::to_repr(ScalarValue) -> 
    Repr

    Value

    source
    pub(all) enum Value {
      Scalar(Scalar)
      Array(IRArray)
      Map(Map)
    } derive(Eq, 
    Debug    )

    Value types in IR

    Value::as_array

    source
    fn Value::as_array(self : Value) -> IRArray?

    Get the array if this is an array

    Value::as_map

    source
    fn Value::as_map(self : Value) -> Map?

    Get the map if this is a map

    Value::as_scalar

    source
    fn Value::as_scalar(self : Value) -> Scalar?

    Get the scalar value if this is a scalar

    Value::equal

    source
    #deprecated("`Value::equal` is deprecated, use `Eq::equal` instead.")
    fn Value::equal(Value, Value) -> Bool

    Value::not_equal

    source
    #deprecated("`Value::not_equal` is deprecated, use `Eq::not_equal` instead.")
    fn Value::not_equal(x : Value, y : Value) -> Bool

    Value::to_repr

    source
    #deprecated("`Value::to_repr` is deprecated, use `@moonbitlang/core/debug.Debug::to_repr` instead.")
    fn Value::to_repr(Value) -> 
    Repr

    compile

    source
    fn compile(ast : 
    Map    ) -> Map raise CompileError

    Compile an AST Map to IR Map

    compile_with_imports

    source
    fn compile_with_imports(ast : 
    Map    , resolver : ImportResolver) -> Map raise CompileError

    Compile an AST Map with import resolution

    evaluate_filter

    source
    fn evaluate_filter(ctx : FilterContext, filter_key : String, filter_value : String) -> Bool

    Evaluate a filter condition against a field Returns true if the field passes the filter

    filter_value_matches

    source
    fn filter_value_matches(actual : String, pattern : String) -> Bool

    is_board_keyword

    source
    fn is_board_keyword(name : String) -> Bool

    Check if a keyword is a board keyword

    is_double_glob

    source
    fn is_double_glob(pattern : Array[String]) -> Bool

    Check if pattern represents a double glob () Parser stores ** as ["", "", ""]

    is_reserved_keyword

    source
    fn is_reserved_keyword(name : String) -> Bool

    Check if a keyword is reserved

    is_triple_glob

    source
    fn is_triple_glob(pattern : Array[String]) -> Bool

    Check if pattern represents a triple glob () Parser stores *** as ["", "", "", "", ""]

    match_pattern

    source
    fn match_pattern(s : String, pattern : Array[String]) -> Bool

    Match a string against a glob pattern Pattern is an array where elements are either:
    • literal text to match
    • "*" to match any characters

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io