Exploit "Errors in guards" in defguard

Sorry guys, I had a rough time and completely forgot about this thread.

Thanks for the insights.

As it seems we can’t exploit “errors in guards” inside a defguard, so I’ll go with your proposal.

@eksperimental

@dimitarvp I understand your point.

I am not criticising OP. I don’t know specifics of how non_empty function is being used.

I feel original non_empty function is little over engineered - covers list, map, tuple.

Most of the time, result tuple is pattern matched. Tuples are rarely iterated like list.

I use Enum.empty? Or for empty checks. I have some error_* which return error messages for a Boolean expression.

def error_if(true, msg), do: {:error, msg}
def error_if(_,_), do: :ok

ErrorUtils module has error_unless, error_if_nil, error_if_not_nil, etc.

Using these error funcs, with and case - I never felt need for anything else.

I wrote defguard for the first time today. This non_empty function does not need defguard as such.

Way too clever for my taste. I would not approve that in a PR and would prefer @eksperimental’s solution.

Wow, I am surprised by the result,
it could be that is_list(term) is faster than term == [], and so on with the other is_* functions. We could benchmark these.

The other thing is that it is so fast than the results are imprecise.
If the results are correct, then it pays off to always check for the type as I was doing.

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?

@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 [{}, [], %{}]

@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, that is definitely the solution to the question by the OP

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 .

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)