🥮 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

    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

    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

    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.

    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.

    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).

    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