Purity validation

@lpil and @hauleth
Thanks, I know how to do it now!

erl_internal:guard_bif/2 or erl_lint:is_guard_test/1

I suspect it will not be, you will be limited to just these functions:

• !=/2
• !==/2
• */2
• +/1
• +/2
• -/1
• -/2
• //2
• <=/2
• ==/2
• ===/2
• >/2
• >=/2
• abs/1
• and/2
• binary_part/3
• bit_size/1
• byte_size/1
• ceil/1
• div/2
• elem/2
• floor/1
• hd/1
• in/2
• is_atom/1
• is_binary/1
• is_bitstring/1
• is_boolean/1
• is_float/1
• is_function/1
• is_function/2
• is_integer/1
• is_list/1
• is_map/1
• is_map_key/2
• is_nil/1
• is_number/1
• is_pid/1
• is_port/1
• is_reference/1
• is_struct/1
• is_tuple/1
• length/1
• map_size/1
• node/0
• node/1
• not/1
• or/2
• rem/2
• round/1
• self/0
• tl/1
• trunc/1
• tuple_size/1

There’s no way to iterate or recurse, and there is no flow control.

I think it will be quite enough for purposes of my library. Do you know name of utility function which checks that given AST is valid guard? Or maybe some guesses where to search it?

They do not have this functionality I’m afraid.

You’re effectively wanting to write a kind of static type system for Erlang- it would be a large piece of work.

No, not really. Erlang/Elixir just have defined set of “guard safe” functions which are allowed. There is much broader set of pure functions that will not be allowed in guards.

I just don’t want to re-invent the wheel, and deal with tricky possibilities like

import Kernel, except: [{:'-', 1}]
import UnpureOverride, only: [{:'-', 1}]

Erlang/Elixir compiler already have utility to deal with this kind of stuff and reject it in guards because of possible impurity

Thanks, I understand, that’s completely fine for my proposes. I maintain this library

And atm it don’t allow any function application. But I want to allow application of functions which are pure for sure. It can be small subset of pure functions, that’s fine. Because atm expressions like foo: -42 are rejected by library because there is &Kernel.-/1 function application there.

They don’t track if functions are pure, instead they have a small list of permitted functions and operators, and if any other functions are used then the code is rejected by the compiler. In Elixir it is the same process I outlined above with macro expansion.

Purity inference isn’t need as being pure isn’t enough for a function to be valid in a guard.

I mean that both Erlang and Elixir compilers don’t allow application of impure functions in guard expressions. And I just want to reuse this utility. Check that given AST is pure for sure, either that it might be impure.