Ytukyg

I have a struct:

defmodule Company do

  defstruct [:id, :name, :active]

end

I have a function that requires one of its arguments to be of this struct:

def create(connection, %Company{id: id} = company) do

  # stuff

end

Is there any way I can enforce type-checking without using a guard clause? Right now I have to do this:

def create(connection, %Company{id: id, name: name, active: active})

    when is_integer(id) and is_binary(name) and is_boolean(active) do

  # stuff

end

Edit: this question in specific is regarding arguments in a function definition that use a struct.

No, there is no way to enforce type check without guards. Erlang (and hence Elixir) is a dynamically typed language and you might want to have different clauses for different types passed, e.g. an error message if the types do not conform, or just sink the input out, or whatever.

def create(connection, %Company{id: id})

    when not is_integer(id) do

  raise "Must be integer"

end

Erlang does not take out the liberty to deal with not proper input in the way you need, that is why guards you use is the way to go.

There is static analysis tool, dialyzer, you might use to statically check types, also it does not prevent the compiler and runtime to pass whatever type is passed.

As @Aleksei has already pointed out, type-checking is not enforced in Elixir since it's a dynamically-typed language, so to do it manually we usually do it in a guard clause.

But repeating the same set of clauses over and over again can be messy, tiring and error-prone. Though you could "validate" them in a separate function and make it easier, but it won't be as performant as guards:

defmodule Company do

  defstruct [:id, :name, :active]



  def create(connection, company) do

    with :ok <- validate(company) do

      # do something

    end

  end



  defp validate(%Company{id: id, name: name, active: active})

  when is_integer(id) and is_binary(name) and is_boolean(active),

  do: :ok



  defp validate(_term), do: raise "Invalid Company"

end

Now calling the function for Company would work as expected, while it would raise errors for other terms:

Company.create(1, %Company{})

# => ** (RuntimeError) Invalid Company



Company.create(2, %Company{id: 1, name: "hello", active: false})

# => ... (works normally)

^{If your use-case was simpler, you could've retained the performance by defining a custom guard-clause.}

I think its more idiomatic in Elixir to consider the contents of a struct to be valid data. And to provide a factory function to create a struct as part of your public API as @Sheharyar suggests above. I typically see the function be called new not create but thats preference more than dogma.

As long as your code adheres to using the <module>.new function to create structs you don't need to add repetitive guards on every function. If it all goes wrong, let it crash.