Vote

Sincerely,

Saagar

Vote: yes!

Solves a big readability issue: one does not need to read the code backwards!

This:

1
2
3
4
5

let fibo n = fst fibo_aux n
  where rec fibo_aux = function
    | 0 -> (1, 1)
    | 1 -> (1, 2)
    | n -> (a, a + b) where let (a, b) = fibo_aux ( n - 1 )

Vs:

1
2
3
4
5
6
7

let fibo n = fst fibo_aux n
  let rec fibo_aux =
    | 0 -> (1, 1)
    | 1 -> (1, 2)
    | n -> let a, b = fibo_aux ( n - 1 )
             (a, a + b)
    fibo_aux n

seems no more or less readable. What am I missing?

When you have many local functions some of which could be mutually recursive or you have many intermediate results, just look at the count less examples in Haskell. It makes the code even more elegant and more readable.

(Here is some code that compiles and works.)

1
2
3
4
5
6
7
8
9
10

 
let rec fibo n = fst (fibo_aux n)
and fibo_aux = function
    | 0 -> (1, 1)
    | 1 -> (1, 2)
    | n -> let a, b = fibo_aux ( n - 1 )
           (b, a + b)

for i in 0..5 do
    printfn "%A" (fibo i)

Does that work with multiple definitions and ones which are mutually recursive?

(Here is some code that compiles and works.)

1
2
3
4
5
6
7
8
9
10
11

 
let rec fibo n = fst (fibo_aux n)

and fibo_aux = function
    | 0 -> (1, 1)
    | 1 -> (1, 2)
    | n -> let a, b = fibo_aux ( n - 1 )
           (b, a + b)

for i in 0..5 do
    printfn "%A" (fibo i)