I’ve written a little boucing ball program in OCaml with OCamlSDL.
It can be used as a basis to write a Pong game, or any 2D game with a ball bouncing here and there on the screen.
You can download it (images, font, source code and Makefile included) here : bbsdl.tar.gz.

Don’t forget to tell me if you start using it.
By the way, I’ve put some comments in the code for learning purpose, as it has been my first OCamlSDL application so it may be of help for OCaml hackers.

Enjoy.

Several days ago, bluestorm and I started working on monads-related stuffs for Batteries, so that we’d be able to provide a good API for writing and using monads in Objective Caml.

Well, we’ve now written the basis of the future monad-related functions and modules in Batteries.

Of course, we’ve introduced two key monads, keeping Batteries’ spirit : the Option monad and the Enum monad. The first is the equivalent of Haskell’s Maybe monad, whereas the latter is somehow “equivalent” to Haskell’s List monad, with the difference that Batteries’ key data structure is Enum, whereas Haskell’s standard library’s is List.

We’ve also written two key functions for working with monads… If you are familiar with foldM and sequence in Haskell, working over lists, you won’t be lost when using our fold_monad and sequence functions, working over enums.

Hey, wait a minute…

OCaml’s hasn’t typeclasses ! How can we “overload” bind and return and make sequence and fold_monac guess what is the monad they have to work in ?
The answer is the pa_openin syntax extension.

Now, even if we’re working on adding some trivial uses of our monad related stuffs in Batteries’ testsuite, you can take a look at the following sample which works on my local Batteries version…

1
2
3
4
5
6

# let module M = Option.Monad in open Enum.WithMonad(M),M in
       sequence [? Some x |x <- 1--100 ] ;;
- : int Batteries.Enum.t option = Some <abstr>
# let module M = Option.Monad in open Enum.WithMonad(M),M in
       sequence (List.enum [Some 1; None ; Some 3]) ;;
- : int Batteries.Enum.t option = None

By the way, do you think, you, user, the (>>=) operator should be provided by default in our XXX.Monad modules ?

Enjoy !

[Link : my git commit]

Jon Harrop has written many articles in his OCaml Journal, and some of them are related to low-level optimization, which is a very important topic for OCaml developers, as OCaml is a fast functional language and can race against mainstream languages if we help him with our way of writing code, using the compiler, etc.

These articles cover many aspects of optimizations, of different kind :

• Architecture
• Compiler manipulation (flags, etc)
• Allocation
• Deforesting (elimination of intermediate data structures)
• Copies
• Boxing
• Mutation
• Garbage collection
• and so on…

As I’m often doing some “races” between OCaml and other languages (Haskell, C++, Java, …), it has been very interesting for me and I managed to write equivalent applications where OCaml was winning “the race”, together with C++, generally. I’ve been programming in C++ for 6 years now and know many optimizations-related stuffs in C++. But learning this kind of things for OCaml was very interesting but also important for me. Moreover, you know, when you like a programming language, you often want to discover its “underground”, know it just well so that you’ll exactly know what your code will generate.

With functional programming languages, however, it’s easier to have an idea of what will be generated by the compiler, but if you don’t read about such things, you’ll never be able to guess. I think as there’s not that much documentation about OCaml but the official reference manual, Jon’s work is really valuable and is (and would) be of help for many OCaml developers.

These articles have really helped me with discovering OCaml’s underground and were very useful for projects I’m working on, in OCaml of course. Why not for you ?

PS : Comments are closed. Don’t loose your time criticizing anyone. Thanks. But you can e-mail me for discussing it (same adress than on mailing lists).

I’m writing this post because I want to thank and encourage the OCaml community. Indeed, there are many really *great* news this week that you may have seen if you read either Planet OCaml(Core), the Caml mailing list or both.

OCaml and Debian — The first one is a very good one for making OCaml more popular, more easy to install, etc : The OCaml 3.11 Debian package is now in Debian’s official testing repository ! Yeah ! I really congratulate the debian-ocaml maintainer team for the huge work. Considering nearly all installations of Debian stable are for server-like usages, having the package in testing make it easier to install OCaml and get it installed and configured in two seconds for all desktop users of Debian (and Debian-based distributions). Indeed, everything will be done with a single root command :

1

# aptitude install ocaml

That’s all.

OCaml Batteries Included — OCaml Batteries Included Beta 1 is out ! If you still don’t know about it, you should quickly go on its website on OCamlCore, download it and install it and then read the documentation for an introduction and a reference manual of Batteries. You can also take the ocaml-batteries-included package on Debian’s unstable repos.
The Beta 1 is already having its first feedbacks and already provide a huge amount of necessary modules and functions, with some syntax extensions and tools for making programming with Batteries the easier possible ! OCaml was criticized because of its standard library, lacking of many additional stuffs that are in Haskell’s SL. Now, it’s over. Batteries is easy to install, easy to use and provide a great new-standard-library. Come on, test it and give some feedback.

Cheers guys !

BTW, the French government still ignores problem related to the reforms about Universities and Research. They’re killing the whole University concept and system and still ignoring that great Researchers are working for a really bad salary, in bad conditions even if they’ve studied 8 years long at least and that there are people paid much more than what Researchers are, for much easier and cool works… Strikes goes on, we must save our Universities !

It’s been some days I was working on a very interesting project…
Many of you probably know Internet Relay Chat (IRC), in particular the Freenode network. You can access it through an IRC Client, the most known being XChat. The host is irc.freenode.net, on port 6667.
Some of you are used to bots on IRC, often provided by regular IRC users, for their prefered language/tool/etc. There is lambdabot on the #haskell channel, geordi on the ##C++ channel, etc. I’ve also seen that Richard WM Jones had worked on a similar bot for the #ocaml channel, xavierbot. But I wasn’t quite satisfied with it as it was nearly not written in OCaml, and I also wanted to develop one myself.

And… it’s done ! I’m proud to introduce you mlbot, written in OCaml, for OCaml, in 144 LoC for the moment. The code will be online soon on mlbot’s webpage : http://mestan.fr/ocaml/mlbot/

Here is an example of interaction with mlbot :

<Alpounet> > List.fold_right (+) [1;2;3;4;5] 0 ;;
<mlbot> - : int = 15
<Alpounet> > “1″ + 1 ;;
<mlbot> Type Error
<Yoric[DT]> > ” *_o/* MLBot, c’est cool, *\\o_*”;;
<mlbot> - : string = ” *_o/* MLBot, c’est cool, *\\o_*”

For the moment, mlbot is only on the following channels, still on Freenode : #ocaml-fr and #mlbot, but will be soon on #ocaml when I’ll have finished some security improvements.

By the way, my Jane Street Summer Project application has been sent this morning, after many discussions with many people of the OCaml community that have helped and encouraged me : David Teller, Jon Harrop, Xavier Leroy and my computability professor, Grégory Lafitte.
This project will be about HLVM (http://hlvm.forge.ocamlcore.org/) and the OCaml language. Stay tuned !

Have you ever tried compiling with either ocamlc or ocamlopt with the -dlambda option ?

Compiling the following code :

1
2
3
4
5

let f = List.map (fun x -> x+1)
 
let print_list = List.iter (fun x -> Printf.printf " %d " x)
 
let _ = print_list ( f [1;2;3;4;5] )

give the following “lambda code” :

1
2
3
4
5
6
7
8
9
10
11
12
13

(* $ ocamlc -dlambda test.ml *)
(setglobal Test!
  (let
    (f/58
       (function l/59
         (apply (field 10 (global List!)) (function x/60 (+ x/60 1)) l/59))
     print_list/61
       (apply (field 9 (global List!))
         (function x/62 (apply (field 1 (global Printf!)) " %d " x/62))))
    (seq
      (apply print_list/61
        (apply f/58 [0: 1 [0: 2 [0: 3 [0: 4 [0: 5 0a]]]]]))
      (makeblock 0 f/58 print_list/61))))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

(* $ ocamlopt -dlambda las.ml *)
(seq
  (let
    (f/58
       (function l/59
         (apply (field 10 (global List!)) (function x/60 (+ x/60 1)) l/59)))
    (setfield_imm 0 (global Test!) f/58))
  (let
    (print_list/61
       (apply (field 9 (global List!))
         (function x/62 (apply (field 1 (global Printf!)) " %d " x/62))))
    (setfield_imm 1 (global Test!) print_list/61))
  (apply (field 1 (global Test!))
    (apply (field 0 (global Test!)) [0: 1 [0: 2 [0: 3 [0: 4 [0: 5 0a]]]]]))
  0a)

There are many phases in the compilation process, and the lambda generation phase is the last before either bytecode/native code generation.

‘global’ keyword seems to reference modules (Test is the module of my file, because of the name, test.ml).
‘apply’ just does function calls.
‘field’ seems to reference function in modules, like index references values in arrays.

More in the next exploration of the -dlambda option !

What are ropes ?

Ropes are better strings (but heavyweight) :

Moreover, functional purity is preserved, we do never modify the original rope when appending, inserting, removing, etc.
There’ll just be as much as possible data shared between the resulting string and the original one.

However, world is not pink-made. I quote the documentation :

However, Rope is an amortized data structure, and its use in a persistent setting can easily degrade its amortized time bounds. It is thus mainly intended to be used ephemerally. In some cases, it is possible to use Rope persistently with the same amortized bounds by explicitly rebalancing ropes to be reused using balance. Special care must be taken to avoid calling balance too frequently; in the limit, calling balance after each modification would defeat the purpose of amortization.

First, you have to know that a syntax extension is included in Batteries, such that you can create literal ropes instead of strings just by prefixing the litteral string with ‘r’. Let’s now see how we can create a rope containing the “OCaml Batteries Included” string.

1

let my_first_rope = r"OCaml Batteries Included" ;;

The type of ‘my_first_rope’ is Batteries.Rope.t, that’s to say a rope.

Of course, there are many conversions possible from and to ropes. from/to_string, from/to_ustring, of_char, of_uchar, of_latin1, and also many interactions possible with the Enum module. You can also lowercase and uppercase a rope, make a rope of ‘n’ times a given character ‘c’.

As you may expect, there are many string operations included in this module. You can explode a string into a character list, you can split a rope using a given separator, get the character at a given position, remove characters, insert characters, concatenate ropes,

OCaml programming, and more generally functional programming, is empowered by higher order functions. The Rope module uses it, providing us higher order functions like iter[...], range_iter[...], fold, map, filter, filter_map, etc. This way, we can express shortly in our code very complex operations with these higher order functions, which let us work on strings with power, speed and elegance.

There are many other functions that fulfill (personally) all the needs I have from a string manipulation module.

To conclude, there are many “bulk” variants of functions that let us work more efficiently for large chunks of string data.

I think it is useless to give code using Batteries’ ropes, you should rather go to the corresponding documentation page and try it out !

I’m back here to introduce a very promising project : OCaml Batteries Included.

It aims at putting together all the things we may need as OCaml developers in a standard library. It has already put together some existing modules (Extlib, etc) and is now growing up with totally new modules.

The first thing you have to know is that with such standardization efforts, the aim is really to get OCaml programming funnier and easier, with strong and efficient modules helping us in everyday-programming. Moreover, there are some syntax extensions that were really missing in OCaml like the one I’m going to tell about : Comprehension.

What is Comprehension ?

You may probably know better expressions like “List comprehension” ? In fact, OCaml Batteries Included (also called Batteries) provide us something more general than List comprehensions. The aim of such techniques is to, given an expression, a “data domain” and, if wanted, constraints, expand the expression to a set (not in its mathematical sense) of data of the form of the given expression, based on elements that belong to their respective domains and respect their respective constraints. It uses by default an Enum interface for building comprehension of any data container that provide some precise functions. Python or Haskell developers, e.g, may be used to List comprehension. It lets us write such codes, in Haskell :

1

[ x*2 | x <- [1,2,3,4,5,6,7,8,9,10] ]

1

[ x*x + 1 | x <- [1..100] ]

1

[ x*y - x - y | x <- [1..100] , y <- [1..100] , x+y < 40 ]

Now, it is possible in OCaml using Batteries to write such code, in a very similar way :

1

[? x*2 | x <- List : [1;2;3;4;5;6;7;8;9;10] ]

1

[? x*x + 1 | x <- 1--100 ]

1

[? x*y - x - y | x <- 1--100 ; y <- 1--100; x+y < 40 ]

We can achieve such work on Lists, Arrays, Lazy Lists, …

Moreover, we can specify the container type we want to get after the “comprehension”, as we can see in the documentation of Batteries :

1
2

let positive_array_of_enum e =
  [? Array : n | n <- e; n > 0 ]

In fact, the most powerful feature of the comprehension feature in OCaml Batteries Included is that it relies only on the presence of some functions in the data container module :

1
2
3
4
5
6
7

val filter : ('a -> bool) -> 'a t -> 'a t
val concat : 'a t t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val filter_map : ('a -> 'b option) -> 'a t -> 'b t (* used for refutable patterns in generators *)
 
val enum : 'a t -> 'a Enum.t
val of_enum : 'a Enum.t -> 'a t

where ‘a is the type of the values you are enumerating, and ‘a t is the data container type : ‘a array, ‘a Enum.t, ‘a list, etc.

However, providing only enum and of_enum will let you work quite well (but not perfectly) with the comprehension extension, interacting with the Enum module.

I hope this feature has caught your interest.

Here are some links about OCaml Batteries Included and this Comprehension feature.
OCaml Batteries Included’s page on OCamlCore.org
The syntax extensions page of Batteries, including some details about Comprehension
Batteries’ install guide

This project is a community project, so I adress thanks to all the contributors of Batteries, but special thanks go to David Teller for his leading and huge participation on OCaml Batteries Included, and to Gabriel Scherer for his participation and for telling me about this project. And, of course, any contribution to this project is welcome.

Few days ago, I posted about completion for OCaml programers within Emacs, the best editor ever (Ok, ok, “one of the best”), using YASnippets and tuareg-mode. Remember, it was here.

After some discussions with Laurent Le Brun, I post here with a new version of this work.

Indeed, Laurent liked this work and has worked on it, modifying the original indentation in my snippets, and bringing on new snippets (To be honest, I must tell you that the snippets for imperative programming in OCaml were brought in my Laurent — I just could not do such a thing !). Then, I’ve added few things and come back to you with a new archive containing the whole work we’ve done so far.

To download it, just click here.

Thanks and as usual, feedbacks are welcome !

As I currently develop mainly with OCaml (with tuareg-mode on Emacs), and that TABbing is much better (for me) than tuareg’s shortcut keys, I’ve created some snippets for tuareg-mode.

You can find them here : http://mestan.fr/ocaml/emacs/yasnippet-tuareg-mode.tar.gz

To install my snippets, assuming yasnippet is already installed (otherwise, see YASnippet’s page), you have to :
- Uncompress the tarball, getting a “tuareg-mode” folder;
- Move it in /snippets/text-mode/ (mine’s path is : ~/.emacs.d/plugins/yasnippet/snippets/text-mode/tuareg-mode/)
- To get YASnippet work with tuareg-mode, you must add the following to your .emacs (or any init file loaded when emacs starts) BEFORE yasnippet’s loading code :

1
2
3

(add-hook 'tuareg-mode-hook
         '(lambda ()
            (yas/minor-mode-on)))

Then reload your .emacs or restart Emacs.

Now, when typing leti then TAB within tuareg-mode (e.g when editing a .ml file), it should expand to

1

let | in

where | is emacs’s cursor.
Note : typing TAB when cursor is between let and in moves the cursor at in’s right.

Here is the current snippet list I’ve defined :

• begin … end => begin
• module … = functor (…) -> struct … end => functor
• if … then … else …=> if
• let … in … => leti
• match … with … -> … | … -> … => match
• module … = struct … end => module
• module type … = sig … end => sig
• try … with => try

where the part on the left side of “=>” is obtained after having typed the part on the right side of “=>” then TAB.

Feel free to use and customize it, I’ll be glad to hear from you if you use it (by commenting this entry or at alp [AT] mestan [DOT] fr).