gen_gleam/types

Provides built-in Gleam types. Provides means to define Gleam types (e.g. variant_type) and generate Gleam code for those (generate_type_def).

Types

Field

</>

pub type Field {
  Field(name: String, field_type: GleamType)
}

Constructors

Field(name: String, field_type: GleamType)

GleamType

</>

pub type GleamType {
  AnonymousType(String)
  NilType
  IntType
  ListType(list_type: GleamType)
  TypeDefType(type_def: TypeDef)
  FunctionType(
    argument_types: List(GleamType),
    result_type: GleamType,
  )
}

Constructors

```
AnonymousType(String)
```
```
NilType
```
```
IntType
```
```
ListType(list_type: GleamType)
```
```
TypeDefType(type_def: TypeDef)
```

FunctionType(
  argument_types: List(GleamType),
  result_type: GleamType,
)

TypeDef

</>

pub type TypeDef {
  VariantType(
    name: String,
    dep_types: List(GleamType),
    variants: List(Variant),
  )
}

Constructors

VariantType(
  name: String,
  dep_types: List(GleamType),
  variants: List(Variant),
)

Variant

</>

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

Constructors

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

Functions

anonymous

</>

pub fn anonymous(name: String) -> GleamType

dep_type

</>

pub fn dep_type(
  type_def: TypeDef,
  actual_types: List(GleamType),
) -> GleamType

dep_type_def

</>

pub fn dep_type_def(
  name: String,
  dep_types: List(GleamType),
  variants: List(Variant),
) -> TypeDef

Returns the TypeDef that you can pass to generate_type_def. If you want the type, use variant_dep_type instead.

field

</>

pub fn field(name: String, field_type: GleamType) -> Field

function

</>

pub fn function(
  argument_types: List(GleamType),
  result_type: GleamType,
) -> GleamType

generate_type

</>

pub fn generate_type(arg_type: GleamType) -> String

Generate the type when using the argument. To be used when you annotate any pattern matching. It is possible this will be done automatically from the statement, in some future version.

generate_type_def

</>

pub fn generate_type_def(type_def: TypeDef) -> String

This is a root-statement

int

</>

pub fn int() -> GleamType

list

</>

pub fn list(item_type: GleamType) -> GleamType

nil

</>

pub fn nil() -> GleamType

type_def

</>

pub fn type_def(name: String, variants: List(Variant)) -> TypeDef

Returns the TypeDef that you can pass to generate_type_def. If you want the type, use variant_type instead.

type_from

</>

pub fn type_from(type_def: TypeDef) -> GleamType

variant

</>

pub fn variant(name: String, fields: List(Field)) -> Variant

variant_dep_type

</>

pub fn variant_dep_type(
  name: String,
  dep_types: List(GleamType),
  variants: List(Variant),
) -> GleamType

For a type definition, the additional types are wildcards

let a = anonymous("a")
variant_dep_type("MyType", [a], [
  variant("ListOfIt", [field("the_list", list(a))])
])
|> generate_type_def

For usage, the additional types are concrete

let t = Int
variant_dep_type("MyType", [t], [
  variant("ListOfIt", [field("the_list", list(t))])
])
|> generate_type

variant_type

</>

pub fn variant_type(
  name: String,
  variants: List(Variant),
) -> GleamType

variant_type("MyType", [
  variant("Bare", []).
  variant("WithField", [field("number", int())])
])