gen_gleam/modules

Types

Import

pub type Import {
  Import(
    module: String,
    types: List(TypeDef),
    functions: List(NamedFunction),
  )
}

Constructors

Import(
  module: String,
  types: List(TypeDef),
  functions: List(NamedFunction),
)

Module

</>

pub type Module =
  List(RootStatement)

Modules

</>

pub type Modules =
  Dict(String, Module)

RootStatement

</>

pub type RootStatement {
  ImportRoot(Import)
  TypeRoot(TypeDef)
  FunctionRoot(NamedFunction)
}

Constructors

```
ImportRoot(Import)
```
```
TypeRoot(TypeDef)
```
```
FunctionRoot(NamedFunction)
```

Functions

function_root

</>

pub fn function_root(
  name: String,
  arguments: List(Argument),
  return_type: Option(GleamType),
  statements: List(GleamStatement),
) -> RootStatement

generate_function_def

</>

pub fn generate_function_def(
  function_def: NamedFunction,
) -> String

generate_import_def

</>

pub fn generate_import_def(import_: Import) -> String

generate_package

</>

pub fn generate_package(
  modules: Dict(String, List(RootStatement)),
  directory: String,
) -> Nil

generate_root

</>

pub fn generate_root(root: RootStatement) -> String

import_root

</>

pub fn import_root(import_: Import) -> RootStatement

import_statement

</>

pub fn import_statement(
  modules: Dict(String, List(RootStatement)),
  module_name: String,
  types: List(String),
  functions: List(String),
) -> Result(#(Import, List(TypeDef), List(NamedFunction)), Nil)

module

</>

pub fn module(
  modules: Dict(String, List(RootStatement)),
  name: String,
  module: List(RootStatement),
) -> Dict(String, List(RootStatement))

type_root

</>

pub fn type_root(type_def: TypeDef) -> RootStatement