Boolean "and" operator.

Provides a short-circuit operator that evaluates and returns the second expression only if the first one evaluates to a truthy value (neither false nor nil). Returns the first expression otherwise.

Not allowed in guard clauses.

Examples

iex> Enum.empty?([]) && Enum.empty?([])
true

iex> List.first([]) && true
nil

iex> Enum.empty?([]) && List.first([1])
1

iex> false && throw(:bad)
false

Note that, unlike and/2, this operator accepts any expression as the first argument, not only booleans.

@spec integer() ** non_neg_integer() :: integer()

@spec integer() ** neg_integer() :: float()

@spec float() ** float() :: float()

Power operator.

It expects two numbers are input. If the left-hand side is an integer and the right-hand side is more than or equal to 0, then the result is integer. Otherwise it returns a float.

Examples

iex> 2 ** 2
4
iex> 2 ** -4
0.0625

iex> 2.0 ** 2
4.0
iex> 2 ** 2.0
4.0

@spec list() ++ term() :: maybe_improper_list()

List concatenation operator. Concatenates a proper list and a term, returning a list.

The complexity of a ++ b is proportional to length(a), so avoid repeatedly appending to lists of arbitrary length, for example, list ++ [element]. Instead, consider prepending via [element | rest] and then reversing.

If the right operand is not a proper list, it returns an improper list. If the left operand is not a proper list, it raises ArgumentError.

Inlined by the compiler.

Examples

iex> [1] ++ [2, 3]
[1, 2, 3]

iex> 'foo' ++ 'bar'
'foobar'

# returns an improper list
iex> [1] ++ 2
[1 | 2]

# returns a proper list
iex> [1] ++ [2]
[1, 2]

# improper list on the right will return an improper list
iex> [1] ++ [2 | 3]
[1, 2 | 3]

@spec list() -- list() :: list()

List subtraction operator. Removes the first occurrence of an element on the left list for each element on the right.

This function is optimized so the complexity of a -- b is proportional to length(a) * log(length(b)). See also the Erlang efficiency guide.

Inlined by the compiler.

Examples

iex> [1, 2, 3] -- [1, 2]
[3]

iex> [1, 2, 3, 2, 1] -- [1, 2, 2]
[3, 1]

The --/2 operator is right associative, meaning:

iex> [1, 2, 3] -- [2] -- [3]
[1, 3]

As it is equivalent to:

iex> [1, 2, 3] -- ([2] -- [3])
[1, 3]

Creates the full-slice range 0..-1//1.

This macro returns a range with the following properties:

• When enumerated, it is empty

• When used as a slice, it returns the sliced element as is

See ..///3 and the Range module for more information.

Examples

iex> Enum.to_list(..)
[]

iex> String.slice("Hello world!", ..)
"Hello world!"

Creates a range from first to last.

If first is less than last, the range will be increasing from first to last. If first is equal to last, the range will contain one element, which is the number itself.

If first is more than last, the range will be decreasing from first to last, albeit this behaviour is deprecated. Instead prefer to explicitly list the step with first..last//-1.

See the Range module for more information.

Examples

iex> 0 in 1..3
false
iex> 2 in 1..3
true

iex> Enum.to_list(1..3)
[1, 2, 3]

Creates a range from first to last with step.

See the Range module for more information.

Examples

iex> 0 in 1..3//1
false
iex> 2 in 1..3//1
true
iex> 2 in 1..3//2
false

iex> Enum.to_list(1..3//1)
[1, 2, 3]
iex> Enum.to_list(1..3//2)
[1, 3]
iex> Enum.to_list(3..1//-1)
[3, 2, 1]
iex> Enum.to_list(1..0//1)
[]

Boolean "not" operator.

Receives any value (not just booleans) and returns true if value is false or nil; returns false otherwise.

Not allowed in guard clauses.

Examples

iex> !Enum.empty?([])
false

iex> !List.first([])
true

Binary concatenation operator. Concatenates two binaries.

Raises an ArgumentError if one of the sides aren't binaries.

Examples

iex> "foo" <> "bar"
"foobar"

The <>/2 operator can also be used in pattern matching (and guard clauses) as long as the left argument is a literal binary:

iex> "foo" <> x = "foobar"
iex> x
"bar"

x <> "bar" = "foobar" would result in an ArgumentError exception.

@spec String.t() =~ (String.t() | Regex.t()) :: boolean()

Text-based match operator. Matches the term on the left against the regular expression or string on the right.

If right is a regular expression, returns true if left matches right.

If right is a string, returns true if left contains right.

Examples

iex> "abcd" =~ ~r/c(d)/
true

iex> "abcd" =~ ~r/e/
false

iex> "abcd" =~ ~r//
true

iex> "abcd" =~ "bc"
true

iex> "abcd" =~ "ad"
false

iex> "abcd" =~ "abcd"
true

iex> "abcd" =~ ""
true

For more information about regular expressions, please check the Regex module.

Module attribute unary operator.

Reads and writes attributes in the current module.

The canonical example for attributes is annotating that a module implements an OTP behaviour, such as GenServer:

defmodule MyServer do
  @behaviour GenServer
  # ... callbacks ...
end

By default Elixir supports all the module attributes supported by Erlang, but custom attributes can be used as well:

defmodule MyServer do
  @my_data 13
  IO.inspect(@my_data)
  #=> 13
end

Unlike Erlang, such attributes are not stored in the module by default since it is common in Elixir to use custom attributes to store temporary data that will be available at compile-time. Custom attributes may be configured to behave closer to Erlang by using Module.register_attribute/3.

Important: Libraries and frameworks should consider prefixing any module attributes that are private by underscore, such as @_my_data so code completion tools do not show them on suggestions and prompts.

Finally, note that attributes can also be read inside functions:

defmodule MyServer do
  @my_data 11
  def first_data, do: @my_data
  @my_data 13
  def second_data, do: @my_data
end

MyServer.first_data()
#=> 11

MyServer.second_data()
#=> 13

It is important to note that reading an attribute takes a snapshot of its current value. In other words, the value is read at compilation time and not at runtime. Check the Module module for other functions to manipulate module attributes.

Attention! Multiple references of the same attribute

As mentioned above, every time you read a module attribute, a snapshot of its current value is taken. Therefore, if you are storing large values inside module attributes (for example, embedding external files in module attributes), you should avoid referencing the same attribute multiple times. For example, don't do this:

@files %{
  example1: File.read!("lib/example1.data"),
  example2: File.read!("lib/example2.data")
}

def example1, do: @files[:example1]
def example2, do: @files[:example2]

In the above, each reference to @files may end-up with a complete and individual copy of the whole @files module attribute. Instead, reference the module attribute once in a private function:

@files %{
  example1: File.read!("lib/example1.data"),
  example2: File.read!("lib/example2.data")
}

defp files(), do: @files
def example1, do: files()[:example1]
def example2, do: files()[:example2]

Attention! Compile-time dependencies

Keep in mind references to other modules, even in module attributes, generate compile-time dependencies to said modules.

For example, take this common pattern:

@values [:foo, :bar, :baz]

def handle_arg(arg) when arg in @values do
  ...
end

While the above is fine, imagine if instead you have actual module names in the module attribute, like this:

@values [Foo, Bar, Baz]

def handle_arg(arg) when arg in @values do
  ...
end

The code above will define a compile-time dependency on the modules Foo, Bar, and Baz, in a way that, if any of them change, the current module will have to recompile. In such cases, it may be preferred to avoid the module attribute altogether:

def handle_arg(arg) when arg in [Foo, Bar, Baz] do
  ...
end

When used inside quoting, marks that the given alias should not be hygienized. This means the alias will be expanded when the macro is expanded.

Check Kernel.SpecialForms.quote/2 for more information.

@spec apply((... -> any()), [any()]) :: any()

Invokes the given anonymous function fun with the list of arguments args.

If the number of arguments is known at compile time, prefer fun.(arg_1, arg_2, ..., arg_n) as it is clearer than apply(fun, [arg_1, arg_2, ..., arg_n]).

Inlined by the compiler.

Examples

iex> apply(fn x -> x * 2 end, [2])
4

@spec apply(module(), function_name :: atom(), [any()]) :: any()

Invokes the given function from module with the list of arguments args.

apply/3 is used to invoke functions where the module, function name or arguments are defined dynamically at runtime. For this reason, you can't invoke macros using apply/3, only functions.

If the number of arguments and the function name are known at compile time, prefer module.function(arg_1, arg_2, ..., arg_n) as it is clearer than apply(module, :function, [arg_1, arg_2, ..., arg_n]).

apply/3 cannot be used to call private functions.

Inlined by the compiler.

Examples

iex> apply(Enum, :reverse, [[1, 2, 3]])
[3, 2, 1]

Returns a binary from the offset given by the start of the range to the offset given by the end of the range.

If the start or end of the range are negative, they are converted into positive indices based on the binary size. For example, -1 means the last byte of the binary.

This is similar to binary_part/3 except that it works with ranges and it is not allowed in guards.

This function works with bytes. For a slicing operation that considers characters, see String.slice/2.

Examples

iex> binary_slice("elixir", 0..5)
"elixir"
iex> binary_slice("elixir", 1..3)
"lix"
iex> binary_slice("elixir", 1..10)
"lixir"

iex> binary_slice("elixir", -4..-1)
"ixir"
iex> binary_slice("elixir", -4..6)
"ixir"
iex> binary_slice("elixir", -10..10)
"elixir"

For ranges where start > stop, you need to explicitly mark them as increasing:

iex> binary_slice("elixir", 2..-1//1)
"ixir"
iex> binary_slice("elixir", 1..-2//1)
"lixi"

You can use ../0 as a shortcut for 0..-1//1, which returns the whole binary as is:

iex> binary_slice("elixir", ..)
"elixir"

The step can be any positive number. For example, to get every 2 characters of the binary:

iex> binary_slice("elixir", 0..-1//2)
"eii"

If the first position is after the string ends or after the last position of the range, it returns an empty string:

iex> binary_slice("elixir", 10..3//1)
""
iex> binary_slice("elixir", -10..-7)
""
iex> binary_slice("a", 1..1500)
""

Returns a binary starting at the offset start and of the given size.

This is similar to binary_part/3 except that if start + size is greater than the binary size, it automatically clips it to the binary size instead of raising. Opposite to binary_part/3, this function is not allowed in guards.

This function works with bytes. For a slicing operation that considers characters, see String.slice/3.

Examples

iex> binary_slice("elixir", 0, 6)
"elixir"
iex> binary_slice("elixir", 0, 5)
"elixi"
iex> binary_slice("elixir", 1, 4)
"lixi"
iex> binary_slice("elixir", 0, 10)
"elixir"

If start is negative, it is normalized against the binary size and clamped to 0:

iex> binary_slice("elixir", -3, 10)
"xir"
iex> binary_slice("elixir", -10, 10)
"elixir"

If the size is zero, an empty binary is returned:

iex> binary_slice("elixir", 1, 0)
""

If start is greater than or equal to the binary size, an empty binary is returned:

iex> binary_slice("elixir", 10, 10)
""

Returns the binding for the given context as a keyword list.

In the returned result, keys are variable names and values are the corresponding variable values.

If the given context is nil (by default it is), the binding for the current context is returned.

Examples

iex> x = 1
iex> binding()
[x: 1]
iex> x = 2
iex> binding()
[x: 2]

iex> binding(:foo)
[]
iex> var!(x, :foo) = 1
1
iex> binding(:foo)
[x: 1]

Debugs the given code.

dbg/2 can be used to debug the given code through a configurable debug function. It returns the result of the given code.

Examples

Let's take this call to dbg/2:

dbg(Atom.to_string(:debugging))
#=> "debugging"

It returns the string "debugging", which is the result of the Atom.to_string/1 call. Additionally, the call above prints:

[my_file.ex:10: MyMod.my_fun/0]
Atom.to_string(:debugging) #=> "debugging"

The default debugging function prints additional debugging info when dealing with pipelines. It prints the values at every "step" of the pipeline.

"Elixir is cool!"
|> String.trim_trailing("!")
|> String.split()
|> List.first()
|> dbg()
#=> "Elixir"

The code above prints:

[my_file.ex:10: MyMod.my_fun/0]
"Elixir is cool!" #=> "Elixir is cool!"
|> String.trim_trailing("!") #=> "Elixir is cool"
|> String.split() #=> ["Elixir", "is", "cool"]
|> List.first() #=> "Elixir"

With no arguments, dbg() debugs information about the current binding. See binding/1.

Configuring the debug function

One of the benefits of dbg/2 is that its debugging logic is configurable, allowing tools to extend dbg with enhanced behaviour. The debug function can be configured at compile time through the :dbg_callback key of the :elixir application. The debug function must be a {module, function, args} tuple. The function function in module will be invoked with three arguments prepended to args:

1. The AST of code
2. The AST of options
3. The Macro.Env environment of where dbg/2 is invoked

Whatever is returned by the debug function is then the return value of dbg/2. The debug function is invoked at compile time.

Here's a simple example:

defmodule MyMod do
  def debug_fun(code, options, caller, device) do
    quote do
      result = unquote(code)
      IO.inspect(unquote(device), result, label: unquote(Macro.to_string(code)))
    end
  end
end

To configure the debug function:

# In config/config.exs
config :elixir, :dbg_callback, {MyMod, :debug_fun, [:stdio]}

Default debug function

By default, the debug function we use is Macro.dbg/3. It just prints information about the code to standard output and returns the value returned by evaluating code. options are used to control how terms are inspected. They are the same options accepted by inspect/2.

Defines a public function with the given name and body.

Examples

defmodule Foo do
  def bar, do: :baz
end

Foo.bar()
#=> :baz

A function that expects arguments can be defined as follows:

defmodule Foo do
  def sum(a, b) do
    a + b
  end
end

In the example above, a sum/2 function is defined; this function receives two arguments and returns their sum.

Default arguments

\\ is used to specify a default value for a parameter of a function. For example:

defmodule MyMath do
  def multiply_by(number, factor \\ 2) do
    number * factor
  end
end

MyMath.multiply_by(4, 3)
#=> 12

MyMath.multiply_by(4)
#=> 8

The compiler translates this into multiple functions with different arities, here MyMath.multiply_by/1 and MyMath.multiply_by/2, that represent cases when arguments for parameters with default values are passed or not passed.

When defining a function with default arguments as well as multiple explicitly declared clauses, you must write a function head that declares the defaults. For example:

defmodule MyString do
  def join(string1, string2 \\ nil, separator \\ " ")

  def join(string1, nil, _separator) do
    string1
  end

  def join(string1, string2, separator) do
    string1 <> separator <> string2
  end
end

Note that \\ can't be used with anonymous functions because they can only have a sole arity.

Keyword lists with default arguments

Functions containing many arguments can benefit from using Keyword lists to group and pass attributes as a single value.

defmodule MyConfiguration do
  @default_opts [storage: "local"]

  def configure(resource, opts \\ []) do
    opts = Keyword.merge(@default_opts, opts)
    storage = opts[:storage]
    # ...
  end
end

The difference between using Map and Keyword to store many arguments is Keyword's keys:

• must be atoms
• can be given more than once
• ordered, as specified by the developer

Function and variable names

Function and variable names have the following syntax: A lowercase ASCII letter or an underscore, followed by any number of lowercase or uppercase ASCII letters, numbers, or underscores. Optionally they can end in either an exclamation mark or a question mark.

For variables, any identifier starting with an underscore should indicate an unused variable. For example:

def foo(bar) do
  []
end
#=> warning: variable bar is unused

def foo(_bar) do
  []
end
#=> no warning

def foo(_bar) do
  _bar
end
#=> warning: the underscored variable "_bar" is used after being set

rescue/catch/after/else

Function bodies support rescue, catch, after, and else as Kernel.SpecialForms.try/1 does (known as "implicit try"). For example, the following two functions are equivalent:

def convert(number) do
  try do
    String.to_integer(number)
  rescue
    e in ArgumentError -> {:error, e.message}
  end
end

def convert(number) do
  String.to_integer(number)
rescue
  e in ArgumentError -> {:error, e.message}
end

Defines a function that delegates to another module.

Functions defined with defdelegate/2 are public and can be invoked from outside the module they're defined in, as if they were defined using def/2. Therefore, defdelegate/2 is about extending the current module's public API. If what you want is to invoke a function defined in another module without using its full module name, then use alias/2 to shorten the module name or use import/2 to be able to invoke the function without the module name altogether.

Delegation only works with functions; delegating macros is not supported.

Check def/2 for rules on naming and default arguments.

Options

• :to - the module to dispatch to.

• :as - the function to call on the target given in :to. This parameter is optional and defaults to the name being delegated (funs).

Examples

defmodule MyList do
  defdelegate reverse(list), to: Enum
  defdelegate other_reverse(list), to: Enum, as: :reverse
end

MyList.reverse([1, 2, 3])
#=> [3, 2, 1]

MyList.other_reverse([1, 2, 3])
#=> [3, 2, 1]

Defines an exception.

Exceptions are structs backed by a module that implements the Exception behaviour. The Exception behaviour requires two functions to be implemented:

• exception/1 - receives the arguments given to raise/2 and returns the exception struct. The default implementation accepts either a set of keyword arguments that is merged into the struct or a string to be used as the exception's message.

• message/1 - receives the exception struct and must return its message. Most commonly exceptions have a message field which by default is accessed by this function. However, if an exception does not have a message field, this function must be explicitly implemented.

Since exceptions are structs, the API supported by defstruct/1 is also available in defexception/1.

Raising exceptions

The most common way to raise an exception is via raise/2:

defmodule MyAppError do
  defexception [:message]
end

value = [:hello]

raise MyAppError,
  message: "did not get what was expected, got: #{inspect(value)}"

In many cases it is more convenient to pass the expected value to raise/2 and generate the message in the Exception.exception/1 callback:

defmodule MyAppError do
  defexception [:message]

  @impl true
  def exception(value) do
    msg = "did not get what was expected, got: #{inspect(value)}"
    %MyAppError{message: msg}
  end
end

raise MyAppError, value

The example above shows the preferred strategy for customizing exception messages.

@spec defguard(Macro.t()) :: Macro.t()

Generates a macro suitable for use in guard expressions.

It raises at compile time if the definition uses expressions that aren't allowed in guards, and otherwise creates a macro that can be used both inside or outside guards.

Note the convention in Elixir is to name functions/macros allowed in guards with the is_ prefix, such as is_list/1. If, however, the function/macro returns a boolean and is not allowed in guards, it should have no prefix and end with a question mark, such as Keyword.keyword?/1.

Example

defmodule Integer.Guards do
  defguard is_even(value) when is_integer(value) and rem(value, 2) == 0
end

defmodule Collatz do
  @moduledoc "Tools for working with the Collatz sequence."
  import Integer.Guards

  @doc "Determines the number of steps `n` takes to reach `1`."
  # If this function never converges, please let me know what `n` you used.
  def converge(n) when n > 0, do: step(n, 0)

  defp step(1, step_count) do
    step_count
  end

  defp step(n, step_count) when is_even(n) do
    step(div(n, 2), step_count + 1)
  end

  defp step(n, step_count) do
    step(3 * n + 1, step_count + 1)
  end
end

@spec defguardp(Macro.t()) :: Macro.t()

Generates a private macro suitable for use in guard expressions.

It raises at compile time if the definition uses expressions that aren't allowed in guards, and otherwise creates a private macro that can be used both inside or outside guards in the current module.

Similar to defmacrop/2, defguardp/1 must be defined before its use in the current module.

Defines an implementation for the given protocol.

See the Protocol module for more information.

Defines a public macro with the given name and body.

Macros must be defined before its usage.

Check def/2 for rules on naming and default arguments.

Examples

defmodule MyLogic do
  defmacro unless(expr, opts) do
    quote do
      if !unquote(expr), unquote(opts)
    end
  end
end

require MyLogic

MyLogic.unless false do
  IO.puts("It works")
end

Defines a private macro with the given name and body.

Private macros are only accessible from the same module in which they are defined.

Private macros must be defined before its usage.

Check defmacro/2 for more information, and check def/2 for rules on naming and default arguments.

Defines a module given by name with the given contents.

This macro defines a module with the given alias as its name and with the given contents. It returns a tuple with four elements:

• :module
• the module name
• the binary contents of the module
• the result of evaluating the contents block

Examples

defmodule Number do
  def one, do: 1
  def two, do: 2
end
#=> {:module, Number, <<70, 79, 82, ...>>, {:two, 0}}

Number.one()
#=> 1

Number.two()
#=> 2

Nesting

Nesting a module inside another module affects the name of the nested module:

defmodule Foo do
  defmodule Bar do
  end
end

In the example above, two modules - Foo and Foo.Bar - are created. When nesting, Elixir automatically creates an alias to the inner module, allowing the second module Foo.Bar to be accessed as Bar in the same lexical scope where it's defined (the Foo module). This only happens if the nested module is defined via an alias.

If the Foo.Bar module is moved somewhere else, the references to Bar in the Foo module need to be updated to the fully-qualified name (Foo.Bar) or an alias has to be explicitly set in the Foo module with the help of Kernel.SpecialForms.alias/2.

defmodule Foo.Bar do
  # code
end

defmodule Foo do
  alias Foo.Bar
  # code here can refer to "Foo.Bar" as just "Bar"
end

Dynamic names

Elixir module names can be dynamically generated. This is very useful when working with macros. For instance, one could write:

defmodule String.to_atom("Foo#{1}") do
  # contents ...
end

Elixir will accept any module name as long as the expression passed as the first argument to defmodule/2 evaluates to an atom. Note that, when a dynamic name is used, Elixir won't nest the name under the current module nor automatically set up an alias.

Reserved module names

If you attempt to define a module that already exists, you will get a warning saying that a module has been redefined.

There are some modules that Elixir does not currently implement but it may be implement in the future. Those modules are reserved and defining them will result in a compilation error:

defmodule Any do
  # code
end
** (CompileError) iex:1: module Any is reserved and cannot be defined

Elixir reserves the following module names: Elixir, Any, BitString, PID, and Reference.

Makes the given definitions in the current module overridable.

If the user defines a new function or macro with the same name and arity, then the overridable ones are discarded. Otherwise, the original definitions are used.

It is possible for the overridden definition to have a different visibility than the original: a public function can be overridden by a private function and vice-versa.

Macros cannot be overridden as functions and vice-versa.

Example

defmodule DefaultMod do
  defmacro __using__(_opts) do
    quote do
      def test(x, y) do
        x + y
      end

      defoverridable test: 2
    end
  end
end

defmodule ChildMod do
  use DefaultMod

  def test(x, y) do
    x * y + super(x, y)
  end
end

As seen as in the example above, super can be used to call the default implementation.

Note: use defoverridable with care. If you need to define multiple modules with the same behaviour, it may be best to move the default implementation to the caller, and check if a callback exists via Code.ensure_loaded?/1 and function_exported?/3.

For example, in the example above, imagine there is a module that calls the test/2 function. This module could be defined as such:

defmodule CallsTest do
  def receives_module_and_calls_test(module, x, y) do
    if Code.ensure_loaded?(module) and function_exported?(module, :test, 2) do
      module.test(x, y)
    else
      x + y
    end
  end
end

Example with behaviour

You can also pass a behaviour to defoverridable and it will mark all of the callbacks in the behaviour as overridable:

defmodule Behaviour do
  @callback test(number(), number()) :: number()
end

defmodule DefaultMod do
  defmacro __using__(_opts) do
    quote do
      @behaviour Behaviour

      def test(x, y) do
        x + y
      end

      defoverridable Behaviour
    end
  end
end

defmodule ChildMod do
  use DefaultMod

  def test(x, y) do
    x * y + super(x, y)
  end
end

Defines a private function with the given name and body.

Private functions are only accessible from within the module in which they are defined. Trying to access a private function from outside the module it's defined in results in an UndefinedFunctionError exception.

Check def/2 for more information.

Examples

defmodule Foo do
  def bar do
    sum(1, 2)
  end

  defp sum(a, b), do: a + b
end

Foo.bar()
#=> 3

Foo.sum(1, 2)
** (UndefinedFunctionError) undefined function Foo.sum/2

Defines a protocol.

See the Protocol module for more information.

Defines a struct.

A struct is a tagged map that allows developers to provide default values for keys, tags to be used in polymorphic dispatches and compile time assertions. For more information about structs, please check Kernel.SpecialForms.%/2.

It is only possible to define a struct per module, as the struct it tied to the module itself. Calling defstruct/1 also defines a __struct__/0 function that returns the struct itself.

Examples

defmodule User do
  defstruct name: nil, age: nil
end

Struct fields are evaluated at compile-time, which allows them to be dynamic. In the example below, 10 + 11 is evaluated at compile-time and the age field is stored with value 21:

defmodule User do
  defstruct name: nil, age: 10 + 11
end

The fields argument is usually a keyword list with field names as atom keys and default values as corresponding values. defstruct/1 also supports a list of atoms as its argument: in that case, the atoms in the list will be used as the struct's field names and they will all default to nil.

defmodule Post do
  defstruct [:title, :content, :author]
end