Long functions in OCaml without where clauses - ocaml

Question

What is the idiomatic way to write the following code in OCaml, with better readability?
let big_function arg =
let big_helper_fn acc = function
| p -> ...
...
...
... foo(arg)
...
...
| _ -> ...
in
let small_helper_1 a b =
...
...
in
let small_helper_2 a b =
...
...
in
fold big_function default_acc
%> small_helper_1 aa1
%> small_helper_2 aa2
Hoisting the inner functions outside may be undesirable for two reasons:
One may need to pass several arguments explicitly instead of direct access (shown with foo(arg) above). This would become cumbersome if there are more arguments, say big_function takes in 3 arguments, big_helper_fn uses all of them and the accumulator is a tuple of 3 elements too.
The helper functions become unnecessarily visible in a larger scope than needed. They might be distracting when one is simply skimming the modules because of the same indentation depth with the important big_function.
If OCaml had a first class where clause this wouldn't be a problem. I did find a PPX and another Github repo for this though.
Please provide a reference to a book/style guide/official documentation/name of a large project which follows the method suggested in your answer.
Edit: The trouble I'm having with this code example is that readability is impaired as the actual definition of big_function is separated by a lot from the original let big_function ... statement at the top. So I'm looking for a more readable idiomatic alternative.

Answer 1

It's hard to tell without knowing what's going on in the helper functions, but generally speaking you can extract them as top-level functions. This has several advantages:
it is easier to read
it reduces the number of variables in scope at every point, reducing risks of referring to the wrong variable (can happen with folds/accumulators)
it makes it possible to test inner functions
There are some disadvantages as well, as you said:
there will be more toplevel functions, so there can be naming conflicts (you can use a module to help with that)
you need to pass more variables explicitly instead of by closures. I'd say that this is an advantage, as this makes coupling more obvious. This is an opportunity to pass less data around (say, a field instead of the whole record).

Answer 2

Your code looks already very OCamlish. Many large projects are written in such a way: see OCaml compiler implementation itself. I like where in Haskell, but personally I am against arbitrary where in non pure language since it may make the ordering of side effects very confusing, which may result into bugs very hard to fix. Restricting definitions of where only to non expansive expressions would be ok but I am not sure the PPX you mention performs such a check or not.
I have never done this, but you could put the "main" task first by using let rec:
let big_function arg =
let rec go () =
fold big_helper_fn default_acc
%> small_helper_1 aa1
%> small_helper_2 aa2
and big_helper_fn acc = function
..
and small_helper_1 a b =
..
and small_helper_2 a b =
..
in
go ()
Or, you could use a local module:
module BigFunctionHelpers(A : sig val arg : t end) = struct
open A
let big_helper_fn acc = function ... foo(arg) ...
let small_helper_1 a b = ...
let small_helper_2 a b = ...
end
let big_function arg =
let module H = BigFunctionHelpers(struct let arg = arg end) in
let open H in
fold big_helper_fn default_acc
%> small_helper_1 aa1
%> small_helper_2 aa2
I do this sometimes when extracting local definitions with many parameters from the parent function.