4

I am a complete beginner in OCaml, but I keep seeing code similar to the following in introductory examples

let sum = List.fold ~f:(+.) ~init:0.0

What bothers me in this snippet is the explicit use of List.fold. In most languages I know, the explicit type of the container would be abstracted by the use of an interface, a trait or a typeclass, so that one could reuse this code to sum an array or any other sequential container.

What is the OCaml way to make this more generic?

Andrea
  • 20,253
  • 23
  • 114
  • 183
  • You are using `List` so your function can only take lists. There is no easy way to make it accept any "sequence" like type (it won't typecheck, there is no "any" type in Ocaml). You might consider functors. – Basile Starynkevitch Nov 16 '14 at 18:06
  • 1
    If http://www.lpw25.net/ml2014.pdf happens, in future OCaml's it may become possible to do away with the `List.` part in a lot of cases. – unhammer Nov 17 '14 at 10:12

1 Answers1

7

A more generic solution is to use functors:

module type Foldable = sig 
  type 'a t
  val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
end

module MakeSum(Container : Foldable) = struct
  let sum xs = Container.fold ~f:(+.) ~init:0.0
end

As you may noticed this extra parametricity comes with significant syntactic overhead. Indeed, we can reuse interfaces from Core to reduce it:

module MakeSum(Container : Container.T) = struct
  let sum xs = Container.fold ~f:(+.) ~init:0.0
end

or 

module MakeSum(Container : Container.S1) = struct
  let sum xs = Container.fold ~f:(+.) ~init:0.0
end

Also, as an example, you maybe mostly interested not in parametrizing over container types, but over the summation operation and zero value. This particular example is implemented using first class functors (another option) in OCaml Core library, and every container implements this function:

  (** Returns the sum of [f i] for i in the container *)
  val sum
    : (module Commutative_group.S with type t = 'sum)
    -> t -> f:(elt -> 'sum) -> 'sum

Update

Indeed, at your particular case we can generalize even without functors, since you do not need to know type in order to implement your code. So we can just define generic sum as:

let sum fold xs = fold ~f:(+.) ~init:0.0
ivg
  • 34,431
  • 2
  • 35
  • 63
  • It should be `val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b` in your `Foldable` sig? It seems that you miss a ` -> 'b` – alwaysday1 Jun 29 '18 at 03:36