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