squalyl (./11) :

let swap_words v =
let low = Int32.logand v 0xffffl in
let high = Int32.logand (Int32.shift_right_logical v 16) 0xffffl in
Int32.logor (Int32.shift_left low 16) high

let's kill myself !

J'ai en effet un petit côté masochiste.
J'aurais pu redéfinir des opérateurs pour que ce bout de code soit plus sympa à lire.

let ( &&& ) = Int32.logand
let ( ||| ) = Int32.logor
let ( >>> ) = Int32.shift_right_logical
let ( << ) = Int32.shift_left

let swap_words v =  ((v &&& 0xffffl) << 16) ||| (v >>> 16)

(à noter que j'ai mis un logand inutile dans le code d'origine)

On peut aussi ouvrir localement le module Int32, ça donnerait

let swap_words v =
  let open Int32 in
  let low = logand v 0xffffl in
  let high = shift_right_logical v 16 in
  logor (shift_left low 16) high

SI je n'avais pas besoin d'entiers 32 bits, mais seulement du type int d'ocaml, ça s'écrirait directement comme ceci:

let swap_words v = ((v land 0xffff) lsl 16) lor (v lsr 16)

Mais ici, j'ai vraiment besoin d'entiers 32 bits (et non 31 ou 63 bits, dépendant de l'architecture). Pour ceux qui rigolent au fond de la classe, le dernier bit est utilisé par le Garbage Collector pour distinguer les entiers des pointeurs.


Je lancerais bien un débat sur les langages, en vous demandant ce que vous reprochez à OCaml, juste par curiosité. Est-ce la syntaxe du langage qui ne vous plait pas? Moi, je trouve assez amusant et réjouissant que le mouvement actuel des langages plus "mainstream" est justement de s'inspirer pas mal des features des langages fonctionnels (lambda en C++ ou Java 8, type génériques, ...)