Let

LetAssert(message: option.Option(Expression))

Named(String)

Discarded(String)

Attribute(name: String, arguments: List(Expression))

And

Or

Eq

NotEq

LtInt

LtEqInt

LtFloat

LtEqFloat

GtEqInt

GtInt

GtEqFloat

GtFloat

Pipe

AddInt

AddFloat

SubInt

SubFloat

MultInt

MultFloat

DivInt

DivFloat

RemainderInt

Concatenate

BytesOption

IntOption

FloatOption

BitsOption

Utf8Option

Utf16Option

Utf32Option

Utf8CodepointOption

Utf16CodepointOption

Utf32CodepointOption

SignedOption

UnsignedOption

BigOption

LittleOption

NativeOption

SizeValueOption(t)

SizeOption(Int)

UnitOption(Int)

Clause(
  patterns: List(List(Pattern)),
  guard: option.Option(Expression),
  body: Expression,
)

Constant(
  location: Span,
  name: String,
  publicity: Publicity,
  annotation: option.Option(Type),
  value: Expression,
)

CustomType(
  location: Span,
  name: String,
  publicity: Publicity,
  opaque_: Bool,
  parameters: List(String),
  variants: List(Variant),
)

Definition(attributes: List(Attribute), definition: definition)

UnexpectedEndOfInput

UnexpectedToken(token: token.Token, position: glexer.Position)

Int(location: Span, value: String)

Float(location: Span, value: String)

String(location: Span, value: String)

Variable(location: Span, name: String)

NegateInt(location: Span, value: Expression)

NegateBool(location: Span, value: Expression)

Block(location: Span, statements: List(Statement))

Panic(location: Span, message: option.Option(Expression))

Todo(location: Span, message: option.Option(Expression))

Tuple(location: Span, elements: List(Expression))

List(
  location: Span,
  elements: List(Expression),
  rest: option.Option(Expression),
)

Fn(
  location: Span,
  arguments: List(FnParameter),
  return_annotation: option.Option(Type),
  body: List(Statement),
)

RecordUpdate(
  location: Span,
  module: option.Option(String),
  constructor: String,
  record: Expression,
  fields: List(RecordUpdateField(Expression)),
)

FieldAccess(location: Span, container: Expression, label: String)

Call(
  location: Span,
  function: Expression,
  arguments: List(Field(Expression)),
)

TupleIndex(location: Span, tuple: Expression, index: Int)

FnCapture(
  location: Span,
  label: option.Option(String),
  function: Expression,
  arguments_before: List(Field(Expression)),
  arguments_after: List(Field(Expression)),
)

BitString(
  location: Span,
  segments: List(
    #(Expression, List(BitStringSegmentOption(Expression))),
  ),
)

Case(
  location: Span,
  subjects: List(Expression),
  clauses: List(Clause),
)

BinaryOperator(
  location: Span,
  name: BinaryOperator,
  left: Expression,
  right: Expression,
)

Echo(location: Span, expression: option.Option(Expression))

LabelledField(label: String, item: t)

ShorthandField(label: String)

UnlabelledField(item: t)

FnParameter(name: AssignmentName, type_: option.Option(Type))

Function(
  location: Span,
  name: String,
  publicity: Publicity,
  parameters: List(FunctionParameter),
  return: option.Option(Type),
  body: List(Statement),
)

FunctionParameter(
  label: option.Option(String),
  name: AssignmentName,
  type_: option.Option(Type),
)

Import(
  location: Span,
  module: String,
  alias: option.Option(AssignmentName),
  unqualified_types: List(UnqualifiedImport),
  unqualified_values: List(UnqualifiedImport),
)

Module(
  imports: List(Definition(Import)),
  custom_types: List(Definition(CustomType)),
  type_aliases: List(Definition(TypeAlias)),
  constants: List(Definition(Constant)),
  functions: List(Definition(Function)),
)

PatternInt(location: Span, value: String)

PatternFloat(location: Span, value: String)

PatternString(location: Span, value: String)

PatternDiscard(location: Span, name: String)

PatternVariable(location: Span, name: String)

PatternTuple(location: Span, elements: List(Pattern))

PatternList(
  location: Span,
  elements: List(Pattern),
  tail: option.Option(Pattern),
)

PatternAssignment(location: Span, attern: Pattern, name: String)

PatternConcatenate(
  location: Span,
  prefix: String,
  prefix_name: option.Option(AssignmentName),
  rest_name: AssignmentName,
)

PatternBitString(
  location: Span,
  segments: List(
    #(Pattern, List(BitStringSegmentOption(Pattern))),
  ),
)

PatternVariant(
  location: Span,
  module: option.Option(String),
  constructor: String,
  arguments: List(Field(Pattern)),
  with_spread: Bool,
)

Public

Private

RecordUpdateField(label: String, item: option.Option(t))

Span(start: Int, end: Int)

Use(
  location: Span,
  patterns: List(UsePattern),
  function: Expression,
)

Assignment(
  location: Span,
  kind: AssignmentKind,
  pattern: Pattern,
  annotation: option.Option(Type),
  value: Expression,
)

Assert(
  location: Span,
  expression: Expression,
  message: option.Option(Expression),
)

Expression(Expression)

NamedType(
  location: Span,
  name: String,
  module: option.Option(String),
  parameters: List(Type),
)

TupleType(location: Span, elements: List(Type))

FunctionType(
  location: Span,
  parameters: List(Type),
  return: Type,
)

VariableType(location: Span, name: String)

HoleType(location: Span, name: String)

TypeAlias(
  location: Span,
  name: String,
  publicity: Publicity,
  parameters: List(String),
  aliased: Type,
)

UnqualifiedImport(name: String, alias: option.Option(String))

UsePattern(pattern: Pattern, annotation: option.Option(Type))

Variant(
  name: String,
  fields: List(VariantField),
  attributes: List(Attribute),
)

LabelledVariantField(item: Type, label: String)

UnlabelledVariantField(item: Type)