In the module tut13.lfe, we saw our first conditional, the (if ...) form. We're going to spend the rest of this section discussing if, cond, case, as well as the use of guards and pattern matching to form conditional code branches.

The if Form

In the previous section, we wrote the function find-max-min/3 to work out the maximum and minimum temperature. This work was delegated to two helper functions:

  • compare-max/2
  • compare-min/2

In both of those functions, we introduced the new if form. If works as follows:

(if <predicate>

where <expression1> is executed if <predicate> evaluates to true and <expression2> is executed if <predicate> evaluates to false. If you have used other programming languages, then this will be quite familiar to you. If you have not, if should remind you a bit of the logic we looked at when discussing guards.

We can see it in action with the following LFE session in the REPL:

lfe> (if (=:= 1 1) "They are equal!" "They are *not* equal!")
"They are equal!"
lfe> (if (=:= 2 1) "They are equal!" "They are *not* equal!")
"They are *not* equal!"

Or -- you will be more familiar with this -- our code from the last section:

(if (< temp1 temp2)

where, if temp1 is less than temp2, the value stored in city1 is returned.

So the if form works for two conditions. What about 3? 10? 100? Well, for the situations were we want to check multiple conditions, we'll need the cond form.

The cond Form

(cond (<predicate1> <expression1>)
      (<predicate2> <expression2>)
      (<predicate3> <expression3>)
      (<predicaten> <expressionn>))

A given expression is only executed if its accompanying predicate evaluates to true. The cond returns the value of the expression for the first predicate that evaluates to true. Using cond, our temperature test would look like this:

(cond ((< temp1 temp2) city1)
      ((>= temp1 temp2) city2))

Here's an example which takes advantage of cond supporting more than two logic branches:

(cond ((> x 0) x)
      ((=:= x 0) 0)
      ((< x 0) (- x)))

Note that each predicate is an expression with it's own parentheses around it; on its left is the opening parenthesis for that particular branch of the cond.

Often times when using cond one needs a "default" or "fall-through" option to be used when no other condition is met. Since it's the last one, and we need it to evaluate to true we simply set the last condition to true when we need a default. Here's a rather silly example:

(cond ((lists:member x '(1 2 3)) "First three")
      ((=:= x 4) "Is four")
      ((>= x 5) "More than four")
      ('true "You chose poorly"))

Any number that is negative will be caught by the last condition.

In case you're wondering, yes: cond works with patterns as well. Let's take a look.

The Extended cond Form

When we talked about cond above, we only discussed the form as any Lisper would be familiar. However, LFE has extended cond with additional capabilities provided via pattern matching. LFE's cond has the following general form when this is taken into consideration:

(cond (<cond-clause1>)

where each <cond-clause> could be either as it is in the regular cond, <predicate> <expression> or it could be (?= <pattern> [<guard>] <expression>) -- the latter being the extended form (with an optional guard). When using the extended form, instead of evaluating a predicate for its Boolean result, the data passed to the cond is matched against the defined patterns: if the pattern match succeeds, then the associated expression is evaluated. Here's an example:

(cond ((?= (cons head '()) x)
       "Only one element")
      ((?= (list 1 2) x)
       "Two element list")
      ((?= (list a _) (when (is_atom a)) x)
       "List starts with an atom")
      ((?= (cons _ (cons a _)) (when (is_tuple a)) x)
       "Second element is a tuple")
      ('true "Anything goes"))

That form is not that often used, but it can be very practical.

The case Form

The case form is useful for situations where you want to check for multiple possible values of the same expression. Without guards, the general form for case is the following:

(case <expression>
  (<pattern1> <expression1>)
  (<pattern2> <expression2>)
  (<patternn> <expressionn>))

So we could rewrite the code for the non-extended cond above with the following case:

(case x
  ((cons head '())
   "Only one element")
  ((list 1 2)
   "Two element list")
  ((list 'a _)
    "List starts with 'a'")
  (_ "Anything goes"))

The following will happen with the case defined above:

  • Any 1-element list will be matched by the first clause.
  • A 2-element list of 1 and 2 (in that order) will match the second clause.
  • Any 2-element list whose first element is the atom a will match the third clause.
  • Anything not matching the first three clauses will be matched by the fourth.

With guards, the case has the following general form:

(case <expression>
  (<pattern1> [<guard1>] <expression1>)
  (<pattern2> [<guard2>] <expression2>)
  (<patternn> [<guardn>] <expressionn>))

Let's update the previous example with a couple of guards:

(case x
  ((cons head '())
   "Only one element")
  ((list 1 2)
   "Two element list")
  ((list a _) (when (is_atom a))
    "List starts with an atom")
  ((cons _ (cons a _)) (when (is_tuple a))
    "Second element is a tuple")
  (_ "Anything goes"))

This changes the logic of the previous example in the following ways:

  • Any list whose first element is an atom will match the third clause.
  • Any list whose second element is a tuple will match the fourth clause.
  • Anything not matching the first four clauses will be matched by the fifth.

Function Heads as Conditionals

Another very common way to express conditional logic in LFE is through the use of pattern matching in function heads. This has the capacity to make code very concise while also remaining clear to read -- thus its prevalent use.

As we've seen, a regular LFE function takes the following form (where the arguments are optional):

(defun <function-name> ([<arg1> ... <argn>])

When pattern matching in the function head, the form is as follows:

(defun <function-name>
 ((<pattern1>) [<guard1>]
 ((<pattern2>) [<guard2>]
 ((<patternn>) [<guardn>]

Note that simple patterns with no expressions are just regular function arguments. In other words <pattern1>, <pattern2>, etc., may be either a full pattern or they may be simple function arguments. The guards are optional.

Let's try this out by rewriting the silly case example above to use a function with pattern-matching in the function heads:

(defun check-val
  (((cons head '()))
   "Only one element")
  (((list 1 2))
   "Two element list")
  (((list a _)) (when (is_atom a))
    "List starts with an atom")
  (((cons _ (cons a _))) (when (is_tuple a))
    "Second element is a tuple")
  ((_) "Anything goes"))

If you run that in the REPL, you can test it out with the following:

lfe> (check-val '(1))
"Only one element"
lfe> (check-val '(a 1))
"List starts with an atom"
lfe> (check-val '(1 #(b 2)))
"Second element is a tuple"
lfe> (check-val 42)
"Anything goes"

And there you have LFE function definitions with much of the power of if, cond, and case!

Let's use some of these forms in actual code now ...

Example: Inches and Centimetres


[tutorial #14]

Example: Leap Years


[tutorial #15]