Bound expressions inside a condition in a cond block in Elixir? - conditional-statements

Question

Is there any way to have multiple bound expressions in a condition in a cond block similar to:
cond do
a = 1; a * 2 == 2 -> "Yes"
end
?
I guess it would be possible if there were something in Elixir like "let in" binding expressions as in Haskell:
let a = 1 in a * 2
Update
In the case below I'd like to bind the String.replace expression to a variable to increase readability (I could of course do it outside the cond which isn't an optimal solution for obvious reasons). The condition checks if the input is upper case only (apart from non-alphabetic characters) and is taken from an exercism.io challenge:
String.upcase(String.replace(input, ~r/[^A-Za-z]/, "")) == String.replace(input, ~r/[^A-Za-z]/, "") and String.length(String.replace(input, ~r/[^A-Za-z]/, "")) > 0 -> "Whoa, chill out!"

Answer 1

To directly answer the first question, the answer is yes. Your original code:
cond do
a = 1; a * 2 == 2 -> "Yes"
end
Is parsed as:
cond do
a = 1
a * 2 == 2 -> "Yes"
end
Because ; means the end of the whole expression. In case you want to include multiple expressions, use parens:
cond do
(a = 1; a * 2 == 2) -> "Yes"
end

Answer 2

Regarding your original question, I think there's nothing wrong with extracting a variable here:
def myfun(input) do
sanitized = String.replace(input, ~r/[^A-Za-z]/, "")
cond do
String.upcase(sanitized) == sanitized and String.length(sanitized) > 0 -> "Whoa, chill out!"
true -> "Good job"
end
end
You could also use the match operator = inside the pattern, more specifically you can use it in place of the first occurrence, but I think it is uglier and harder to read:
def myfun(input) do
cond do
String.upcase(sanitized = String.replace(input, ~r/[^A-Za-z]/, "")) == sanitized and String.length(sanitized) > 0 -> "Whoa, chill out!"
true -> "Good job"
end
end
However your code can be improved by closely looking at the comparisons you are doing. To match the condition, the input string must consist of only uppercase and non-alphabetic characters, containing at least one uppercase character. Since you are already using regexes, here's one that will match all of this in a single check:
\A[^a-z]*[A-Z][^a-z]*\z
Explanation:
\A and \z match string boundaries, the entire string must fulfill the condition
[^a-z]* zero or more non-lowercase characters, followed by
[A-Z] an uppercase character somewhere in the string, followed by
[^a-z]* zero or more non-lowercase characters
Code:
def myfun(input) do
cond do
Regex.match?(~r/\A[^a-z]*[A-Z][^a-z]*\z/, input) -> "Whoa, chill out!"
true -> "Good job"
end
end