# Derive Them Protocols

## January 6, 2019

Using derive to implement a protocol is a quick way to give functionality to your modules.

Let’s say you had a protocol that rounds values for you. Like such:

```
defprotocol Math do
def round(v, p)
end
defimpl Math, for: Float do
defdelegate round(v, p), to: Float
end
```

Which allows us to do something like this:

```
iex(1)> Math.round(1.556, 2)
1.56
```

Now say we wanted to round all the float values in our custom data structures. Instead of having to implement the logic over and over would be nice if we could do it simply once.

Here is an example data structure.

```
defmodule Data do
defstruct x: 1.556, y: 2.556
end
```

If we tried to use our protocol as it stands now on the Data structure we’d get:

```
iex(1)> Math.round(%Data{}, 2)
** (Protocol.UndefinedError) protocol Math not implemented for %Data{x: 1.556, y: 2.556}. This protocol is implemented for: Float
(super_happy_fun_land) lib/math.ex:1: Math.impl_for!/1
(super_happy_fun_land) lib/math.ex:2: Math.round/2
```

Let’s implement the Math protocol for any such data structure in our system to take advantage of.

```
defimpl Math, for: Any do
defmacro __deriving__(module, _struct, _opts) do
quote do
defimpl Math, for: unquote(module) do
def round(data, p) do
rounded_map =
data
|> Map.from_struct()
|> Enum.reduce(%{}, fn {k, v}, acc ->
Map.merge(acc, %{k => round_float(v, p)})
end)
struct(unquote(module), rounded_map)
end
defp round_float(v, p) when is_float(v), do: Math.round(v, p)
defp round_float(v, _), do: v
end
end
end
end
```

We’ve implemented the Math protocol for Any and then defined the **deriving** macro which will allow us to use this in our modules.

Then we can implement the round function for any module that takes advantage of the derive.

Finally let’s add this to our Data module and give it a try.

```
defmodule Data do
@derive [Math]
defstruct x: 1.556, y: 2.556
end
iex(1)> Math.round(%Data{}, 2)
%Data{x: 1.56, y: 2.56}
```

As you can see using derive is a nice tool if you have lots of data structures that all need to implement a protocol in a simple fashion and saves you the time from having to repeat yourself over and over.