This is an experimental implementation of automatically generated anonymous sum types as described in rust-lang/rfcs#2414. The current implementation has many limitations, some of these are avoidable with a bit more effort, others are (as far as I'm aware) unavoidable when implementing via a procedural macro.

There are two major limitations with this implementation that could be avoided by an in-compiler implementation:

• The biggest unavoidable limitation is that the supported traits need to be explicitly specified in this repository. This could potentially be avoided via a generic delegation mechanism such as described in rust-lang/rfcs#2393, although I believe that at a minimum some of the proposed extensions to that RFC would also have to be implemented.

• There needs to be an expression level marker for this implementation, an in-compiler implementation could avoid this by instead collecting all points at which it fails to unify expression types that end up being unified with the return type.

• Only a single anonymous sum type per function is supported. This is because of how the proc-macro walks the function AST and replaces all calls to impl_sum! by a specific wrapper. There's currently no way for this to distinguish between different parts of the return value, and all solutions I can think of would be rather cumbersome to use.

Old limitations that have been dropped:

• No implicit returns.
• Only the top-level of the returned type is supported