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

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

[Andreas Rossberg]

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

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

[Florian Angeletti]

[-- Attachment #1: Type: text/plain, Size: 3030 bytes --]

Those warnings can be suppressed on the type definition by adding a 
`@@warning` attribute

    module M: sig type t end = struct
       type t = { x:int; y:int } [@@warning "-unused-field"]
    end

With this attribute, the compiler will not register those fields for the 
usage checker and thus no unused
warning fields will be emitted for the fields `x` and `y`

For this specific warning, the compiler even supports disabling the 
usage checker field-by-field.
For instance, this code will only disable the warning for the `M.x` 
field, and thus warns

    module M: sig type t end = struct
       type t = { x:int[@warning "-unused-field"] ; y:int }
    end

  that the field `y` is being unused while omitting the check for the  
field `x`.

— Florian.

Le 03/06/2025 à 11:11, Andreas Rossberg a écrit :
> 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
>

[-- Attachment #2: Type: text/html, Size: 3709 bytes --]

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

[Andreas Rossberg]

Excellent, thanks Léo and Florian! This is the information I was looking for (and can’t find in the manual ;) ).

/Andreas


> On 3. Jun 2025, at 11:23, Florian Angeletti <octa@polychoron.fr> wrote:
> 
> Those warnings can be suppressed on the type definition by adding a `@@warning` attribute
> module M: sig type t end = struct
>   type t = { x:int; y:int } [@@warning "-unused-field"]
> end
> With this attribute, the compiler will not register those fields for the usage checker and thus no unused
> warning fields will be emitted for the fields `x` and `y`
> 
> For this specific warning, the compiler even supports disabling the usage checker field-by-field.
> For instance, this code will only disable the warning for the `M.x` field, and thus warns
> module M: sig type t end = struct
>   type t = { x:int[@warning "-unused-field"] ; y:int }
> end
>  that the field `y` is being unused while omitting the check for the  field `x`.
> 
> — Florian.
> 
> Le 03/06/2025 à 11:11, Andreas Rossberg a écrit :
>> 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
>> 
>> 
>