List/binary comprehensions

List/binary comprehensions are supported as macros. The syntax for list comprehensions is:

(lc (qual  ...) expr ... )

where the final expr is used to generate the elements of the list.

An alias is provided such that the following is also valid:

(list-comp (qual  ...) expr ... )

The syntax for binary comprehensions is:

(bc (qual  ...) expr ... )

where the final expr is a bitseg expr and is used to generate the elements of the binary.

An alias is provided such that the following is also valid:

(binary-comp (qual  ...) expr ... )

The supported qualifiers, in both list/binary comprehensions are:

Form	Notes
`(<- pat {{guard}} list-expr)`	Extract elements from a list expression
`(<= bin-pat {{guard}} binary-expr)`	Extract elements from a binary/bits expression
`(?= pat {{guard}} expr)`	Match test and bind variables in `pat`
`expr`	Normal boolean test

Some examples:

(lc ((<- v (when (> v 5)) l1)
     (== (rem v 2) 0))
  v)

That returns a list of all the even elements of the list l1 which are greater than 5.

(bc ((<= (f float (size 32)) b1)  ; No wrapping, only bitseg needed
     (> f 10.0))
  (io:fwrite "~p\n" (list f))
  (f float (size 64)))            ; No wrapping, only bitseg needed

That returns a binary of floats of size 64 of floats which are larger than 10.0 from the binary b1 and of size 32. The returned numbers are first printed.

NOTE: A word of warning when using guards when extracting elements from a binary. When a match/guard fails for a binary no more attempts will be made to extract data from the binary. This means that even if a value could be extracted from the binary, if the guard fails, this value will be lost and extraction will cease. This is NOT the same as having following boolean test which may remove an element but will not stop extraction. Using a guard is probably not what you want!

Normal vanilla Erlang does the same thing but does not allow guards.