Reusing polymorphic function in ocaml not working

Question

I was creating a simple concat, and thought that this might work.

(** [foldl fun init lst] the [fun] gets applied, left to right: 
 {[foldl fun init [e1;e2;e3;e4] -> fun e4 (fun e3 (fun e2 (fun e1 init)))]} *)
let foldl func = let rec foldl accum = function  
                   |[] -> accum
                   |(head :: tail) -> foldl (func head accum) tail
  in foldl 

(** [reverse lst] reverses [lst]. Useful for tail recursive list building functions *)      
let reverse : 'a list -> 'a list = foldl (fun a b -> a :: b) []
let concat lst = lst |> reverse |> foldl (foldl (fun a b -> a :: b)) [] |> reverse

This only works when I try this

(** [foldl fun init lst] the [fun] gets applied, left to right: 
 {[foldl fun init [e1;e2;e3;e4] -> fun e4 (fun e3 (fun e2 (fun e1 init)))]} *)
let foldl func = let rec foldl accum = function  
                   |[] -> accum
                   |(head :: tail) -> foldl (func head accum) tail
  in foldl 

(** [reverse lst] reverses [lst]. Useful for tail recursive list building functions *)      
let reverse : 'a list -> 'a list = foldl (fun a b -> a :: b) []
let reverse' : 'a list -> 'a list = foldl (fun a b -> a :: b) []
let concat lst = lst |> reverse' |> foldl (foldl (fun a b -> a :: b)) [] |> reverse

I heard this was related to the value restriction, but I don't know how to make it work. What should I do?

Chris · Accepted Answer · 2025-10-16 23:12:48Z

3

You can't use partial application in a place like this without running head-first into the value restriction. As noted, you can eta-expand to avoid this.

If you resolve this there's no need for both reverse and reverse'.

I also wanted to note that your foldl is a bit cumbersome. There's no need to define a local function vs. just passing multiple arguments. Is this "lying to ourselves" about how OCaml conceptually works ? Maybe. It's also cleaner and easier to read.

let rec foldl func accum = function
  | [] -> accum
  | head::tail -> foldl func (func head accum) tail

answered Oct 16 at 23:12

Chris

38.2k6 gold badges33 silver badges59 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Ashok Kimmel Oct 17 at 16:20

I didn't want to repeatedly pass func into foldl, I was taking inspiration from haskell, which has a lot of functions to find like mine in Data.List. Are there any other things that I need to know?

Ashok Kimmel Oct 17 at 16:22

Is there any performance penalty? Or does tail-call optimization solve it?

Naïm Camille Favier · Accepted Answer · 2025-10-16 21:07:48Z

3

As mentioned in the manual, one way around this is to η-expand the function:

# let reverse : 'a list -> 'a list = fun x -> foldl (fun a b -> a :: b) [] x;;
val reverse : 'a list -> 'a list = <fun>

answered Oct 16 at 21:07

Naïm Camille Favier

2,3001 gold badge14 silver badges20 bronze badges

Collectives™ on Stack Overflow

Reusing polymorphic function in ocaml not working

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related