[Caml-list] Ocaml in depth?

[Caml-list] Ocaml in depth?

[Rick Bischoff]

Hello all,

      I'm a undergrad student with my nose in a lot of languages, but
      unfortunately i was raised on C/C++...  OCaml and the other
      ML dialects are very interesting to me, but
      I have a few doubts and questions!

      (1) The only "real" examples I see in the tutorials and books,
      etc, are "parsing" problems.  This seems to be the topic at the
      functional programming contests at lot (with a high probability
      at least);  are there any other good examples?

      (2) How can I learn better to escape my simpleton method of
      writing C code in Caml?

      (3) Why do functions return (int -> int) -> int -> int when
      the real type is (int -> int) -> (int -> int).  I find that
      confusing (again, I am a simpleton)

      (4) What is the difference between saying:

          let bob =
              function [] -> []
                       h :: t -> h
          ;;

          and

          let fun john lst =
              match lst with
                    [] -> []
              |     h::t -> h
          ;;

          (I don't know if my syntax is right here, but I am a....)
-- 
Best regards,
 Rick                          mailto:bischoff@rickjr.org

-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr

Re: [Caml-list] Ocaml in depth?

[David Mentre]

Rick Bischoff <bischoff@rickjr.org> writes:

>       (1) The only "real" examples I see in the tutorials and books,
>       etc, are "parsing" problems.  This seems to be the topic at the
>       functional programming contests at lot (with a high probability
>       at least);  are there any other good examples?

ML is good at handling symbolic computation (compilers, analyzers,
etc.), so you'll find a lot of "parsing" problems. Historically, ML was
designed to program theorem provers.

That's said, Caml is much better nowadays at usual computations, for
example numeric computations with its native compiler and the Bigarray
module.

You'll find a good set of real world apps at:
  http://caml.inria.fr/users_programs-eng.html 


>       (2) How can I learn better to escape my simpleton method of
>       writing C code in Caml?

1. Read the FAQs:
  http://caml.inria.fr/FAQ/index-eng.html
Mainly:
  http://caml.inria.fr/FAQ/FAQ_DEBUTANT-eng.html
  http://caml.inria.fr/FAQ/FAQ_EXPERT-eng.html

2. Look at good code (general advice). For Caml, look at ocaml source
   code, for example the List module of standard library:
List.ml:
  http://camlcvs.inria.fr/cgi-bin/cvsweb.cgi/ocaml/stdlib/list.ml?rev=1.27&content-type=text/x-cvsweb-markup
List.mli:
  http://camlcvs.inria.fr/cgi-bin/cvsweb.cgi/ocaml/stdlib/list.mli?rev=1.30&content-type=text/x-cvsweb-markup

>       (3) Why do functions return (int -> int) -> int -> int when
>       the real type is (int -> int) -> (int -> int).  I find that
>       confusing (again, I am a simpleton)

Currying (the Magic Word(tm) ;-). It allows to handle partial
applications, that is to say functions that have parts of their
arguments.

For example, consider:
# let f g x = let x' = x + 1 in (g x') + 1;;
val f : (int -> int) -> int -> int = <fun>

You can use it with all its arguments:
# let h x = x - 1 in f h 3;;
- : int = 4

But you can also create a specialized function by giving only the first
parameter:
# let specialized x = let h x = x * 2 in f h x;;
val specialized : int -> int = <fun>

So, what it is useful for? It is very useful in combination with lists,
for example with List.iter or List.map:
# List.map specialized [ 1; 2; 3; 4];;
- : int list = [5; 7; 9; 11]

You see? It allows to prepare a computation and apply it "in batch" to a
data structure. Nearly all data structures (List, Hashtbl, ...) have
iter, fold operators (and other one).

>       (4) What is the difference between saying:
> 
>           let bob =
>               function [] -> []
>                        h :: t -> h
>           ;;
> 
>           and
> 
>           let fun john lst =
>               match lst with
>                     [] -> []
>               |     h::t -> h
>           ;;

You mean:
# let bob default = function
  | [] -> default
  | h :: _ -> h;;
val bob : 'a -> 'a list -> 'a = <fun>

and

# let john default = fun lst ->
  match lst with
    | [] -> default
    | h :: _ -> h;;  
val john : 'a -> 'a list -> 'a = <fun>

No difference.

# bob 3 [];;
- : int = 3
# john 3 [];;
- : int = 3
# bob 3 [ 4 ];;
- : int = 4
# john 3 [ 4 ];;
- : int = 4

In fact, 'function | [] ->...' is exactly the same as 'fun x -> match x
with | [] ->...'. In one case, the x parameter is implicit, in another
case, it is explicit.

Best regards,
d.
-- 
 David.Mentre@inria.fr
 Opinions expressed here are only mine.
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr