[swift-evolution] Pitch: Compound name `foo(:)` for nullary functions

[Matthew Johnson]

I like this idea.  I think you made the right choice of syntax given the alternatives considered.  To me `foo(_)` and `foo(:)` equally imply presence of an argument.  The former looks like an anonymous (unnamed) argument and the latter includes the colon which only follows an argument.  Between the two `foo(:)` is the better choice because it doesn’t look like a pattern as has been pointed out.

I’m going to do a little brainstorming to try and come up with something that works and doesn’t imply an argument at all but suspect I’ll come up empty handed.


> On Feb 22, 2017, at 1:05 AM, Jacob Bandes-Storch via swift-evolution <swift-evolution at swift.org> wrote:
> 
> Evolutioniers,
> 
> Compound name syntax — foo(_:), foo(bar:), foo(bar:baz:) — is used to disambiguate references to functions. (You might've used it inside a #selector expression.) But there's currently no compound name for a function with no arguments.
> 
>     func foo() {}  // no compound syntax for this one :(
>     func foo(_ bar: Int) {}  // foo(_:)
>     func foo(bar: Int) {}  // foo(bar:)
>     func foo(bar: String, baz: Double) {}  // foo(bar:baz:)
> 
> Given these four functions, only the first one has no compound name syntax. And the simple reference "let myfn = foo" is ambiguous because it could refer to any of the four. A workaround is to specify a contextual type, e.g. "let myfn = foo as () -> Void".
> 
> I filed SR-3550 <https://bugs.swift.org/browse/SR-3550> for this a while ago, and there was some discussion in JIRA about it. I'd like to continue exploring solutions here and then write up a formal proposal.
> 
> To kick off the discussion, I'd like to propose foo(:) for nullary functions.
> 
> Advantages:
> - the colon marks a clear similarity to the foo(bar:) form when argument labels are present.
> - cutely parallels the empty dictionary literal, [:].
> 
> Disadvantages:
> - violates intuition about one-colon-per-argument.
> - the parallel between #selector(foo(:)) and @selector(foo) is not quite as obvious as between #selector(foo(_:)) and @selector(foo:).
> 
> 
> For the sake of discussion, another option would be foo(_). This was my original choice, and I like that the number of colons matches the number of parameters. However, it's a little less obvious as a function reference. It would preclude _ from acting as an actual identifier, and might conflict with pattern-matching syntax (although it appears functions can't be compared with ~= anyway).
> 
> 
> Looking forward to everyone's bikeshed color ideas,
> Jacob
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170222/433697aa/attachment.html>