Elixir - Passing multiple lists as function parameters

Question

I am new in Elixir but my google searches and reading up have not found me with a solution to my current problem. I have only seen examples in the books and tutorials with passing in a single list parameter to a function like so: [ head | tail ].

defmodule Math do
  def double_each([head|tail]) do
    [head * 2| double_each(tail)]
  end

  def double_each([]) do
    []
  end
end

I need to pass in two lists and then perform some actions on them, like so:

defmodule Pagination do
  def getPaginatedList([], _, _, _) do
    []
  end

  def getPaginatedList([list], [paginated], f, l) when f == 1 do
    Enum.take(list, l)
  end

  def getPaginatedList(_, [paginated], f, l) when l <= f do
    paginated
  end

  def getPaginatedList([list], [paginated] \\ [], f, l) do
    getPaginatedList(tl(list), paginated ++ hd(list), f, l - 1)
  end
end

However, I receive an error about the function clause not matching when passing in a list for a and a list for b as in the error below:

iex(23)> Pagination.getPaginatedList(a, b, 1, 2)
** (FunctionClauseError) no function clause matching
      in Pagination.getPaginatedList/4
    pagination.ex:2: Pagination.getPaginatedList([1, 2, 3, 4, 5], [], 1, 2)

Any ideas on what I may be doing incorrectly? (Apologies if this is a simple question to answer. I have not been able to find any answer after a few hours of searching and playing around with this.)

Answer 1

Your issues are the list argument pattern match. For the list and paginated arguments, you don't need to wrap them in a list, since you'd actually be matching on a nested list. Also, it's conventional to use snake case in Elixir for function names. Try giving this a shot:

defmodule Pagination do
  def get_paginated_list([], _, _, _) do
    []
  end

  def get_paginated_list(list, paginated, f, l) when f == 1 do
    Enum.take(list, l)
  end

  def get_paginated_list(_, paginated, f, l) when l <= f do
    paginated
  end

  def get_paginated_list(list, paginated \\ [], f, l) do
    get_paginated_list(tl(list), paginated ++ hd(list), f, l - 1)
  end
end

Answer 2

@Chris solved the error message you've encountered, I'll only add that the method signatures are not very "elixirish".

The following method signatures are more in the spirit and coding style of the language (I've changed some of the parameter names to be more readable):

defmodule Pagination do
  def get_paginated_list([], _, _, _) do
    []
  end

  def get_paginated_list(list, _, page_num, page_size) when page_num == 1 do
    Enum.take(list, page_size)
  end

  def get_paginated_list(_, paginated, page_num, page_size) when page_size <= page_num do
    paginated
  end

  def get_paginated_list([head | tail], paginated \\ [], page_num, page_size) do
    get_paginated_list(tail, paginated ++ [head], page_num, page_size - 1)
  end
end

I'm not exactly sure what the semantics of your code should be, but for pagination, I think you might want to look at Enum.chunk/4, which you might use like this:

defmodule Pagination do   
  def get_paginated_list(list, page_num, page_size) do
    list |> Enum.chunk(page_size, page_size, []) |>  Enum.at(page_num)
  end
end

Pagination.get_paginated_list([1, 2, 3, 4, 5], 1, 3)
# => [4, 5]
Pagination.get_paginated_list([1, 2, 3, 4, 5], 0, 3)
# => [1, 2, 3]
Pagination.get_paginated_list([1, 2, 3, 4, 5], 2, 3)
# => nil