# [eeps] EEP XXX: Pattern-test operator

Richard O'Keefe <>
Mon Apr 30 08:52:57 CEST 2012

```On 30/04/2012, at 1:59 PM, David Mercer wrote:
> You actually answered that quite well, and I understood your answer.  I was just trying to understand *why* or *when* binding in guards might be necessary.

That's described in Erik Søe Sørensen's original proposal.

Here's an example, adapted from one of his.

?point_in_unit_square(P)

is to succeed as a guard if and only if P is a {point,X,Y}
term and X and Y are both floating point numbers in the
half-open interval [0.0,1.0).

This is duck soup for abstract patterns.

#point_in_unit_square(X, Y)
when is_float(X), 0.0 =< X, X < 1.0,
is_float(Y), 0.0 =< Y, Y < 1.0
-> {point,X,Y}.

It is straightforward in Erlang with '?=' as the only
extension:

-define(point_in_unit_square(P),
( {point,X,Y} ?= P andalso
is_float(X) andalso 0.0 =< X andalso X < 1.0 andalso
is_float(Y) andalso 0.0 =< Y andalso Y < 1.0
)).

But without ?= you have to write

-define(point_in_unit_square(P),
( is_tuple(P) andalso
tuple_size(P) =:= 3 andalso
element(1,P) =:= point andalso
is_float(element(2,P)) andalso
0.0 =< element(2,P) andalso
element(2,P) < 1.0 andalso
is_float(element(3,P)) andalso
0.0 =< element(3,P) andalso
element(3,P) < 1.0
)).

One would expect a good compiler to evaluate element(2,P) once
rather than three times, but that amounts to doing
X ?= element(2, P) in the object code, so why not in the source
code?

Following this example, you will see that it is easy to come
up with examples that take O(n) tokens to write using ?= but
O(n**2) without.

```