omcg/module

Types

BinaryOperationNS

pub type BinaryOperationNS {
  BinaryOperationNS(
    create: fn(Module, Operator, Module) -> Module,
    access: fn(Module, Module) -> Module,
    pipe: fn(Module, Module) -> Module,
    string_concat: fn(Module, Module) -> Module,
  )
}

Constructors

BinaryOperationNS(
  create: fn(Module, Operator, Module) -> Module,
  access: fn(Module, Module) -> Module,
  pipe: fn(Module, Module) -> Module,
  string_concat: fn(Module, Module) -> Module,
)

BuiltinTypesNS

</>

pub type BuiltinTypesNS {
  BuiltinTypesNS(
    string: fn() -> Module,
    int: fn() -> Module,
    float: fn() -> Module,
  )
}

Constructors

BuiltinTypesNS(
  string: fn() -> Module,
  int: fn() -> Module,
  float: fn() -> Module,
)

CaseBranchData

</>

pub type CaseBranchData {
  CaseBranchData(
    expression: Node,
    guard: option.Option(Node),
    body: List(Node),
  )
}

Constructors

CaseBranchData(
  expression: Node,
  guard: option.Option(Node),
  body: List(Node),
)

CaseBranchNS

</>

pub type CaseBranchNS {
  CaseBranchNS(
    create: fn(Module) -> Module,
    create_default: fn() -> Module,
    add: fn(Module, Module) -> Module,
  )
}

Constructors

CaseBranchNS(
  create: fn(Module) -> Module,
  create_default: fn() -> Module,
  add: fn(Module, Module) -> Module,
)

CaseExpressionNS

</>

pub type CaseExpressionNS {
  CaseExpressionNS(
    create: fn(Module) -> Module,
    add: fn(Module, Module) -> Module,
  )
}

Constructors

CaseExpressionNS(
  create: fn(Module) -> Module,
  add: fn(Module, Module) -> Module,
)

ConstDefinitionNS

</>

pub type ConstDefinitionNS {
  ConstDefinitionNS(
    create: fn(String, Module) -> Module,
    public: fn(Module) -> Module,
    as_type: fn(Module) -> Module,
  )
}

Constructors

ConstDefinitionNS(
  create: fn(String, Module) -> Module,
  public: fn(Module) -> Module,
  as_type: fn(Module) -> Module,
)

Field

</>

pub type Field {
  Field(name: option.Option(String), type_: Node)
}

Constructors

Field(name: option.Option(String), type_: Node)

FunctionCallNS

</>

pub type FunctionCallNS {
  FunctionCallNS(
    create: fn(Module) -> Module,
    add: fn(Module, Module) -> Module,
    add_with_alias: fn(Module, String, Module) -> Module,
  )
}

Constructors

FunctionCallNS(
  create: fn(Module) -> Module,
  add: fn(Module, Module) -> Module,
  add_with_alias: fn(Module, String, Module) -> Module,
)

FunctionCallParameter

</>

pub type FunctionCallParameter {
  FunctionCallParameter(
    alias: option.Option(String),
    value: Node,
  )
}

Constructors

FunctionCallParameter(alias: option.Option(String), value: Node)

FunctionDefinitionNS

</>

pub type FunctionDefinitionNS {
  FunctionDefinitionNS(
    create: fn() -> Module,
    public: fn(Module) -> Module,
    with_name: fn(Module, String) -> Module,
    add_parameter: fn(Module, String, Module) -> Module,
    add_untyped_parameter: fn(Module, String) -> Module,
    add_aliased_parameter: fn(Module, String, String, Module) -> Module,
    with_return_type: fn(Module, Module) -> Module,
    add: fn(Module, Module) -> Module,
  )
}

Constructors

FunctionDefinitionNS(
  create: fn() -> Module,
  public: fn(Module) -> Module,
  with_name: fn(Module, String) -> Module,
  add_parameter: fn(Module, String, Module) -> Module,
  add_untyped_parameter: fn(Module, String) -> Module,
  add_aliased_parameter: fn(Module, String, String, Module) -> Module,
  with_return_type: fn(Module, Module) -> Module,
  add: fn(Module, Module) -> Module,
)

FunctionDefinitionParameter

</>

pub type FunctionDefinitionParameter {
  FunctionDefinitionParameter(
    alias: option.Option(String),
    name: String,
    type_: option.Option(Node),
  )
}

Constructors

FunctionDefinitionParameter(
  alias: option.Option(String),
  name: String,
  type_: option.Option(Node),
)

IdentifierNS

</>

pub type IdentifierNS {
  IdentifierNS(create: fn(String) -> Module, discard: Module)
}

Constructors

IdentifierNS(create: fn(String) -> Module, discard: Module)

Import

</>

pub type Import {
  Import(
    path: List(String),
    items: List(ImportItem),
    alias: option.Option(String),
  )
}

Constructors

Import(
  path: List(String),
  items: List(ImportItem),
  alias: option.Option(String),
)

ImportItem

</>

pub type ImportItem {
  ImportType(name: String, alias: option.Option(String))
  ImportItem(name: String, alias: option.Option(String))
}

Constructors

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

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

LetDefinitionNS

</>

pub type LetDefinitionNS {
  LetDefinitionNS(
    create: fn(Module, Module) -> Module,
    type_: fn(Module, Module) -> Module,
  )
}

Constructors

LetDefinitionNS(
  create: fn(Module, Module) -> Module,
  type_: fn(Module, Module) -> Module,
)

Literal

</>

pub type Literal {
  String(value: String)
  Int(value: Int)
  Float(value: Float)
  Bool(value: Bool)
  Tuple(value: List(Node))
  List(value: List(Node))
}

Constructors

```
String(value: String)
```
```
Int(value: Int)
```
```
Float(value: Float)
```
```
Bool(value: Bool)
```
```
Tuple(value: List(Node))
```
```
List(value: List(Node))
```

LiteralNS

</>

pub type LiteralNS {
  LiteralNS(
    string: fn(String) -> Module,
    int: fn(Int) -> Module,
    float: fn(Float) -> Module,
    bool: fn(Bool) -> Module,
    tuple: fn(List(Module)) -> Module,
    nested_tuple: fn(List(Module)) -> Module,
    list: fn(List(Module)) -> Module,
    nil: Module,
  )
}

Constructors

LiteralNS(
  string: fn(String) -> Module,
  int: fn(Int) -> Module,
  float: fn(Float) -> Module,
  bool: fn(Bool) -> Module,
  tuple: fn(List(Module)) -> Module,
  nested_tuple: fn(List(Module)) -> Module,
  list: fn(List(Module)) -> Module,
  nil: Module,
)

Module

</>

pub type Module {
  Module(node: Node, imports: List(Import))
}

Constructors

Module(node: Node, imports: List(Import))

Node

</>

pub type Node {
  Root(body: List(Node))
  FunctionDefinition(
    public: Bool,
    name: option.Option(String),
    parameters: List(FunctionDefinitionParameter),
    return_type: option.Option(Node),
    body: List(Node),
  )
  BinaryOperation(lhs: Node, operator: Operator, rhs: Node)
  Identifier(name: String)
  FunctionCall(
    lhs: Node,
    parameters: List(FunctionCallParameter),
  )
  TypeVariant(data: TypeVariantData)
  TypeDefinition(
    public: Bool,
    name: String,
    generics: List(String),
    variants: List(TypeVariantData),
  )
  ConstDefinition(
    public: Bool,
    as_type: Bool,
    name: String,
    value: Node,
  )
  CaseBranch(data: CaseBranchData)
  CaseExpression(
    expression: Node,
    branches: List(CaseBranchData),
  )
  UseExpression(parameters: List(String), rhs: Node)
  Literal(literal: Literal)
  SectionComment(comment: String)
  LetDefinition(
    pattern: Node,
    type_: option.Option(Node),
    value: Node,
  )
}

Constructors

```
Root(body: List(Node))
```

FunctionDefinition(
  public: Bool,
  name: option.Option(String),
  parameters: List(FunctionDefinitionParameter),
  return_type: option.Option(Node),
  body: List(Node),
)

BinaryOperation(lhs: Node, operator: Operator, rhs: Node)

```
Identifier(name: String)
```

FunctionCall(lhs: Node, parameters: List(FunctionCallParameter))

```
TypeVariant(data: TypeVariantData)
```

TypeDefinition(
  public: Bool,
  name: String,
  generics: List(String),
  variants: List(TypeVariantData),
)

ConstDefinition(
  public: Bool,
  as_type: Bool,
  name: String,
  value: Node,
)

```
CaseBranch(data: CaseBranchData)
```

CaseExpression(expression: Node, branches: List(CaseBranchData))

UseExpression(parameters: List(String), rhs: Node)

```
Literal(literal: Literal)
```
```
SectionComment(comment: String)
```

LetDefinition(
  pattern: Node,
  type_: option.Option(Node),
  value: Node,
)

Operator

</>

pub type Operator {
  Access
  Add
  Subtract
  Multiply
  Divide
  FloatAdd
  FloatSubtract
  FloatDivide
  FloatMultiply
  StringConcat
  Pipe
}

Constructors

```
Access
```
```
Add
```
```
Subtract
```
```
Multiply
```
```
Divide
```
```
FloatAdd
```
```
FloatSubtract
```
```
FloatDivide
```
```
FloatMultiply
```
```
StringConcat
```
```
Pipe
```

RootNS

</>

pub type RootNS {
  RootNS(
    create: fn() -> Module,
    add: fn(Module, Module) -> Module,
  )
}

Constructors

RootNS(create: fn() -> Module, add: fn(Module, Module) -> Module)

TypeDefinitionNS

</>

pub type TypeDefinitionNS {
  TypeDefinitionNS(
    create: fn(String) -> Module,
    public: fn(Module) -> Module,
    add: fn(Module, Module) -> Module,
  )
}

Constructors

TypeDefinitionNS(
  create: fn(String) -> Module,
  public: fn(Module) -> Module,
  add: fn(Module, Module) -> Module,
)

TypeVariantData

</>

pub type TypeVariantData {
  TypeVariantData(name: String, fields: List(Field))
}

Constructors

TypeVariantData(name: String, fields: List(Field))

TypeVariantNS

</>

pub type TypeVariantNS {
  TypeVariantNS(
    create: fn(String) -> Module,
    field: fn(Module, option.Option(String), Module) -> Module,
  )
}

Constructors

TypeVariantNS(
  create: fn(String) -> Module,
  field: fn(Module, option.Option(String), Module) -> Module,
)

UseExpressionNS

</>

pub type UseExpressionNS {
  UseExpressionNS(
    create: fn(Module) -> Module,
    add: fn(Module, String) -> Module,
  )
}

Constructors

UseExpressionNS(
  create: fn(Module) -> Module,
  add: fn(Module, String) -> Module,
)

Values

add_aliased_import

</>

pub fn add_aliased_import(
  module module: Module,
  path path: List(String),
  alias alias: String,
) -> Module

add_aliased_item_import

</>

pub fn add_aliased_item_import(
  module module: Module,
  path path: List(String),
  name name: String,
  alias alias: String,
) -> Module

add_aliased_type_import

</>

pub fn add_aliased_type_import(
  module module: Module,
  path path: List(String),
  name name: String,
  alias alias: String,
) -> Module

add_import

</>

pub fn add_import(
  module module: Module,
  path path: List(String),
) -> Module

add_item_import

</>

pub fn add_item_import(
  module module: Module,
  path path: List(String),
  name name: String,
) -> Module

add_type_import

</>

pub fn add_type_import(
  module module: Module,
  path path: List(String),
  name name: String,
) -> Module

binop

</>

pub const binop: BinaryOperationNS

case_branch

</>

pub const case_branch: CaseBranchNS

case_expression

</>

pub const case_expression: CaseExpressionNS

const_definition

</>

pub const const_definition: ConstDefinitionNS

function_call

</>

pub const function_call: FunctionCallNS

function_definition

</>

pub const function_definition: FunctionDefinitionNS

identifier

</>

pub const identifier: IdentifierNS

let_definition

</>

pub const let_definition: LetDefinitionNS

literal

</>

pub const literal: LiteralNS

merge_imports

</>

pub fn merge_imports(a: Module, b: Module) -> Module

node_to_string

</>

pub fn node_to_string(node: Node, indent: Int) -> String

root

</>

pub const root: RootNS

section_comment

</>

pub fn section_comment(comment: String) -> Module

temptest

</>

pub fn temptest() -> Module

to_string

</>

pub fn to_string(module: Module) -> String

to_string2

</>

pub fn to_string2(module: Module) -> String

type_definition

</>

pub const type_definition: TypeDefinitionNS

type_variant

</>

pub const type_variant: TypeVariantNS

types

</>

pub const types: BuiltinTypesNS

use_expression

</>

pub const use_expression: UseExpressionNS