🥮 mooncakes.io

    Milky2018/diago/ast does not have a README file

    ArrayNode

    source
    pub(all) enum ArrayNode {
      Comment(
    Range    , String)
      BlockComment(
    Range    , String)
      Substitution(Substitution)
      Import(Import)
      Value(Value)
    } derive(Eq, 
    Debug    )

    Nodes that can appear inside an array

    ArrayNode::equal

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

    ArrayNode::not_equal

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

    ArrayNode::range

    source

    ArrayNode::to_repr

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

    ArrayValue

    source

    An array value

    ArrayValue::equal

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

    ArrayValue::new

    source

    ArrayValue::not_equal

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

    ArrayValue::to_repr

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

    BlockString

    source
    pub struct BlockString {
      range : 
    Range
      quote : String
      tag : String
      value : String
    } derive(Eq, 
    Debug    )

    Block string (|md, |sh, etc.)

    BlockString::equal

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

    BlockString::new

    source
    fn BlockString::new(range : 
    Range    , quote : String, tag : String, value : String) -> BlockString

    BlockString::not_equal

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

    BlockString::to_repr

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

    DoubleQuotedString

    source
    pub struct DoubleQuotedString {
      range : 
    Range
      value : Array[Interpolation]
    } derive(Eq, 
    Debug    )

    Double-quoted string that may contain substitutions

    DoubleQuotedString::equal

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

    DoubleQuotedString::new

    source

    DoubleQuotedString::not_equal

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

    DoubleQuotedString::to_repr

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

    DoubleQuotedString::to_string

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

    Edge

    source
    pub struct Edge {
      range : 
    Range
      src : KeyPath
      src_arrow : String
      dst : KeyPath
      dst_arrow : String
    } derive(Eq, 
    Debug    )

    An edge between two nodes

    Edge::equal

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

    Edge::new

    source
    fn Edge::new(range : 
    Range    , src : KeyPath, dst : KeyPath, src_arrow : String, dst_arrow : String) -> 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::to_repr

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

    EdgeIndex

    source
    pub struct EdgeIndex {
      range : 
    Range
      index : Int?
      glob : Bool
    } derive(Eq, 
    Debug    )

    Index into an edge group

    EdgeIndex::equal

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

    EdgeIndex::new

    source
    fn EdgeIndex::new(range : 
    Range    , index : Int?, glob : Bool) -> EdgeIndex

    EdgeIndex::not_equal

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

    EdgeIndex::to_repr

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

    Import

    source
    pub struct Import {
      range : 
    Range
      spread : Bool
      pre : String
      path : Array[StringValue]
    } derive(Eq, 
    Debug    )

    Import declaration (@path/to/file)

    Import::equal

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

    Import::new

    source
    fn Import::new(range : 
    Range    , spread : Bool, pre : String, path : Array[StringValue]) -> Import

    Import::not_equal

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

    Import::to_repr

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

    Interpolation

    source
    pub(all) enum Interpolation {
      Text(String)
      Sub(Substitution)
    } derive(Eq, 
    Debug    )

    Part of an interpolated string

    Interpolation::equal

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

    Interpolation::not_equal

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

    Interpolation::to_repr

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

    Key

    source
    pub struct Key {
      range : 
    Range
      ampersand : Bool
      not_ampersand : Bool
      key : KeyPath?
      edges : Array[Edge]
      edge_index : EdgeIndex?
      edge_key : KeyPath?
      primary : Scalar?
      value : Value?
    } derive(Eq, 
    Debug    )

    A key declaration in a map

    Examples:
    • x (simple key)
    • x: value (key with value)
    • x -> y (edge)
    • container.child (nested key path)
    • (x -> y).label (edge with property)

    Key::equal

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

    Key::new

    source
    fn Key::new(range : 
    Range    , ampersand : Bool, not_ampersand : Bool, key : KeyPath?, edges : Array[Edge], edge_index : EdgeIndex?, edge_key : KeyPath?, primary : Scalar?, value : Value?) -> Key

    Key::not_equal

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

    Key::to_repr

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

    KeyPath

    source

    A path of identifiers separated by dots Example: container.child.grandchild

    KeyPath::equal

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

    KeyPath::has_glob

    source
    fn KeyPath::has_glob(self : KeyPath) -> Bool

    KeyPath::last

    source
    fn KeyPath::last(self : KeyPath) -> StringValue?

    KeyPath::new

    source

    KeyPath::not_equal

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

    KeyPath::to_repr

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

    KeyPath::to_strings

    source
    fn KeyPath::to_strings(self : KeyPath) -> Array[String]

    Map

    source

    A diago file is represented as a Map at the root level

    Map::equal

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

    Map::new

    source
    fn Map::new(range : 
    Range    , nodes : Array[MapNode]) -> 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::to_repr

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

    MapNode

    source
    pub(all) enum MapNode {
      Comment(
    Range    , String)
      BlockComment(
    Range    , String)
      Substitution(Substitution)
      Import(Import)
      Key(Key)
    } derive(Eq, 
    Debug    )

    Nodes that can appear inside a Map

    MapNode::equal

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

    MapNode::not_equal

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

    MapNode::range

    source

    MapNode::to_repr

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

    Node

    source
    pub(all) enum Node {
      Map(Map)
      MapNode(MapNode)
      Key(Key)
      KeyPath(KeyPath)
      Edge(Edge)
      EdgeIndex(EdgeIndex)
      Value(Value)
      ArrayValue(ArrayValue)
      ArrayNode(ArrayNode)
      Scalar(Scalar)
      StringValue(StringValue)
      UnquotedString(UnquotedString)
      DoubleQuotedString(DoubleQuotedString)
      BlockString(BlockString)
      Substitution(Substitution)
      Import(Import)
    } derive(Eq, 
    Debug    )

    Boxed AST node for generic traversal.

    This is intentionally a closed set of variants over the public AST structs/enums.

    Node::children

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

    Node::equal

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

    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::range

    source

    Node::to_repr

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

    Scalar

    source

    Scalar values

    Scalar::equal

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

    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::range

    source

    Scalar::to_repr

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

    StringValue

    source
    pub(all) enum StringValue {
      Unquoted(UnquotedString)
      SingleQuoted(
    Range    , String)
      DoubleQuoted(DoubleQuotedString)
      Block(BlockString)
    } derive(Eq, 
    Debug    )

    String values with their quote style

    StringValue::content

    source
    fn StringValue::content(self : StringValue) -> String

    StringValue::equal

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

    StringValue::not_equal

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

    StringValue::range

    source

    StringValue::to_repr

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

    Substitution

    source
    pub struct Substitution {
      range : 
    Range
      spread : Bool
      path : Array[StringValue]
    } derive(Eq, 
    Debug    )

    Variable substitution ($var or ${var})

    Substitution::equal

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

    Substitution::new

    source

    Substitution::not_equal

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

    Substitution::to_repr

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

    UnquotedString

    source
    pub struct UnquotedString {
      range : 
    Range
      value : Array[Interpolation]
      pattern : Array[String]
    } derive(Eq, 
    Debug    )

    Unquoted string that may contain substitutions

    UnquotedString::equal

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

    UnquotedString::new

    source

    UnquotedString::not_equal

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

    UnquotedString::to_repr

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

    UnquotedString::to_string

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

    Value

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

    Values that can appear on the right side of a colon

    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::range

    source

    Value::to_repr

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

    board_keywords

    source
    let board_keywords : Array[String]

    Board keywords (create new boards)

    composite_keywords

    source
    let composite_keywords : Array[String]

    Keywords that hold composites

    fill_patterns

    source
    let fill_patterns : Array[String]

    Valid fill patterns

    is_board_keyword

    source
    fn is_board_keyword(s : String) -> Bool

    Check if a string is a board keyword

    is_reserved_keyword

    source
    fn is_reserved_keyword(s : String) -> Bool

    Check if a string is a reserved keyword

    is_style_keyword

    source
    fn is_style_keyword(s : String) -> Bool

    Check if a string is a style keyword

    label_positions

    source
    let label_positions : Array[String]

    Label positions

    near_constants

    source
    let near_constants : Array[String]

    Near constant positions

    simple_reserved_keywords

    source
    let simple_reserved_keywords : Array[String]

    Simple reserved keywords (non-style, non-composite)

    style_keywords

    source
    let style_keywords : Array[String]

    Style keywords (must be inside "style" block)

    text_transforms

    source
    let text_transforms : Array[String]

    Valid text transforms

    tooltip_positions

    source
    let tooltip_positions : Array[String]

    Tooltip positions

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io