[Caml-list] Warning 69 (unused record fields) and polymorphic reads

[Andreas Rossberg <rossberg@mpi-sws.org>]

Today, I ran into a slight annoyance with warning 69 (unused record fields). Obviously, the warning does not consider uses of polymorphic operators like `=` or `compare`, which technically are reads of the fields. Unfortunately, it turns out that there are reasonable use cases where these are the _only_ reads, resulting in bogus warnings.

There probably isn't much that can be done about it(?), since such access could hide in any polymorphic function invocation. Hence I didn’t file a bug. But for the record, I thought I'll show the counter example anyway.

Consider code that implements some processing akin to SQL `group by`, as in:
```
SELECT artist, album, COUNT(*), SUM(time), ... FROM Tracks GROUP BY artist, album;
```
Intuitively, this extracts all known albums from a list of track (song) meta data, and computes their total running time, among other values.

Here is a sketch of how to achieve something similar in OCaml:
```
module GroupKey =
   struct
      type t = {artist : string; title : string}
      let compare = compare
   end
module GroupMap = Map.Make(GroupKey)

type track = ...
type acc = ...  (* result type *)
val empty_acc : acc
val accumulate : entry -> acc -> acc  (* combine result *)

let albums =
   tracks
   |> List.fold_left (fun map (entry : track) ->
         let group = {artist = entry.artist; title = entry.title} in
         let acc = Option.value (GroupMap.find_opt group map) ~default: empty_acc in
         GroupMap.add group (accumulate acc entry) map
      ) GroupMap.empty
   |> GroupMap.bindings |> List.map snd
```
The only purpose of the `GroupKey.t` type in this code is to identify entries belonging to the same group. Its fields are read implicitly by `GroupMap.find/add`, which invokes `compare` on them. Yet, this code produces warnings that `artist` and `title` are never read, which technically isn’t quite correct.

In my actual code, the key record has more fields, which is why I didn’t want to replace it with a tuple.

Perhaps there is some annotation magic I’m missing that could be applied to the type definition to suppress the warning?

/Andreas