Automatically generate conversion functions from OCaml enums to integers

Learning
1

Suppose you have an OCaml enumeration of the kind:

type enum = A | B | C | D

Is there a standard way to easily derive (or implement with minimal redundancy) the following functions:

let int_of_enum = function
    | A -> 0
    | B -> 1
    | C -> 2
    | D -> 3

let enum_of_int = function
    | 0 -> A
    | 1 -> B
    | 2 -> C
    | 3 -> D
2

If you want to go the unsafe route, I would guess that this is correct :

let int_of_enum (e:enum) = 
  (Obj.magic e : int)

let enum_of_int (i:int) = 
   (Obj.magic i : enum)

I have no idea what the range will be though, or how the constructors will be ordered.

3

This solution works indeed on my ocaml version and it has the benefit of being very fast. Is anyone aware of a safer solution that is guaranteed not to break in the future?

It seems to me that there is a pretty natural coding pattern underlying my question. For example, a simple and efficient way to represent a function of type enum -> t is to simply store an array of t values of size the length of the enum. The enum_of_int and int_of_enum functions would then be needed to manipulate such a representation.

4

You may be interested in ppx_deriving.enum:

# #require "ppx_deriving.enum" ;;
# type t = A | B | C | D [@@deriving enum] ;;

type t = A | B | C | D
val min : int = 0
val max : int = 3
val to_enum : t -> int = <fun>
val of_enum : int -> t option = <fun>
5

Thanks, this is exactly what I was looking for!
I knew ppx_enumerate but not ppx_enum.

6

The only thing that is possibly missing from this solution in my opinion is an of_enum_exn: int -> t function that does not allocate an option and can be compiled into a quasi no-op by the compiler. But I am nitpicking here. :slight_smile: