"error: illegal recursive type; insert an enum or struct in the cycle, if this is desired" not very helpful

[imbaczek]

I've tried to write code that would work like this:

let mut f = some_fn;  // many other some_fns also exist

loop {
    f = f()
}

To make coding some_fn and its friends easier, I wanted to create a type:

type SomeFn = fn() -> SomeFn;

Unfortunately, this results in some type-theoretic error message that isn't really understandable by mere mortals:

<anon>:1:15: 1:29 error: illegal recursive type; insert an enum or struct in the cycle, if this is desired
<anon>:1 type SomeFn = fn() -> SomeFn;
                       ^~~~~~~~~~~~~~

It's not at all clear what 'the cycle' is and where to insert an enum or struct. Turns out that if you know what the compiler is talking about, the fix is simple:

struct SomeFn(fn() -> SomeFn);

// ergonomy suffers
fn fn1() -> SomeFn { println!("1"); SomeFn(fn2) }
fn fn2() -> SomeFn { println!("2"); SomeFn(fn1) }

fn main() {
    let mut f = SomeFn(fn1);
    f = { let SomeFn(ff) = f; ff() };
    f = { let SomeFn(ff) = f; ff() };
}

Output:

1
2

But I was very confused by the message and tried a contraption like this instead:

type SomeFn = fn() -> Option<SomeFn>;

A hint in the error message that points the programmer to the right direction would be very helpful. Ergonomy of the solution is also questionable, but at least it compiles.

[reem]

Since the size of a fn does not depend on its output type, I doubt this is a necessary restriction in the type system.

[nham]

Triage: The error message seems better, but perhaps is still not ideal. Compiling this code:

type SomeFn = fn() -> SomeFn;
fn main() {}

on a recent nightly (rustc 1.1.0-nightly (4b88e8f63 2015-05-11) (built 2015-05-12)) results in:

iss_17539.rs:1:23: 1:29 error: unsupported cyclic reference between types/traits detected
iss_17539.rs:1 type SomeFn = fn() -> SomeFn;
                                     ^~~~~~
note: the cycle begins when processing `SomeFn`...
note: ...which then again requires processing `SomeFn`, completing the cycle.
error: aborting due to previous error

The "processing" language sounds a bit strange to me. Could it maybe say something like "the definition of the type SomeFn depends on SomeFn"?

[steveklabnik]

Triage: same as @nham reported. I agree that we could improve on 'processing'.

[estebank]

Current output is same as above, with new style output:

error[E0391]: unsupported cyclic reference between types/traits detected
 --> src/main.rs:1:23
  |
1 | type SomeFn = fn() -> SomeFn;
  |                       ^^^^^^ cyclic reference
  |
note: the cycle begins when processing `SomeFn`...
 --> src/main.rs:1:1
  |
1 | type SomeFn = fn() -> SomeFn;
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  = note: ...which then again requires processing `SomeFn`, completing the cycle.

[estebank]

Current output:

error[E0391]: cycle detected when processing `SomeFn`
 --> src/main.rs:1:23
  |
1 | type SomeFn = fn() -> SomeFn;
  |                       ^^^^^^
  |
  = note: ...which again requires processing `SomeFn`, completing the cycle

[camelid]

I have an idea on how to improve this error. @rustbot claim