Function with many arguments design

Hey everyone!

This is my first time posting on here, and I’m getting started with writing some real Elixir code! I’m not new to programming, but I also wouldn’t call myself a programmer, more of a hobbyist since I do a lot more with systems and security.

Anyhay, I really like to learn coding design when I trying new languages, so when I create a function in a module, I want to do it the right way. In my code I’m writing right now, I am writing some functions in a module that will be accepting many arguments, and the majority of them are going to be optional with default values, or optional with nil and if it’s nil it will get tossed.

With that context, if I have a function with say, 10 arguments, how would you write that? My thought is to have it something like this:

  def testfunc(
        arg3 \\ "default",
        arg4 \\ "default1",
        arg5 \\ nil
      ) do

Is that acceptable in the Elixir world?


10 arguments is pretty unwieldy. What you’ll see more commonly is a data structure defined with defstruct that is used in the module. Maybe a couple of constructors, and then functions that accept other args and implement logic to add to the structure, and then functions that consume it.

The other pattern you will see is the options pattern - this is for when you have one-three args that are required and several optional arguments. You define the last argument as a Keyword list. Elixir has syntax sugar so you don’t have to wrap that in a list constructor.


Thank you! You’ve given me some stuff to look into. I’ll do some playing around and report back with what I think is the code design you’re talking about :slight_smile:

But for starters, you’re saying it’d be like:

defmodule MyModule do
  defstruct arg4: "default1", arg5: "default2"

  def testfunct(
    [arg4: "user-value"]
  ) do
  IO.puts("Do something")

Then have some sort of control flow to check the optional args and if they aren’t defined use a value from defstruct?

What he’s saying is this:

defmodule MyModule do
   @enforce_keys [:arg1, :arg2, :arg3]
   defstruct :arg1, :arg2, :arg3, arg4: “default”, arg5: “default”

   def testfunc(%__MODULE__{} = params) do

You can then access the arguments in the params variable. Enforce keys requires specific arguments be specified.


Oh interesting, I haven’t come across that syntax yet. I’ll try that out hopefully tonight or tomorrow when I can return to this

If your argument list is always used together, the struct approach can be powerful.

If the arguments are more ad-hoc, one approach you’ll see in other languages is named arguments. Elixir doesn’t specifically have named arguments, but you can get close with a keyword list:

def some_func(required_arg_1, required_arg_2, opts \\ []) do
  # extract optional args from opts with Keyword.get(opts, :optional_arg_name, "default value")

# call sequence
some_func("foo", "bar")
some_func("foo", "bar", baz: "wat")

if you have a LOT of optional arguments, you might even do something like:

def some_func(required_arg_1, required_arg_2, kw_opts \\ []) do
  opts = Enum.into(kw_opts, %{optional_arg_1: "default", optional_arg_2:: false, ...})
  # can now use opts.optional_arg_1 etc
  # or pattern-match the map

I first encountered this technique in this post: Passing in options: Maps vs. Keyword lists


Fortunately my optional args are known so in this case the struct will make a lot more sense. The second suggestion you showed me reminds me a lot of what I’ve been doing in Python. And thank you for the link! That really helps too!