Re: Lisibilité

Merci, je vais étudier ça de près.

Dans ce cas, je te propose la version suivante de la boucle principale (dans une approche similaire à celle en Elixir et ce que l'auteur à appeler flow programming).

let rec loop stamp samples = match input_char stdin with
| exception End_of_file -> ()
| 'q' -> ()
| '\n' ->
 let new_stamp = Mtime_clock.now () in
 let elapsed = Mtime.(Span.to_s (span stamp new_stamp)) in 
 samples
 |- (if elapsed > reset_delay then Sample.reset else ignore)
 |- Sample.add new_stamp
 |- show_bpm
 |> loop new_stamp
| _ -> loop stamp samples
in loop (Mtime_clock.now ()) (Sample.create sample_size);

Ici c'est dans la même veine que le code Rust que tu ne comprenais pas : c'est à base de pipe (on connecte les flux d'entrée et de sortie de fonctions). Il y a deux types de connecteurs de flux sous forme d'opérateurs infixes : |- qui est proche de la commande unix tee (d'où le choix du symbole) et le |> qui fonctionne comme le pipe | du shell.

Si tu comprends cette commande, alors c'est bon :

$ (for i in $(seq 6); do echo; sleep 0.5; done) | ./taptempo | tee log1 | grep bpm | tee log2 | cut -d' ' -f2,3
120 bpm
120 bpm
120 bpm
120 bpm
120 bpm
$ cat log1
Appuyer sur la touche entrée en cadence (q pour quitter).
[Appuyer encore sur la touche entrée pour lancer le calcul du tempo...]
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm
Au revoir !
$ cat log2
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm
Tempo: 120 bpm

on chaîne les commandes, et on utilise tee pour faire un log de résultats intermédiaires mais sans casser le flux. Comme dans cet exemple OCaml :

let pipeline str =
 str
 |- Printf.printf "la chaîne est: \"%s\"\n"
 |> String.trim
 |- Printf.printf "on a retiré les espaces: \"%s\"\n"
 |> String.length
 |- Printf.printf "la longueur de la chaîne tronquée est: %i\n"
 |> succ
 |> (fun x -> 3 * x)
;;
val pipeline : string -> int = <fun>

on prend une chaîne, on lui retire les espaces en préfixe et suffixe (String.trim), on calcule la longueur de la chaîne ainsi obtenue (String.length) puis on effectue des calculs sur cette valeur entière, le tout en faisant quelques commandes de log entre temps. Exemple d'usage :

pipeline " hello world ! ";;
la chaîne est: " hello world ! "
on a retiré les espaces: "hello world !"
la longueur de la chaîne tronquée est: 13
- : int = 42

L'opérateur infixe |- se définit tout simplement ainsi :

(* on applique f à x, puis on retourne x pour pouvoir chaîner *)
let (|-) x f = (f x : unit); x;;
val ( |- ) : 'a -> ('a -> unit) -> 'a

j'ai juste mis une contrainte de type sur la sortie de f de telle sorte que :

x |- step1 |- step2 |- step3
(* soit bien équivalent à *)
step1 x; step2 x; step3 x

Maintenant, si on reprend la partie du code qui correspond au traitement à effectuer lors de l'appui sur la touche enter :

let new_stamp = Mtime_clock.now () in
let elapsed = Mtime.(Span.to_s (span stamp new_stamp)) in 
samples
|- (if elapsed > reset_delay then Sample.reset else ignore)
|- Sample.add new_stamp
|- show_bpm
|> loop new_stamp

On calcule un nouvelle horodatage et le temps écoulé (en secondes) depuis le dernier appui sur enter; ensuite on enchaîne les traitements sur la file des horodatages :

• si le temps écoulé est supérieur au délai de réinitialisation alors on reset, sinon on ne fait rien ;
• on ajoute l'horodatage à la file (ce qui met à jour, dans la structure, la valeur du tempo) ;
• on affiche le tempo ou le message qui dit d'appuyer une nouvel fois pour lancer le calcul (choix basé sur un type option contenu dans la structure[1]) ;
• on repart dans la boucle avec comme paramètres le nouvel horodatage et la file mise à jour.

C'est beau, c'est fin, ça se mange sans faim. :-)

---

[1]: en arrière plan, le type de la file d'horodatage est

type t = {
 size : int ; (* nombre max d'échantillons *)
 queue : Mtime.t Queue.t ; (* FIFO contenant les timestamps *)
 mutable tempo : float option ; (* Some tempo ou None *)
}

Sapere aude ! Aie le courage de te servir de ton propre entendement. Voilà la devise des Lumières.