🥮 mooncakes.io

    moonrockz/krueger/ast does not have a README file

    Cases

    source
    type Cases = ArrayView[Case]

    Elm.Syntax.Expression.Cases

    Comment

    source
    type Comment = String

    Elm.Syntax.Comments.Comment

    Documentation

    source
    type Documentation = String

    Elm.Syntax.Documentation.Documentation

    ModuleName

    source
    type ModuleName = ArrayView[String]

    Elm.Syntax.ModuleName.ModuleName

    RecordDefinition

    source
    type RecordDefinition = ArrayView[Node[RecordField]]

    Elm.Syntax.TypeAnnotation.RecordDefinition

    DecodeError

    source
    pub(all) suberror DecodeError {
      DecodeError(path~ : String, message~ : String)
    } derive(Eq, 
    Debug    )

    Error raised on malformed input. path is a JSONPath-like location ($ is the value given to the public decoder).
    impl Show for DecodeError

    Case

    source
    pub(all) struct Case {
      pattern : Node[Pattern]
      expression : Node[Expression]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.Case (an Elm tuple ( Node Pattern, Node Expression ))

    CaseBlock

    source
    pub(all) struct CaseBlock {
      expression : Node[Expression]
      cases : ArrayView[Case]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.CaseBlock

    Declaration

    source
    pub(all) enum Declaration {
      FunctionDeclaration(Function)
      AliasDeclaration(TypeAlias)
      CustomTypeDeclaration(Type)
      PortDeclaration(Signature)
      InfixDeclaration(Infix)
      Destructuring(Node[Pattern], Node[Expression])
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Declaration.Declaration

    DefaultModuleData

    source
    pub(all) struct DefaultModuleData {
      module_name : Node[ArrayView[String]]
      exposing_list : Node[Exposing]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Module.DefaultModuleData

    EffectModuleData

    source
    pub(all) struct EffectModuleData {
      module_name : Node[ArrayView[String]]
      exposing_list : Node[Exposing]
      command : Node[String]?
      subscription : Node[String]?
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Module.EffectModuleData

    ExposedType

    source
    pub(all) struct ExposedType {
      name : String
      open : Range?
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Exposing.ExposedType

    Exposing

    source
    pub(all) enum Exposing {
      All(Range)
      Explicit(ArrayView[Node[TopLevelExpose]])
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Exposing.Exposing

    Expression

    source
    pub(all) enum Expression {
      UnitExpr
      Application(ArrayView[Node[Expression]])
      OperatorApplication(String, InfixDirection, Node[Expression], Node[Expression])
      FunctionOrValue(ArrayView[String], String)
      IfBlock(Node[Expression], Node[Expression], Node[Expression])
      PrefixOperator(String)
      Operator(String)
      Integer(Int64)
      Hex(Int64)
      Floatable(Double)
      Negation(Node[Expression])
      Literal(String)
      CharLiteral(Char)
      TupledExpression(ArrayView[Node[Expression]])
      ParenthesizedExpression(Node[Expression])
      LetExpression(LetBlock)
      CaseExpression(CaseBlock)
      LambdaExpression(Lambda)
      RecordExpr(ArrayView[Node[RecordSetter]])
      ListExpr(ArrayView[Node[Expression]])
      RecordAccess(Node[Expression], Node[String])
      RecordAccessFunction(String)
      RecordUpdateExpression(Node[String], ArrayView[Node[RecordSetter]])
      GLSLExpression(String)
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.Expression

    File

    source
    pub(all) struct File {
      module_definition : Node[Module]
      imports : ArrayView[Node[Import]]
      declarations : ArrayView[Node[Declaration]]
      comments : ArrayView[Node[String]]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.File.File

    Function

    source
    pub(all) struct Function {
      documentation : Node[String]?
      signature : Node[Signature]?
      declaration : Node[FunctionImplementation]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.Function

    FunctionImplementation

    source
    pub(all) struct FunctionImplementation {
      name : Node[String]
      arguments : ArrayView[Node[Pattern]]
      expression : Node[Expression]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.FunctionImplementation

    Import

    source
    pub(all) struct Import {
      module_name : Node[ArrayView[String]]
      module_alias : Node[ArrayView[String]]?
      exposing_list : Node[Exposing]?
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Import.Import

    Infix

    source
    pub(all) struct Infix {
      direction : Node[InfixDirection]
      precedence : Node[Int]
      operator : Node[String]
      function : Node[String]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Infix.Infix

    InfixDirection

    source
    pub(all) enum InfixDirection {
      Left
      Right
      Non
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Infix.InfixDirection

    Lambda

    source
    pub(all) struct Lambda {
      args : ArrayView[Node[Pattern]]
      expression : Node[Expression]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.Lambda

    LetBlock

    source
    pub(all) struct LetBlock {
      declarations : ArrayView[Node[LetDeclaration]]
      expression : Node[Expression]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.LetBlock

    LetDeclaration

    source
    pub(all) enum LetDeclaration {
      LetFunction(Function)
      LetDestructuring(Node[Pattern], Node[Expression])
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.LetDeclaration

    Location

    source
    pub(all) struct Location {
      row : Int
      column : Int
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Range.Location: a point in the source. row is the line and column the column, both counted from 1. Columns count code points, so a character outside the BMP (a surrogate pair) is one column.

    Module

    source
    pub(all) enum Module {
      NormalModule(DefaultModuleData)
      PortModule(DefaultModuleData)
      EffectModule(EffectModuleData)
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Module.Module

    Node

    source
    pub(all) struct Node[T] {
      range : Range
      value : T
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Node.Node: a value with its source range. Most parts of the AST are nodes: names, expressions, patterns, type annotations and declarations.

    Pattern

    source
    pub(all) enum Pattern {
      AllPattern
      UnitPattern
      CharPattern(Char)
      StringPattern(String)
      IntPattern(Int64)
      HexPattern(Int64)
      FloatPattern(Double)
      TuplePattern(ArrayView[Node[Pattern]])
      RecordPattern(ArrayView[Node[String]])
      UnConsPattern(Node[Pattern], Node[Pattern])
      ListPattern(ArrayView[Node[Pattern]])
      VarPattern(String)
      NamedPattern(QualifiedNameRef, ArrayView[Node[Pattern]])
      AsPattern(Node[Pattern], Node[String])
      ParenthesizedPattern(Node[Pattern])
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Pattern.Pattern

    QualifiedNameRef

    source
    pub(all) struct QualifiedNameRef {
      module_name : ArrayView[String]
      name : String
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Pattern.QualifiedNameRef

    Range

    source
    pub(all) struct Range {
      start : Location
      end : Location
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Range.Range: the source from start up to end. end is the location just after the last character, so x in column 1 has the range 1:1 to 1:2. elm-syntax writes it as [startRow, startColumn,endRow, endColumn].

    test {
      let source = @scanner.SourceText::new(
        "module Main exposing (..)\n\nname = \"\u{1F600}\" ++ x\n",
      )
      let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
      guard result.ast is Some(file) else { fail("no AST") }
      let decl = file.declarations[0]
      debug_inspect(
        decl.range,
        content="{ start: { row: 3, column: 1 }, end: { row: 3, column: 16 } }",
      )
      inspect(@ast.encode_range(decl.range).stringify(), content="[3,1,3,16]")
    }

    RecordField

    source
    pub(all) struct RecordField {
      name : Node[String]
      type_annotation : Node[TypeAnnotation]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.TypeAnnotation.RecordField (an Elm tuple ( Node String, Node TypeAnnotation ))

    RecordSetter

    source
    pub(all) struct RecordSetter {
      field : Node[String]
      expression : Node[Expression]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Expression.RecordSetter (an Elm tuple ( Node String, Node Expression ))

    Signature

    source
    pub(all) struct Signature {
      name : Node[String]
      type_annotation : Node[TypeAnnotation]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Signature.Signature

    TopLevelExpose

    source
    pub(all) enum TopLevelExpose {
      InfixExpose(String)
      FunctionExpose(String)
      TypeOrAliasExpose(String)
      TypeExpose(ExposedType)
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Exposing.TopLevelExpose

    Type

    source
    pub(all) struct Type {
      documentation : Node[String]?
      name : Node[String]
      generics : ArrayView[Node[String]]
      constructors : ArrayView[Node[ValueConstructor]]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Type.Type

    TypeAlias

    source
    pub(all) struct TypeAlias {
      documentation : Node[String]?
      name : Node[String]
      generics : ArrayView[Node[String]]
      type_annotation : Node[TypeAnnotation]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.TypeAlias.TypeAlias

    TypeAnnotation

    source
    pub(all) enum TypeAnnotation {
      GenericType(String)
      Typed(Node[(ArrayView[String], String)], ArrayView[Node[TypeAnnotation]])
      Unit
      Tupled(ArrayView[Node[TypeAnnotation]])
      Record(ArrayView[Node[RecordField]])
      GenericRecord(Node[String], Node[ArrayView[Node[RecordField]]])
      FunctionTypeAnnotation(Node[TypeAnnotation], Node[TypeAnnotation])
    } derive(Eq, 
    Debug    )

    Elm.Syntax.TypeAnnotation.TypeAnnotation

    ValueConstructor

    source
    pub(all) struct ValueConstructor {
      name : Node[String]
      arguments : ArrayView[Node[TypeAnnotation]]
    } derive(Eq, 
    Debug    )

    Elm.Syntax.Type.ValueConstructor

    decode_declaration

    source
    fn decode_declaration(json : Json) -> Declaration raise DecodeError

    Elm.Syntax.Declaration.decoder.

    decode_exposing

    source
    fn decode_exposing(json : Json) -> Exposing raise DecodeError

    Elm.Syntax.Exposing.decoder.

    decode_expression

    source
    fn decode_expression(json : Json) -> Expression raise DecodeError

    Elm.Syntax.Expression.decoder.

    decode_file

    source
    fn decode_file(json : Json) -> File raise DecodeError

    Elm.Syntax.File.decoder.

    It reads the JSON that elm-syntax 7.3.9 writes, and the JSON from encode_file and encode_file_with. decode_file(encode_file(f)) gives f back, except for Int literals above 2^53 (use exact_ints=true for those). Malformed input raises DecodeError with the JSON path of the problem.

    test {
      let source = @scanner.SourceText::new(
        "module Main exposing (main)\n\nmain =\n    \"hi\"\n",
      )
      let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
      guard result.ast is Some(file) else { fail("no AST") }
      let text = @ast.encode_file(file).stringify()
      let decoded = @ast.decode_file(@json.parse(text))
      inspect(decoded == file, content="true")
      // Malformed input raises an error that names the JSON path.
      try @ast.decode_file({ "imports": [] }) catch {
        e =>
          inspect(
            e,
            content="$: Expecting an OBJECT with a field named `moduleDefinition`",
          )
      } noraise {
        _ => fail("expected a DecodeError")
      }
    }

    decode_function

    source
    fn decode_function(json : Json) -> Function raise DecodeError

    Elm.Syntax.Expression.functionDecoder.

    decode_import

    source
    fn decode_import(json : Json) -> Import raise DecodeError

    Elm.Syntax.Import.decoder.

    decode_infix

    source
    fn decode_infix(json : Json) -> Infix raise DecodeError

    Elm.Syntax.Infix.decoder.

    decode_infix_direction

    source
    fn decode_infix_direction(json : Json) -> InfixDirection raise DecodeError

    Elm.Syntax.Infix.decodeDirection.

    decode_module

    source
    fn decode_module(json : Json) -> Module raise DecodeError

    Elm.Syntax.Module.decoder.

    decode_module_name

    source
    fn decode_module_name(json : Json) -> ArrayView[String] raise DecodeError

    Elm.Syntax.ModuleName.decoder.

    decode_node

    source
    fn[T] decode_node(json : Json, f : (Json) -> T raise DecodeError) -> Node[T] raise DecodeError

    Elm.Syntax.Node.decoder. Errors raised by f get the prefix $.value.

    decode_pattern

    source
    fn decode_pattern(json : Json) -> Pattern raise DecodeError

    Elm.Syntax.Pattern.decoder.

    decode_range

    source
    fn decode_range(json : Json) -> Range raise DecodeError

    Elm.Syntax.Range.decoder.

    decode_signature

    source
    fn decode_signature(json : Json) -> Signature raise DecodeError

    Elm.Syntax.Signature.decoder.

    decode_top_level_expose

    source
    fn decode_top_level_expose(json : Json) -> TopLevelExpose raise DecodeError

    Elm.Syntax.Exposing.topLevelExposeDecoder (the value inside the Node).

    decode_type

    source
    fn decode_type(json : Json) -> Type raise DecodeError

    Elm.Syntax.Type.decoder.

    decode_type_alias

    source
    fn decode_type_alias(json : Json) -> TypeAlias raise DecodeError

    Elm.Syntax.TypeAlias.decoder.

    decode_type_annotation

    source
    fn decode_type_annotation(json : Json) -> TypeAnnotation raise DecodeError

    Elm.Syntax.TypeAnnotation.decoder.

    decode_value_constructor

    source
    fn decode_value_constructor(json : Json) -> ValueConstructor raise DecodeError

    Elm.Syntax.Type.valueConstructorDecoder.

    encode_declaration

    source
    fn encode_declaration(d : Declaration) -> Json

    Elm.Syntax.Declaration.encode.

    encode_declaration_with

    source
    fn encode_declaration_with(d : Declaration, exact_ints~ : Bool) -> Json

    Elm.Syntax.Declaration.encode. With exact_ints, Int literals are written with their exact digits (elm-syntax writes the nearest Double, which differs above 2^53).

    encode_exposing

    source
    fn encode_exposing(e : Exposing) -> Json

    Elm.Syntax.Exposing.encode.

    encode_expression

    source
    fn encode_expression(e : Expression) -> Json

    Elm.Syntax.Expression.encode.

    encode_expression_with

    source
    fn encode_expression_with(e : Expression, exact_ints~ : Bool) -> Json

    Elm.Syntax.Expression.encode. With exact_ints, Int literals are written with their exact digits (elm-syntax writes the nearest Double, which differs above 2^53).

    encode_file

    source
    fn encode_file(file : File) -> Json

    Elm.Syntax.File.encode.

    The JSON is the JSON that elm-syntax 7.3.9 writes for the same file, with the object keys in elm-syntax's order. The parity check compares the two on a corpus of real packages. An Int literal above 2^53 becomes the nearest Double, as in elm-syntax; use encode_file_with(file, exact_ints=true) to keep its digits.

    test {
      let source = @scanner.SourceText::new("module Main exposing (x)\n\nx = 1\n")
      let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
      guard result.ast is Some(file) else { fail("no AST") }
      let json = @ast.encode_file(file)
      guard json is { "declarations": [declaration], .. } else {
        fail("unexpected shape")
      }
      inspect(
        declaration.stringify(),
        content=(
          #|{"range":[3,1,3,6],"value":{"type":"function","function":{"documentation":null,"signature":null,"declaration":{"range":[3,1,3,6],"value":{"name":{"range":[3,1,3,2],"value":"x"},"arguments":[],"expression":{"range":[3,5,3,6],"value":{"type":"integer","integer":1}}}}}}}
        ),
      )
    }

    encode_file_with

    source
    fn encode_file_with(file : File, exact_ints~ : Bool) -> Json

    Elm.Syntax.File.encode. With exact_ints, Int literals are written with their exact digits (elm-syntax writes the nearest Double, which differs above 2^53). With exact_ints=false the result is the same as encode_file.

    test {
      let source = @scanner.SourceText::new(
        "module Main exposing (..)\n\nbig =\n    9007199254740993\n",
      )
      let result = @parser.parse_module(source, @scanner.DefaultScanner::new())
      guard result.ast is Some(file) else { fail("no AST") }
      // elm-syntax writes the nearest Double.
      let nearest = @ast.encode_file(file).stringify()
      inspect(nearest.contains("9007199254740992"), content="true")
      // exact_ints keeps the digits of the literal.
      let exact = @ast.encode_file_with(file, exact_ints=true).stringify()
      inspect(exact.contains("9007199254740993"), content="true")
      // The decoder reads both forms; the exact form gives the literal back.
      inspect(@ast.decode_file(@json.parse(exact)) == file, content="true")
    }

    encode_function

    source
    fn encode_function(f : Function) -> Json

    Elm.Syntax.Expression.encodeFunction.

    encode_function_with

    source
    fn encode_function_with(f : Function, exact_ints~ : Bool) -> Json

    Elm.Syntax.Expression.encodeFunction. With exact_ints, Int literals are written with their exact digits (elm-syntax writes the nearest Double, which differs above 2^53).

    encode_import

    source
    fn encode_import(i : Import) -> Json

    Elm.Syntax.Import.encode.

    encode_infix

    source
    fn encode_infix(i : Infix) -> Json

    Elm.Syntax.Infix.encode.

    encode_infix_direction

    source
    fn encode_infix_direction(d : InfixDirection) -> Json

    Elm.Syntax.Infix.encodeDirection.

    encode_module

    source
    fn encode_module(m : Module) -> Json

    Elm.Syntax.Module.encode.

    encode_module_name

    source
    fn encode_module_name(m : ArrayView[String]) -> Json

    Elm.Syntax.ModuleName.encode.

    encode_node

    source
    fn[T] encode_node(n : Node[T], f : (T) -> Json) -> Json

    Elm.Syntax.Node.encode: {"range": ..., "value": ...}.

    encode_pattern

    source
    fn encode_pattern(p : Pattern) -> Json

    Elm.Syntax.Pattern.encode.

    encode_pattern_with

    source
    fn encode_pattern_with(p : Pattern, exact_ints~ : Bool) -> Json

    Elm.Syntax.Pattern.encode. With exact_ints, Int literals are written with their exact digits (elm-syntax writes the nearest Double, which differs above 2^53).

    encode_range

    source
    fn encode_range(r : Range) -> Json

    Elm.Syntax.Range.encode: [startRow, startColumn, endRow, endColumn].

    encode_signature

    source
    fn encode_signature(s : Signature) -> Json

    Elm.Syntax.Signature.encode.

    encode_top_level_expose

    source
    fn encode_top_level_expose(t : TopLevelExpose) -> Json

    Elm.Syntax.Exposing.encodeTopLevelExpose (without the Node wrapper).

    encode_type

    source
    fn encode_type(t : Type) -> Json

    Elm.Syntax.Type.encode.

    encode_type_alias

    source
    fn encode_type_alias(a : TypeAlias) -> Json

    Elm.Syntax.TypeAlias.encode.

    encode_type_annotation

    source
    fn encode_type_annotation(t : TypeAnnotation) -> Json

    Elm.Syntax.TypeAnnotation.encode.

    encode_value_constructor

    source
    fn encode_value_constructor(c : ValueConstructor) -> Json

    Elm.Syntax.Type.encodeValueConstructor.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io