SE-0253: Static callables

[dan-zheng]

I'd like to emphasize some naming difficulties regarding "named call-syntax delegate methods", stated above. Do you have ideas for addressing these difficulties?

@dan-zheng

A more serious problem is: naming call-syntax delegate methods becomes very tricky. Consider this example:

struct MachineLearningModel {
    var weight: Float
    var bias: Float
    // Since the method is non-mutating, it should be named `applied(to:)`,
    // not the imperative `apply`.
    @callable func applied(to input: Float) -> Float { ... }
}

let model = MachineLearningModel(...)
let input = ...

// Direct method references now have proper naming.
model.applied(to: input)
// But call-syntax has an awkward label! This is killer.
model(to: input)

// The name `func applied(_ input: Vector<Float>)` fixes the call-syntax,
// but makes direct references un-Swifty:
model.applied(input)

// `monoid.combine(_:)` violates Swift naming guidelines.
// Same problem would apply to `monoid.combined(with:)`.

AFAICT, this naming difficulty exists for any approach involving call-syntax delegate methods with custom names.

This problem doesn't seem to for call-syntax delegate methods ending with ing:

// call func parsing(_ input: String), name is okay
let sexp = parser.parsing("(+ 1 2)")
let sexp = parser("(+ 1 2)")
// call func applying(_ input: Float), not a great name
let prediction = model.applying(2)
let prediction = model(2)

But does exist for methods ending in ed:

// call func parsed(from input: String), name is okay
let sexp = parser.parsed(from: "(+ 1 2)")
let sexp = parser(from: "(+ 1 2)")
// call func applied(to input: Float), name is okay
let prediction = model.applied(to: 2)
let prediction = model(to: 2)

I think ed names sometimes make more sense than ing names.

For example, "function applied to an input" makes sense, but "function applying an input" doesn't. It's more like "user is applying the function to an input".