It's possible to write a custom Guard to check for a blank string?

Guard functions are limited to this list. What they have in common is that they execute in constant time. Since binaries (Strings) as well as some other structures, are variable in size, there are no guard functions that operate on the structure as a whole except for length/1 which seems to be a bit of an exception to the constant time expectation.

Therefore I don’t think you’ll find a way to perform the checks you want as a guard.

Typically I would normalise input at an outer boundary layer. Like calling String.trim/2 in a changes that processes user input and therefore my guard would only have to check for "" which is possible,

Lastly, I would just note that the nature of empty? is open to a lot of interpretation and variability in the Unicode world given the wide range of code points that can be interpreted as whitespace.

I was checking in this moment your unicode library. Nice work

Well this is really unfortunate and annoying, because sometimes this is not the case:

Sometimes I just have a function that can be called internally from other modules and I want to be sure that I don’t get the blank string " " .

It seems that I don’t have another alternative then keeping checking for the input in the body of the function

defmodule UtilsFor.Hash.Sha256 do

  alias UtilsFor.Text.Empty

  def salted_base64_encoded(content, salt)
    when is_binary(content)
    and byte_size(content) > 0
    and is_binary(salt)
    and byte_size(salt) > 64 do

    case Empty.check?(content) || Empty.check?(salt) do
      true ->
        raise "Content and/or salt cannot be a blank string."
      false ->
        content_salted = content <> salt

        :crypto.hash(:sha256, content_salted)
        |> Base.encode64()
    end
  end
end

For my purposes I would be happy if I could get a guard clause to work for the common white space

Thanks for the comment! Unicode simple regex’s coming up soon, and then the full Uncocde transform spec. Not quite so soon

Even given the situation you describe I would tend to still enforce a boundary condition separately from processing. For example:

defmodule UtilsFor.Hash.Sha256 do
  alias UtilsFor.Text.Empty

  def salted_base64_encode(content, salt) when is_binary(content) and is_binary(salt) do
    do_salted_base64_encode(String.trim(content), String.trim(salt))
  end
  
  def do_salted_base64_encode("", _), do: {:error, :invalid_content}
  def do_salted_base64_encode(__, ""), do: {:error, :invalid_content}
  
  def do_salted_base64_encode(content, salt) do
    :sha256
    |> :crypto.hash(content <> salt)
    |> Base.encode64()
    |> wrap(:ok)
  end
  
  def wrap(term, wrap) do
    {atom, term}
  end
end

Just my 2.354c worth

This is exactly the type of solution that I am tired of using all hover the place each time I need to check for a blank string.

It’s ok when you need to do it 1 time, not when you need to keep repeating it a across projects.

If you notice the name of the module is UtilsFor because is a package that I use across my projects, thus I would like to have the check for a blank string that I could use from a guard clause, not from the body of a function or with multiple functions heads.

The salted_base64_encode function is just one example where I need ot check for a blanks string, that happens to also be inside the UtilsFor package. I just gave it to help illustrate why it’s needed.

Anyway thanks for your insights

I hear you, boilerplate gets to be a pain, no disagreement there. In most cases I’ve converged on using structs a lot more where a new function does validation and afterwards I trust that the struct has data of the right form and I never check it again. Another approach to creating a boundary between data validation/casting and operations on data.

This has dramatically reduced the amount of boilerplate - but not necessarily for the kind of function you describe above. Over and out

Your approach doesn’t do exactly what I want, aka a blank string "lots of spaces here" will still go through, thus jeopardizing the hash, that could end-up to be generated from a blank content and salt.

Assuming I make do_salted_base64_encode/2 private (which I forgot to do), the String.trim/1 calls on the 5th line will strip all leading and trailing whitespace resulting in "" for a string that is only whitespace before the call to the private function and therefore I think it does what you are after.

I did missed the call to String.trim/1, and I also use it in my UtilsFor package for the same effect. I think I should do a break, because I spent the entire day trying to figure out this issue, and I am starting to not seeing things clearly

Thanks for all your insights.

# @link https://rocket-science.ru/hacking/2017/03/28/is-empty-guard-for-binaries
def empty?(<<" " :: binary, rest :: binary>>), do: empty?(rest)
def empty?(string = ""), do: true
def empty?(_string), do: false

This can simply be injected with a macro module via something like use EmptyStringGuard.

To use in the guard itself?

def my_func(string) when not empty?(string) do
  # do stuff
end