Open Radar

 
Summary:
Indirect enums are neat. Indirect structs would be valuable for cases where the recursion is via another enum which itself is non-recursive, like Optional. For example one could write List like so:

indirect struct List<T> {
	let uncons: (T, List)?
}

or like so:

struct List<T> {
	indirect let uncons: (T, List)?
}

As a more practical example of this, I often use a struct as the fixpoint of a non-recursive enum:

enum Expression<A> {
	case Var(Int)
	case App(A, A)
	case Abs(Int, A)
}

struct Term {
	// what I want to write:
	// indirect let expression: Expression<Term>

	// what I have to write:
	let expression: Box<Expression<Term>>

	// or:
	let expression: () -> Expression<Term>
}


Steps to Reproduce:
N/A

Expected Results:
N/A

Actual Results:
N/A

Regression:
N/A

Notes:
N/A