[Caml-list] Guards vs. conditionals

[Caml-list] Guards vs. conditionals

[Matt Gushee]

Hi, all--

I'm just curious about something. I've been noticing that in many cases
(if not always) a pattern match with guard expressions in OCaml is
equivalent to a conditional statement. E.g.:

  let foo =
    function
    | i when i >= 500 -> true
    | i -> false
    
does the same thing as

  let foo i =
    if i >= 500 then true
    else false

And I wrote a pair of small programs, each of which invokes one of these
functions on a random integer 100,000 times. The executables, whether
byte-compiled or native, are almost exactly the same size and, according
to a round of informal tests with GNU time, run at the same speed. This
suggests that the compiled code is for all practical purposes the same.

So, my question is, is there any objective reason to prefer the
pattern-match version over the conditional, or vice versa? Or is it just
a matter of coding style?
        
-- 
Matt Gushee                 When a nation follows the Way,
Englewood, Colorado, USA    Horses bear manure through
mgushee@havenrock.com           its fields;
http://www.havenrock.com/   When a nation ignores the Way,
                            Horses bear soldiers through
                                its streets.
                                
                            --Lao Tzu (Peter Merel, trans.)
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Guards vs. conditionals

[Sven Luther]

On Thu, Dec 26, 2002 at 12:06:52AM -0700, Matt Gushee wrote:
> Hi, all--
> 
> I'm just curious about something. I've been noticing that in many cases
> (if not always) a pattern match with guard expressions in OCaml is
> equivalent to a conditional statement. E.g.:
> 
>   let foo =
>     function
>     | i when i >= 500 -> true
>     | i -> false
>     
> does the same thing as
> 
>   let foo i =
>     if i >= 500 then true
>     else false
> 
> And I wrote a pair of small programs, each of which invokes one of these
> functions on a random integer 100,000 times. The executables, whether
> byte-compiled or native, are almost exactly the same size and, according
> to a round of informal tests with GNU time, run at the same speed. This
> suggests that the compiled code is for all practical purposes the same.
> 

Yes, i guess the exact same code it generated for both.

> So, my question is, is there any objective reason to prefer the
> pattern-match version over the conditional, or vice versa? Or is it just
> a matter of coding style?

It is just a matter of coding style. I think that the if version is
maybe easier to do prooves on or something such, and that guard version
is easier to read and maybe better when there are more than one
condition, but the compiler does not know when the guards cover all the
cases, and may output a warning when non is needed :

consider :

let foo = function
| i when i > 500 -> 1
| i when i = 500 -> 2
| i when i < 500 -> 3

Which will output a warning.

Friendly,

Sven Luther
>         
> -- 
> Matt Gushee                 When a nation follows the Way,
> Englewood, Colorado, USA    Horses bear manure through
> mgushee@havenrock.com           its fields;
> http://www.havenrock.com/   When a nation ignores the Way,
>                             Horses bear soldiers through
>                                 its streets.
>                                 
>                             --Lao Tzu (Peter Merel, trans.)
> -------------------
> To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
> Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Guards vs. conditionals

[Pierre Weis]

[...]
> > So, my question is, is there any objective reason to prefer the
> > pattern-match version over the conditional, or vice versa? Or is it just
> > a matter of coding style?
> 
> It is just a matter of coding style. I think that the if version is
> maybe easier to do prooves on or something such,
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
What do you mean ?

> and that guard version is easier to read and maybe better when there
> are more than one condition, but the compiler does not know when the
> guards cover all the cases, and may output a warning when non is
> needed :
> 
> consider :
> 
> let foo = function
> | i when i > 500 -> 1
> | i when i = 500 -> 2
> | i when i < 500 -> 3
> 
> Which will output a warning.
> 
> Friendly,
> 
> Sven Luther

The guard version has the additional good property of allowing
sequences in the clauses with no need for parens or begin end:

 | i when i > 500 -> print i; printe_newline ()
 | i -> ...

Concerning the conjunction of guards and partial matches, the problem
is covered in large in the FAQ of the language, under the question

* Partial match with guards ?

Have a look to:

http://pauillac.inria.fr/caml/FAQ/FAQ_EXPERT-eng.html#gardes_partielles

In short, you just have to remember that the last clause does not need
a guard: use comments and the warning desapears :). For instance,

 | i (* when i < 500 *) -> 3

Friendly,

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/


-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Guards vs. conditionals

[Xavier Leroy]

> I'm just curious about something. I've been noticing that in many cases
> (if not always) a pattern match with guard expressions in OCaml is
> equivalent to a conditional statement.

Not always strictly equivalent.  Consider

  match x with hd::tl when hd <> 0 -> <expr1>
             | _ -> <expr2>

Without "when", you'd need to duplicate <expr2>:

  match x with hd::tl -> if hd <> 0 then <expr1> else <expr2>
             | _ -> <expr2>

> So, my question is, is there any objective reason to prefer the
> pattern-match version over the conditional, or vice versa? Or is it just
> a matter of coding style?

It's just a question of style.  Personally, I'd recommend using "when"
in cases where "real" pattern-matching is involved, as in the example
above, and cascades of "if...then...else..." in cases where it doesn't
cause duplication of code.  But you can opt for a different style.

- Xavier Leroy
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Guards vs. conditionals

[Matt Gushee]

On Thu, Dec 26, 2002 at 09:55:09PM -0600, Gurr, David (MED, self) wrote:
> try "ocamlc -dlambda foo.ml"

Wow. That outputs something that looks a lot like LISP. And -dlambda
seems to be undocumented, at least in the man page and the HTML user's
manual. What is it intended for?

Just in case anyone's interested, here are the two programs and the
results of calling the above command on them:

-- foo1.ml ----------------------------------------------------------
let foo =                                                       
  function                                                                  
  | i when i >= 500 -> true                                                 
  | i -> false in
    for i = 1 to 100000 do
      ignore (foo (Random.int 1000))
    done

---------------------------------------------------------------------

bash-2.05a$ ocamlc -dlambda foo1.ml 
(setglobal Foo1!
  (seq
    (let (foo/56 (function i/57 (if (>= i/57 500) 1a 0a)))
      (for i/59 1 to 100000
        (ignore (apply foo/56 (apply (field 4 (global Random!)) 1000)))))
    (makeblock 0)))


-- foo2.ml ----------------------------------------------------------
let foo i =                                                       
  if i >= 500 then true
  else false in
  for i = 1 to 100000 do
    ignore (foo (Random.int 1000))
  done
  
---------------------------------------------------------------------

bash-2.05a$ ocamlc -dlambda foo2.ml 
(setglobal Foo2!
  (seq
    (let (foo/56 (function i/57 (if (>= i/57 500) 1a 0a)))
      (for i/58 1 to 100000
        (ignore (apply foo/56 (apply (field 4 (global Random!)) 1000)))))
    (makeblock 0)))

I note that the output is identical except on the fourth line: i/59 vs.
i/58 . What does that notation represent, by the way?

-- 
Matt Gushee                 When a nation follows the Way,
Englewood, Colorado, USA    Horses bear manure through
mgushee@havenrock.com           its fields;
http://www.havenrock.com/   When a nation ignores the Way,
                            Horses bear soldiers through
                                its streets.
                                
                            --Lao Tzu (Peter Merel, trans.)
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners

Re: [Caml-list] Guards vs. conditionals

[Luc Maranget]

> 
> On Thu, Dec 26, 2002 at 09:55:09PM -0600, Gurr, David (MED, self) wrote:
> > try "ocamlc -dlambda foo.ml"
> 
> Wow. That outputs something that looks a lot like LISP. And -dlambda
> seems to be undocumented, at least in the man page and the HTML user's
> manual. What is it intended for?

Well, -d.... options show intermediate representations used by the
compiler. Lambda code is one of the earliest ones.
This is intented for debugging the compiler.


[Snip]
> 
> I note that the output is identical except on the fourth line: i/59 vs.
> i/58 . What does that notation represent, by the way?
> 

Internally, all variables are unique, they are characterized by
a name from the source (for readable output) and an integer.


> -- 
> Matt Gushee                 When a nation follows the Way,
> Englewood, Colorado, USA    Horses bear manure through
> mgushee@havenrock.com           its fields;
> http://www.havenrock.com/   When a nation ignores the Way,
>                             Horses bear soldiers through
>                                 its streets.
>                                 

--Luc
-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners