[swift-evolution] [Discussion] Static methods as global functions

[Derrick Ho]

-1
On Fri, Mar 10, 2017 at 6:18 AM Haravikk via swift-evolution <
swift-evolution at swift.org> wrote:

> So the topic of global functions like min/max came up on the thread about
> adding a standard clamp method, and it got me to thinking whether there was
> a better way to define most global methods.
>
> Currently for example there are two global functions min and max; very
> useful, and don't make much sense as instance methods, but they're not as
> easily discoverable as a static method declared under relevant type(s). We
> could get around this by defining such functions both as a static method,
> and as a global function, but it means duplicate code and by convention
> only.
>
> An alternative is to remove the need for duplicate methods using a new
> global keyword for a method declaration, telling Swift to define it as both
> a static method *and* a global function. This allows the function to be
> grouped logically under a type, making it a bit neater, but without losing
> the benefit of the global definition. For example:
>
> protocol Comparable {
> global func min(_ a:Self, _ b:Self) -> Self { return a < b ? a : b }
> global func max(_ a:Self, _ b:Self) -> Self { return a > b ? a : b }
> }
>
> With this single definition both of the following are now valid:
>
> let min = Int.min(1, 3)
> let max = max(5, 10)
>
> In the second case, Swift looks at all global definitions for "max" in
> order to locate the best match, leading it to Int.max.
>
> It's a relatively small change, but helps with neatness. It may also be
> good for consistency if we ever get the ability to define operators within
> types (though I'm not sure where we are with that?), as they could
> potentially just use the same format like-so:
>
> struct MyType : Equatable {
> global func == (_ a:MyType, _ b:MyType) -> Bool { /* Determine equality */
> }
> }
>
> I just think it's a neater way to do this than currently requiring
> separate declarations for the static and global versions, especially since
> one usually just calls the other anyway, anyone have any thoughts?
>
> I normally argue against new keywords, but in this case it may be
> justified, as I considered an attribute but it would only end up requiring
> static anyway, so it seemed neater to just have a new category "above"
> static that is both static and global, since a global non-static doesn't
> make any sense. However, one advantage of a @global attribute is that it
> could potentially take a different name for the global function, so I could
> (but probably wouldn't) define something like:
>
> @global("min") static func smallerOfTwo(_ a:Self, _ b:Self) -> Self {
> return a < b ? a : b }
>
> So here, although the method name is smallerOfTwo, it is exposed globally
> as "min". Though I don't know much need there would be for something like
> that.
> _______________________________________________
> 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/20170310/9677ced7/attachment.html>