Exploit "Errors in guards" in defguard

size is constant time O(1), where as length is linear time -O(N) - Naming conventions — Elixir v1.20.2

Isn’t non_empty for lists a bit more expensive operation - depending on size of list?

Enum.empty?/1 just compares to when it is list.

def empty?(enumerable) when is_list(enumerable) do
    enumerable == []
end

Maybe your non_empty can be changed to this ?

def non_empty(val, _msg) when map_size(val) > 0, do: {:ok, val}
def non_empty(val, _msg) when tuple_size(val) > 0, do: {:ok, val}
def non_empty([], msg), do: {:error, msg}
def non_empty(val, _msg) when is_list(val), do: {:ok, val}
def non_empty(_val, msg), do: {:error, msg}

or something like this only if you pass enumerable or tuple, else this will return {:ok, val} for strings, numbers, etc

  def non_empty([], msg), do: {:error, msg}
  def non_empty({}, msg), do: {:error, msg}
  def non_empty(%{} = val, msg) when map_size(val) == 0, do: {:error, msg}
  def non_empty(val, _msg), do: {:ok, val}

This is how I would rewrite your clauses into just two.

  def non_empty(val, _msg)
      when is_list(val) and val != []
      when is_map(val) and map_size(val) > 0
      when is_tuple(val) and tuple_size(val) > 0 do
    {:ok, val}
  end

  def non_empty(_val, msg), do: {:error, msg}

by checking for the type, it does not raise (anyway that is not a problem if you only have one when clause), but in my example it is needed, othewise later when clauses will never be evaluated if any prior clause raises.
Personally I consider good practice to check for types.

please don’t! It totally changes the logic of the function, unless you are fine with it.
As mentioned by @karthheek, it will return {:ok, } in case of an uncovered type.

non_empty(0, "it is empty") will return {:ok, 0}

Why don’t you want to use is_list/1 and what is the issue with raising within the guard?

or you can make it a guard, it will not work for structs though.

  defguard is_non_empty(term)
           when (is_list(term) and term != []) or
                  (is_map(term) and map_size(term) > 0) or
                  (is_tuple(term) and tuple_size(term) > 0)

non_empty function using defguards:

defguard is_non_empty(enum) when ((enum == []) or (enum == {}) or (is_map(enum) and map_size(enum) == 0)) == false

def non_empty(val, _msg) when is_non_empty(val), do: {:ok, val}
def non_empty(_, msg), do: {:error, msg}

@eksperimental .

@kartheek, that is definitely the solution to the question by the OP

@eksperimental I feel both our solutions are very similar. Fun collaborating with you.

@Sebb I was running some benchmarking (just for fun) for below data. Your existing version was taking hit when data is non empty list. You may have to change it.
Which version to use ? you have to figure out by running benchmark or based on other requirements of in the project where it is used.

empty_list = []
list1 = Enum.to_list(1..3)
list2 = Enum.to_list(1..10)
list3 = Enum.to_list(1..100)
empty_map = %{}
map = %{1 => 2}
empty_tuple = {}
tuple = {1}

Benchee.run(%{
  "non_empty_empty_list"    => fn -> TestPattern.non_empty(empty_list, "") end,
  "non_empty_list1"    => fn -> TestPattern.non_empty(list1, "") end,
  "non_empty_list2"    => fn -> TestPattern.non_empty(list2, "") end,
  "non_empty_list3"    => fn -> TestPattern.non_empty(list3, "") end,
  "non_empty_empty_map"    => fn -> TestPattern.non_empty(empty_map, "") end,
  "non_empty_map"    => fn -> TestPattern.non_empty(map, "") end,
  "non_empty_empty_tuple"    => fn -> TestPattern.non_empty(empty_tuple, "") end,
  "non_empty_tuple"    => fn -> TestPattern.non_empty(tuple, "") end,
})

@kartheek definitely yours is more performant.

Here’s another version I think even simpler, that builds on your idea.
defguard is_non_empty(term) when term not in [{}, [], %{}]

This is simpler This will be slower than your original defguard.

As long as time complexity of expression is constant time O(1) - more or less same performance. Your versions are constant time too, so they will have similar performance.

In benchmark - your original defguard is performing the best .

Is better performance due to integer comparison vs equality operators?