OCaml compiler check for vector lengths

Question

I was wondering if it is possible to have compile-time check in OCaml to make sure arrays are the correct length. For my problem, I want to verify that two GPU 1-dim vectors are of the same length before doing piecewise vector subtraction.

let init_value = 1
let length = 10_000_000
let x = GpuVector.create length init_value and y = GpuVector.create 9 init_value in
let z = GpuVector.sub v1 v2

In this example I would like it to throw a compile error as x and y are not the same length. As I am a OCaml noob I would like to know how I can achieve this? I am guessing that I will have to use functors or camlp4 (which I have never used before)

Answer 1

You cannot define a type family in OCaml for arrays of length n where n can have arbitrary length. It is however possible to use other mechanisms to ensure that you only GpuVector.sub arrays of compatible lengths.

The easiest mechanism to implement is defining a special module for GpuVector of length 9, and you can generalise the 9 by using functors. Here is an example implementation of a module GpuVectorFixedLength:

module GpuVectorFixedLength =
struct
module type P =
sig
  val length : int
end

module type S =
sig
  type t
  val length : int
  val create : int -> t
  val sub : t -> t -> t
end

module Make(Parameter:P): S =
struct
  type t = GpuVector.t
  let length = Parameter.length
  let create x = GpuVector.create length x
  let sub = GpuVector.sub
end
end

You can use this by saying for instance

module GpuVectorHuge = GpuVectorFixedLength.Make(struct let length = 10_000_000 end)
module GpuVectorTiny = GpuVectorFixedLength.Make(struct let length = 9 end)
let x = GpuVectorHuge.create 1
let y = GpuVectorTiny.create 1

The definition of z is then rejected by the compiler:

let z = GpuVector.sub x y
                        ^
Error: This expression has type GpuVectorHuge.t
       but an expression was expected of type int array

We therefore successfully reflected in the type system the property for two arrays of having the same length. You can take advantage of module inclusion to quickly implement a complete GpuVectorFixedLength.Make functor.

Answer 2

The slap library implements such kind of size static checks (for linear algebra). The overall approach is described this abstract