TypedStruct is a library for defining structs with a type without writing boilerplate code.
To define a struct in Elixir, you probably want to define three things:
- the struct itself, with default values,
- the list of enforced keys,
- its associated type.
It ends up in something like this:
defmodule Person do
@moduledoc """
A struct representing a person.
"""
@enforce_keys [:name]
defstruct name: nil,
age: nil,
happy?: true,
phone: nil
@typedoc "A person"
@type t() :: %__MODULE__{
name: String.t(),
age: non_neg_integer() | nil,
happy?: boolean(),
phone: String.t() | nil
}
endIn the example above you can notice several points:
- the keys are present in both the
defstructand type definition, - enforced keys must also be written in
@enforce_keys, - if a key has no default value and is not enforced, its type should be nullable.
If you want to add a field in the struct, you must therefore:
- add the key with its default value in the
defstructlist, - add the key with its type in the type definition.
If the field is not optional, you should even add it to @enforce_keys. This is
way too much work for lazy people like me, and moreover it can be error-prone.
It would be way better if we could write something like this:
defmodule Person do
@moduledoc """
A struct representing a person.
"""
use TypedStruct
typedstruct do
@typedoc "A person"
field :name, String.t(), enforce: true
field :age, non_neg_integer()
field :happy?, boolean(), default: true
field :phone, String.t(), doc: "strictly the home number"
end
endThanks to TypedStruct, this is now possible :)
To use TypedStruct in your project, add this to your Mix dependencies:
{:typed_struct, "~> 0.3.0"}If you do not plan to compile modules using TypedStruct at runtime, you can add
runtime: false to the dependency tuple as TypedStruct is only used at build
time.
If you want to avoid mix format putting parentheses on field definitions,
you can add to your .formatter.exs:
[
...,
import_deps: [:typed_struct]
]To define a typed struct, use
TypedStruct, then define
your struct within a typedstruct block:
defmodule MyStruct do
# Use TypedStruct to import the typedstruct macro.
use TypedStruct
# Define your struct.
typedstruct do
# Define each field with the field macro.
field :a_string, String.t()
# You can set a default value.
field :string_with_default, String.t(), default: "default"
# You can enforce a field.
field :enforced_field, integer(), enforce: true
# Define each field with the field macro.
field :a_field_thats_purpose_is_not_obvious, String.t(), doc: "some explanation about this field"
end
endEach field is defined through the
field/2 macro.
If you want to enforce all the keys by default, you can do:
defmodule MyStruct do
use TypedStruct
# Enforce keys by default.
typedstruct enforce: true do
# This key is enforced.
field :enforced_by_default, term()
# You can override the default behaviour.
field :not_enforced, term(), enforce: false
# A key with a default value is not enforced.
field :not_enforced_either, integer(), default: 1
end
endYou can also generate an opaque type for the struct:
defmodule MyOpaqueStruct do
use TypedStruct
# Generate an opaque type for the struct.
typedstruct opaque: true do
field :name, String.t()
end
endIf you often define submodules containing only a struct, you can avoid boilerplate code:
defmodule MyModule do
use TypedStruct
# You now have %MyModule.Struct{}.
typedstruct module: Struct do
field :field, term()
end
endTo add a @typedoc to the struct type, just add the attribute in the
typedstruct block:
typedstruct do
@typedoc "A typed struct"
field :a_string, String.t()
field :an_int, integer()
endYou can also add documentation to individual fields:
typedstruct do
@typedoc "A typed struct"
field :a_string, String.t(), doc: "this is just a series of letters"
field :an_int, integer(), doc: "some explanation"
endAs an added benefit, the above will generate a typedoc as below:
@typedoc """
A typed struct
- `a_string`: this is just a series of letters
- `an_int`: some explanation
"""This works without the @typedoc ... declaration,
with the following result:
@typedoc """
- `a_string`: this is just a series of letters
- `an_int`: some explanation
"""You can also document submodules this way:
typedstruct module: MyStruct do
@moduledoc "A submodule with a typed struct."
@typedoc "A typed struct in a submodule"
field :a_string, String.t()
field :an_int, integer()
endIt is possible to extend the scope of TypedStruct by using its plugin interface,
as described in
TypedStruct.Plugin.
For instance, to automatically generate lenses with the
Lens library, you can use
TypedStructLens and do:
defmodule MyStruct do
use TypedStruct
typedstruct do
plugin TypedStructLens
field :a_field, String.t()
field :other_field, atom()
end
@spec change(t()) :: t()
def change(data) do
# a_field/0 is generated by TypedStructLens.
lens = a_field()
put_in(data, [lens], "Changed")
end
endtyped_struct_lens– Integration with the Lens library.typed_struct_legacy_reflection– Re-enables the legacy reflection functions from TypedStruct 0.1.x.
This list is not meant to be exhaustive, please search for “typed_struct” on hex.pm for other results. If you want your plugin to appear here, please open an issue.
When defining an empty typedstruct block:
defmodule Example do
use TypedStruct
typedstruct do
end
endyou get an empty struct with its module type t():
defmodule Example do
@enforce_keys []
defstruct []
@type t() :: %__MODULE__{}
endEach field call adds information to the struct, @enforce_keys and the type
t().
A field with no options adds the name to the defstruct list, with nil as
default. The type itself is made nullable:
defmodule Example do
use TypedStruct
typedstruct do
field :name, String.t()
end
endbecomes:
defmodule Example do
@enforce_keys []
defstruct name: nil
@type t() :: %__MODULE__{
name: String.t() | nil
}
endThe default option adds the default value to the defstruct:
field :name, String.t(), default: "John Smith"
# Becomes
defstruct name: "John Smith"When set to true, the enforce option enforces the key by adding it to the
@enforce_keys attribute.
field :name, String.t(), enforce: true
# Becomes
@enforce_keys [:name]
defstruct name: nilIn both cases, the type has no reason to be nullable anymore by default. In one
case the field is filled with its default value and not nil, and in the other
case it is enforced. Both options would generate the following type:
@type t() :: %__MODULE__{
name: String.t() # Not nullable
}Passing opaque: true replaces @type with @opaque in the struct type
specification:
typedstruct opaque: true do
field :name, String.t()
endgenerates the following type:
@opaque t() :: %__MODULE__{
name: String.t()
}When passing module: ModuleName, the whole typedstruct block is wrapped in a
module definition. This way, the following definition:
defmodule MyModule do
use TypedStruct
typedstruct module: Struct do
field :field, term()
end
endbecomes:
defmodule MyModule do
defmodule Struct do
@enforce_keys []
defstruct field: nil
@type t() :: %__MODULE__{
field: term() | nil
}
end
end- Struct definition
- Type definition (with nullable types)
- Default values
- Enforced keys (non-nullable types)
- Plugin API
- Default value type-checking (is it possible?)
- Guard generation
- Integration with Lens
- Integration with Ecto
- Domo: a library to validate structs that
define a
t()type, like the one generated byTypedStruct. - TypedEctoSchema: a library
that provides a DSL on top of
Ecto.Schemato achieve the same result asTypedStruct, withEcto.
Before contributing to this project, please read the CONTRIBUTING.md.
Copyright © 2018-2022 Jean-Philippe Cugnet and Contributors
This project is licensed under the MIT license.