As mentioned in my prior message, I currently have a PR open to update the 
generics manifesto ( 
<>).  I removed one topic from that 
update at Doug Gregor’s request that it be discussed on the list first.  

The idea is to add the ability to make default arguments conditional (i.e. 
depend on generic constraints).  It is currently possible to emulate 
conditional default arguments using an overload set.  This is verbose, 
especially when several arguments are involved.  Here is an example use case 
using the overload method to emulate this feature:

protocol Resource {
  associatedtype Configuration
  associatedtype Action
struct ResourceDescription<R: Resource> {
  func makeResource(with configuration: R.Configuration, actionHandler: 
@escaping (R.Action) -> Void) -> R {
    // create a resource using the provided configuration
    // connect the action handler
    // return the resource

extension ResourceDescription where R.Configuration == Void {
  func makeResource(actionHandler: @escaping (R.Action) -> Void) -> R {
    return makeResource(with: (), actionHandler: actionHandler)

extension ResourceDescription where R.Action == Never {
  func makeResource(with configuration: R.Configuration) -> R {
    return makeResource(with: configuration, actionHandler: { _ in })

extension ResourceDescription where R.Configuration == Void, R.Action == Never {
  func makeResource() -> R {
    return makeResource(with: (), actionHandler: { _ in })


Adding language support for defining these more directly would eliminate a lot 
of boilerplate and reduce the need for overloads.  Doug mentioned that it may 
also help simplify associated type inference 

The reason that I call this a pre-pitch and one reason Doug requested it be 
discussed on list is that I haven’t thought of a good way to express this 
syntactically.  I am interested in hearing general feedback on the idea.  I am 
also looking for syntax suggestions.

swift-evolution mailing list

Reply via email to