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.

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
      ...
   end
end

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

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")
end

# 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
end

I first encountered this technique in this post: Passing in options: Maps vs. Keyword lists - #3 by josevalim