Version française
Home     About     Download     Resources     Contact us    
Browse thread
[newbie] Caml Light vs Objective Caml
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Pierre Weis <Pierre.Weis@i...>
Subject: Re: [newbie] Caml Light vs Objective Caml
[...]
> Some Caml Light code from this book (and form others) does not work 
> for Ocaml, for example, Ocaml report a syntax
> error for a definition from page 25
>   
>  let neg = fun  true  -> false | false -> true ;;

Yes, you should write function instead of fun here.

> 1) Could anyone point out other known basic discrepancy between Caml   
> Light and Ocaml that were not mentioned in the FAQ?

There are a few of them, namely:

- predefined identifiers that has changed (module vect is now module Array)
- module access conventions (module__ident is now Module.ident), hence
String.sub, instead of sub_string, and String.blit instead of blit_string
- case conventions have been enforced in Objective Caml.

> 2) I know there is a French book "Diveloppement d'applications avec 
> Objective Caml". Is it suits for studying functional programming and 
> OCaml for peoples without any background in the functional programming?

It is a good book with many interesting examples, worth reading. There
are a lot of other french books for beginners, have a look at

 http://pauillac.inria.fr/caml/books-eng.html

> 3) Why did the meaning of "fun" change?

The raw ``meaning'' is still the same: fun introduces a function
definition; however the syntax of the construction, and the kind of
function definitions the fun keyword introduces has changed.  Hence,
this is one of the more difficult changes you have to make when you
want to translate to O'Caml some code that heavily uses this
construct. I summarize here the differences:

What is perfectly equivalent:
-----------------------------

Introducing a curried function with multiple arguments, as in

fun x y z -> expression

What has slightly changed:
--------------------------

Introducing a pattern matching function with 1 argument; you must
change the keyword fun to the keyword function. Hence

fun true  -> false | false -> true becomes

function true  -> false | false -> true

What has completely changed:
----------------------------

In Objective Caml, the notion of ``curried pattern matching'' (as
defined in older versions of Caml) has been removed, because this
feature has been considered as having a too questionable (and complex
to understand) semantics.

The ``curried pattern matching'' is the ability to performs multiple
pattern matching in parallel, here multiple pattern matching when
defining a function. Instead of the O'Caml code

 fun x y ->
  match x, y with
  | 1, 1 -> bli
  | _, 0 -> bla
  | _, _ -> blu

you could write the Caml Light specific fragment

 fun
 | 1 1 -> bli
 | _ 0 -> bla
 | _ _ -> blu

So you need to perform the converse transformation, which is
fortunately easy if not completely mechanical.

> Thank you in advance.
>   
> Sergei.

You're welcome.

Pierre Weis

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