Handle flexible type protocols appropriately

[eholk]

Pipe protocols allow for some rather magical things regarding types. For example, consider this protocol:

proto! type_switch {

    start:send {
        get_int -> wait_thing<int>,
        get_str -> wait_thing<~str>
    }

    wait_thing:recv<T:send> {
        thing(T) -> start
    }

}

Furthermore, start could be polymorphic itself and go to different instances of wait_thing.

This is really flexible. Whether this flexibility is desirable is definitely a valid question.

If we decide we do want this flexibility, the protocol compiler needs to be sure to handle this correctly. I think compiling that protocol as an unbounded protocol would probably work fine, but the bounded version will probably fail in mysterious ways.

If we decide we don't want that flexible of polymorphic protocols, we should change the item macro syntax so we can do this instead:

proto! type_switch<T: send> {

    start:send {
        get -> wait_thing
    }

    wait_thing {
        thing(T) -> start
    }
}

[bblum]

this seems really slick. currently you would have to monomorphise the protocol by hand, right?

[eholk]

@bblum, we already do polymorphic protocols and monomorphization. The problem is the protocol compiler won't handle the more esoteric cases correctly. It's also more verbose, since you have to put type bounds on each state rather than for the whole protocol.

[graydon]

Work on this should wait on resolution to #3658

[emberian]

The pipes compiler was removed, closing.