Enumerator

[Ngoguey42]

What would make my life easier is an enumerator of all the possible values (bit permutations) that the value of a typerepr can take.

This would look like deriving's enum and repr's random.

The enumerator could take the form of an OCaml sequence to deal with the fact that the user may be requesting an enumeration on something of almost infinite size (e.g. an int64).

type 'a enumerate = ('a -> 'a Seq.t) staged

val enumerate : 'a t -> 'a enumerate

---

My (simplified) use case, where such a feature would be greatly appreciated:

    module M = struct
      type tree =
        [ `Empty
        | `Remove ]
      [@@deriving repr]

      type tag =
        [ `Tree of tree
        | `Find_tree
        | `Add
        | `Init ]
      [@@deriving repr]
    end

    type t = [
      [ `M of M.tag
      | `Commit
      | `Block ]
    [@@deriving repr]

    let all = [
        `M (`Tree `Empty);
        `M (`Tree `Remove);
        `M `Find_tree;
        `M `Init;
        `Commit;
        `Block;
        (* This was cumbersome to write, I even missed one! *)
    ]

[craigfe]

Agreed. I've thought about writing one of these a few times, but haven't yet got around to it.

I think there's also a good use-case for having a deriver that goes straight to 'a list and works only for finite types, so that the generation work can be done at initialisation time. (I believe the JS convention for the finite enumeration is all, as you've written.)