Comment author: @diml

I had a look at this. I wrote two small functions to check if a type/module is recursive and select the rec_status field in the implementation of "show_XXX" according to this. The branch is here:

https://github.com/diml/ocaml/tree/fix-toplevel-type-and-module-printing

It seems to work, there is just a bug when calling #show_module multiple times that I haven't fixed yet.

Another approach would be to record the recursive status inside the type/module declaration, so that the output of #show matches what the user wrote. Currently you get nonrec if the type is not in fact recursive:

# type t = int;;
type t = int
# #show t;;
type nonrec t = int

Comment author: @yallop

Thanks for looking at this.

I don't think that preserving what the user wrote is especially worthwhile; the important thing is that what is printed is as close to correct as possible. If it's not too difficult, I think the best scheme would be:

• default to printing 'module' and switch to 'module rec' where the module type mentions the module name. I think this is what you've implemented already.

• default to printing 'type' and switch to 'type nonrec' where necessary (i.e. where the type definition would mean something different if you left out the 'nonrec'). This is a bit different to your current scheme.

For actually-recursive types there's no difference between your current scheme and the proposal above. And there's no difference for types that actually need 'nonrec', either. The only difference is for non-recursive types that can be written equivalently either with or without 'nonrec', such as 'type t = int', and it's best if those are printed as simply as possible.

Comment author: voglerr

Is there something blocking this?
Had a bit of a problem explaining this to students...

default to printing 'type' and switch to 'type nonrec' where necessary
best if those are printed as simply as possible

Sounds perfect.

This issue has been open one year with no activity. Consequently, it is being marked with the "stale" label. What this means is that the issue will be automatically closed in 30 days unless more comments are added or the "stale" label is removed. Comments that provide new information on the issue are especially welcome: is it still reproducible? did it appear in other contexts? how critical is it? etc.

The code in the problem report now works in trunk:

# #show list;;
type 'a list = [] | (::) of 'a * 'a list
# type t = T of t;;
type t = T of t
# #show t;;
type t = T of t

But printing types defined using nonrec doesn't use nonrec, so there's still a bug:

# type nonrec list = T of int list;;
type nonrec list = T of int list
# #show list;;
type list = T of int list

I added a known-bug test for these faulty (non)use of rec by the #show command in f7ec223.

One slightly strange behavior of the test, unrelated to the present discussion (it is not with #show but with standard toplevel printing) is the scoping-incorrect use of a M/2 stamp in the second declaration below (cc @Octachron ; I believe this is a known and tolerated misbehavior but I couldn't find an issue to reference).

# module M : sig end = struct end;;
module M : sig  end
# module rec M : sig type t = Loop of M.t end = struct type t = Loop of M.t end;;
module rec M : sig type t = Loop of M/2.t end

The printing issue is an instance of #8917. There is a fix for the bug, #8929, waiting for a review too.

This issue has been open one year with no activity. Consequently, it is being marked with the "stale" label. What this means is that the issue will be automatically closed in 30 days unless more comments are added or the "stale" label is removed. Comments that provide new information on the issue are especially welcome: is it still reproducible? did it appear in other contexts? how critical is it? etc.

This is not quite fixed yet: @gasche's broken_rec_in_show.ml tests still fail in trunk.

All examples are fixed by #10416 (and this time without fatal errors when -short-paths is enabled). There are still some case that are not perfectly printed, when the displayed fragment of a group of mutually recursive definitions is not self-recursive. But that only happens for unprintable type definitions (e.g.

type t;;
type u = [ `U of t]
type t = A of [ u | `V ] | B of s
and s = C of t;;
#show t;;

) and recursive modules.

Thank you, @Octachron!