SE-0216: User-defined dynamically callable types has been accepted.
Feedback on the proposal was almost entirely positive on both (1) the idea of supporting dynamically-typed calls and (2) the proposal's specific approach to providing that support. The major concerns expressed were:
Several community members felt that the feature was very complex, especially when combined with the future direction of dynamic member calls. Overall, though, the community seemed to feel that the feature was worth the complexity, and the core team agrees.
Relatedly, several people expressed concern that the design of dynamically-typed member calls might substantially affect the design of this feature, and so it is inappropriate to separate them. The core team feels that the design of dynamically-typed member calls has already been substantially completed, and it has only been delayed due to implementation difficulties. Furthermore, it is unlikely that the final design would want to unify the two dynamically-typed call features, as doing so would undermine a fairly important design goal already expressed in SE-0216: namely, the ability to statically reject structurally invalid calls (such as calls with argument labels in a language that doesn't support them).
There was also concern that Swift was adding support for a dynamically-typed call feature before it added support for a statically-typed call feature; this seems "un-Swifty". The core team feels that a statically-typed
@callablefeature might be interesting but is in practice a totally different feature with very different use cases and requiring a substantially different language design.
Finally, several alternate language designs were explored in the review thread; the core team did not feel that any of them stood out as better than the proposal.
Therefore, the proposal was accepted without modifications. Thank you to everyone who participated in the review.