Why are default arguments not allowed in protocols?

[davdroman (David Roman)]

I like that default keyword as part of the protocol requirements. Should be worth pitching.

[soundflix]

As it seems to work and answers the original question, is this still the way to do it or is there something better now?

[mayoff (Rob Mayoff)]

It’s still the way.

[joshw (Josh)]

Resurrecting this thread - I wonder if we could just have default arguments be sugar for the compiler adding the extension

Would be a nice UX win for protocols IMO

[perihelia (Chad Lechner)]

@Tino

what about

struct MyType: ToolComponentRepository {
  func find(for inVendorID: UUID, page inPage: Int? = 0, pageSize inPageSize: Int) -> EventLoopFuture<[ToolComponent]> {
  // ... 
  } 
}

But then, it won't be obvious what value find would actually use when the page parameter is missing.
We would end up with another incarnation of the problem with protocol extensions, where the choice which method is executed depends on the context (is it an instance of the type, or of the protocol?).

What if conforming implementations were required to use the default values specified in a protocol? One could then write something like:

protocol Foo {
	func foo_defaut_value(param: Int = 123)
}

struct Bar: Foo {
	// func foo_defaut_value(param: Int = default) {  }
}

The = default indicates that the default value is inherited, not added or overridden in any way. This restriction would mean existentials and conforming types always have the same default values, making them easier to reason about from the caller’s point of view.

However, this might break code where a subclass uses different default values from its superclass.

What if two protocols declare a method with identical signature, but different default values?

I don’t know that there’s a good solution for that. It might even be necessary to disallow cases where the default values in both protocols match, since a change in either protocol would prevent conforming to both (if default values are selected statically—Swift’s current behavior).

[gbitaudeau (Guillaume BITAUDEAU)]

If you have multiple arguments, on way to do this is using a struct as argument mix with what @mayoff proposed.

This could look like :

public struct MyFuncParameters {
    var arg: Int
    var arg2: Double

    public static func `for` (arg: Int = 1, arg2: Double = 2.0) -> MyFuncParameters {
        return MyFuncParameters(arg: arg, arg2: arg2)
    }
}

protocol A {
    func myFunc(_ parameters: MyFuncParameters)
}

a.myFunc(.for(arg: 2))