<html><head><meta http-equiv="Content-Type" content="text/html charset=utf-8"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">Yes, the `static` is badly overloaded with many different meanings:<div class="">1. static storage (old, from C)</div><div class="">2. static linking (old, from C)</div><div class="">3. final (new in Swift)</div><div class=""><br class=""></div><div class="">That’s why I’m proposing we use a new keyword. My initial suggestion is `type` but I welcome any better alternative.</div><div class=""><br class=""></div><div class="">`overridable` is unnecessary since we already have `final`.<br class=""><div class=""><br class=""><div><blockquote type="cite" class=""><div class="">On Dec 8, 2015, at 7:33 AM, Daniel Valls Estella <<a href="mailto:daniel@upzzle.com" class="">daniel@upzzle.com</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><meta http-equiv="Content-Type" content="text/html charset=utf-8" class=""><div style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space;" class="">Just if it helps someway, in my opinion:<div class=""><br class=""></div><div class="">- static is well known keyword modifier from long ago, but I think is an unfortunate one because is named that way from a complier point fo view, not from a language programmer user.</div><div class=""><br class=""></div><div class="">- I don’t understand static as having an implicit final behaviour. </div><div class=""><br class=""></div><div class="">- It seems we want to mix in one word parallel variables modifiers when is not a goal reduce code typing.</div><div class=""><br class=""></div><div class="">- I found confusing using class keyword instead of static just to note that a static computed variable is not final (same for methods). More when the language provides the final keyword to identify this behaviour.</div><div class=""><br class=""></div><div class="">- why not ?</div><div class=""><br class=""></div><div class=""><div class="">class SomeClass {</div><div class=""><br class=""></div><div class=""> static var storedTypeProperty = "Some value."</div><div class=""> static var computedTypeProperty: Int {</div><div class=""> return 27</div><div class=""> }</div><div class=""> static final var <b class="">nonOverrideable</b>ComputedTypeProperty: Int {</div><div class=""> return 107</div><div class=""> }</div><div class="">}</div><div class=""><br class=""></div><div class="">-But as I mentioned I think static is not a good keyword, only we have been used to it.</div><div class=""><br class=""></div><div class="">Maybe <b class="">shared</b> ? Adding <b class="">overridable</b> in case?</div><div class=""><br class=""></div><div class=""><div class="">class SomeClass {</div><div class=""> shared var storedTypeProperty = “Some value."</div><div class=""> shared var computedTypeProperty: Int {</div><div class=""> return 27</div><div class=""> }</div><div class=""> shared overridable var <b class="">overrideable</b>ComputedTypeProperty: Int {</div><div class=""> return 107</div><div class=""> }</div><div class="">}</div><div class=""><br class=""></div><div class=""><br class=""></div><div class="">Or:</div><div class=""><br class=""></div><div class=""><div class="">class SomeClass {</div><div class=""> shared var storedTypeProperty = “Some value."</div><div class=""> shared var computedTypeProperty: Int {</div><div class=""> return 27</div><div class=""> }</div><div class=""> shared final var <b class="">nonOverrideable</b>ComputedTypeProperty: Int {</div><div class=""> return 107</div><div class=""> }</div><div class="">}</div></div><div class=""><br class=""></div><div class=""><br class=""></div><div class="">Thanks,</div><div class=""><br class=""></div><div class="">Daniel</div><div class=""><br class=""></div><div class="">Fragment de: Apple Inc. “The Swift Programming Language (Swift 2.2)“. iBooks. </div></div><div class=""><br class=""></div><div class=""><br class=""></div><div class="">Fragment de: Apple Inc. “The Swift Programming Language (Swift 2.2)“. iBooks. </div></div><div class=""><br class=""><div class=""><blockquote type="cite" class=""><div class="">El 8 des 2015, a les 5:22, J. Cheyo Jimenez via swift-evolution <<a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a>> va escriure:</div><br class="Apple-interchange-newline"><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class="">Hi Ling,</span></font><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""><br class=""></span></font></div><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class="">In April 2015 you said on your blog that "I was not convinced so I filed an radar." </span></font><span style="background-color:rgba(255,255,255,0);font-size:small" class="">It would seem to me that you are not convinced now either, even after Chris explained that what you are asking for was implemented, reverted and ultimately rejected. I appreciate the fact that you are thinking and worry about the apparent inconstancy. I rather the swift swift team spend more time focusing on ABI stability than on non issue items. Swift is young. Who knows maybe your ideas will make it in a future version<span class=""></span> of Swift. </span></div><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""><br class=""></span></font></div><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""><a href="http://wangling.me/2015/04/unify-type-properties-and-methods.html" class="">wangling.me/2015/04/unify-type-properties-and-methods.html</a></span></font></div><div class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""><a href="https://devforums.apple.com/message/1123857" class="">https://devforums.apple.com/message/1123857</a><br class=""></span></font></div><div class=""><br class=""></div><br class="">On Monday, December 7, 2015, an0 <<a href="mailto:an00na@gmail.com" class="">an00na@gmail.com</a>> wrote:<br class=""><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div style="white-space:pre-wrap" class="">I read that. But that's a long time ago, Swift has evolved a lot since then. I believe the Swift team may have some new ideas about it or at least could take a look at the ideas in this proposal.<br class=""><br class="">Do you have any ideas of your own about this proposal? I'd really like to learn:)</div><br class=""><div class="gmail_quote"><div dir="ltr" class="">On Mon, Dec 7, 2015 at 12:49 PM J. Cheyo Jimenez <<a href="javascript:_e(%7B%7D,'cvml','cheyo@masters3d.com');" target="_blank" class="">cheyo@masters3d.com</a>> wrote:<br class=""></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div class=""><span style="font-size:small;background-color:rgba(255,255,255,0)" class="">ChrisLattner wrote:</span><br class=""></div><div class=""><div style="margin: 0px; padding: 0px; border: 0px; outline: 0px; min-height: 8pt;" class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""> </span></font><br class="webkit-block-placeholder"></div><div style="margin: 0px; padding: 0px; border: 0px; outline: 0px;" class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class="">We considered unifying the syntax (e.g. using "type" as the keyword), but that doesn't actually simply things. The keywords "class" and "static" are good for familiarity and are quite descriptive (once you understand how + methods work), and open the door for potentially adding truly static methods to classes. The primary weirdness of this model is that protocols have to pick a keyword (and we chose "class"), but on balance it is the right tradeoff.</span></font></div><div style="margin: 0px; padding: 0px; border: 0px; outline: 0px; min-height: 8pt;" class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class=""> </span></font><br class="webkit-block-placeholder"></div><div style="margin: 0px; padding: 0px; border: 0px; outline: 0px;" class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class="">-Chris</span></font></div><div style="margin: 0px; padding: 0px; border: 0px; outline: 0px;" class=""><font size="2" class=""><span style="background-color:rgba(255,255,255,0)" class="">Jul 5, 2014 <br class=""></span></font></div></div><div class=""><br class=""></div><a href="https://devforums.apple.com/message/998365#998365" target="_blank" class="">https://devforums.apple.com/message/998365#998365</a><div class=""><br class=""></div><div class=""><br class=""><div class=""></div></div><div class=""><div class=""><br class="">On Monday, December 7, 2015, an0 via swift-evolution <<a href="javascript:_e(%7B%7D,'cvml','swift-evolution@swift.org');" target="_blank" class="">swift-evolution@swift.org</a>> wrote:<br class=""></div></div><div class=""><div class=""><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">The idea is simple but the reasoning is long. So please bear with me.<br class="">
You can read on github for a better reading experience:<br class="">
<a href="https://github.com/an0/swift-evolution/blob/master/proposals/NNNN-unify-static-and-class-keywords.md" target="_blank" class="">https://github.com/an0/swift-evolution/blob/master/proposals/NNNN-unify-static-and-class-keywords.md</a>.<br class="">
<br class="">
## Introduction<br class="">
<br class="">
The coexistence of `static` and `class` keywords for declaring type<br class="">
properties and methods is confusing and causes inconsistency between<br class="">
type and instance member declarations. This document reasons why we<br class="">
don’t need both and suggests we unify them with a better keyword<br class="">
`type`.<br class="">
<br class="">
## Motivation<br class="">
<br class="">
### Confusion<br class="">
<br class="">
One “language enhancement” of [Swift<br class="">
1.2](<a href="https://developer.apple.com/library/ios/releasenotes/DeveloperTools/RN-Xcode/Chapters/xc6_release_notes.html#//apple_ref/doc/uid/TP40001051-CH4-SW6" target="_blank" class="">https://developer.apple.com/library/ios/releasenotes/DeveloperTools/RN-Xcode/Chapters/xc6_release_notes.html#//apple_ref/doc/uid/TP40001051-CH4-SW6</a>)<br class="">
is:<br class="">
> “static” methods and properties are now allowed in classes (as an alias for class final). You are now allowed to declare static stored properties in classes, which have global storage and are lazily initialized on first access (like global variables). Protocols now declare type requirements as static requirements instead of declaring them as class requirements. (17198298)<br class="">
<br class="">
If even the Swift team itself has difficulties in picking one from the<br class="">
two and had to revert its initial decision after several revisions, we<br class="">
know these keywords are indeed confusing.<br class="">
<br class="">
So now protocols use `static` to declare type methods, when a class<br class="">
adapts such protocols, should it implement those static methods, as<br class="">
static methods or class methods?<br class="">
<br class="">
But static means final, right? Does it mean we can not override these<br class="">
methods in subclasses of the conforming class?<br class="">
<br class="">
These kinds of unnecessary confusion and hesitation should be<br class="">
resolved, and could if this proposal is implemented.<br class="">
<br class="">
### Unnecessary and inconsistent differentiation<br class="">
<br class="">
The `class` keyword is only used in classes. In the current<br class="">
implementation of Swift the differences between `class` and `static`<br class="">
are:<br class="">
<br class="">
1. Class properties can only be calculated properties but not stored properties.<br class="">
2. Class methods(also calculated properties) are dynamically<br class="">
dispatched while static ones are statically dispatched.<br class="">
<br class="">
If we can eliminate the differences or find better ways to<br class="">
differentiate we can use one unified keyword instead for declaring<br class="">
type properties and methods.<br class="">
<br class="">
Let’s see.<br class="">
<br class="">
#### Class stored properties VS. static stored properties<br class="">
<br class="">
If you use the `class` keyword to declare a stored property in a class<br class="">
you will get this compiling error:<br class="">
> class stored properties not yet supported in classes; did you mean 'static'?<br class="">
<br class="">
So what are class stored properties? How are they different from<br class="">
static stored properties?<br class="">
<br class="">
As far as I know, class stored properties, if ever implemented in<br class="">
Swift, “would be what Ruby calls ‘class instance<br class="">
variables’”.<sup>[1](<a href="https://twitter.com/UINT_MIN/status/584104757117095936" target="_blank" class="">https://twitter.com/UINT_MIN/status/584104757117095936</a>)</sup><br class="">
<br class="">
So what are class instance variables?<br class="">
<br class="">
The best explanation I can find is this<br class="">
[one](<a href="http://martinfowler.com/bliki/ClassInstanceVariable.html" target="_blank" class="">http://martinfowler.com/bliki/ClassInstanceVariable.html</a>) from<br class="">
Martin Fowler.<br class="">
<br class="">
Do we really want this feature in Swift? “If we didn't already have<br class="">
these, would we add them to Swift 3?"<br class="">
<br class="">
I strongly believe we won’t add it to Swift 3. Actually I believe we<br class="">
will never add it to Swift, because its use cases are so rare which is<br class="">
also why it hasn’t been implemented so far in Swift.<br class="">
<br class="">
If we agree we are not going to support class stored properties, there<br class="">
is and will be only one kind of stored properties for types and we<br class="">
only need one keyword to declare such properties.<br class="">
<br class="">
#### Class methods VS. static methods<br class="">
<br class="">
*Since calculated properties are also methods in essence they are also<br class="">
covered by this section.*<br class="">
<br class="">
The only difference is how methods are dispatched.<br class="">
<br class="">
Let’s see [how we handle it for instance<br class="">
methods](<a href="https://developer.apple.com/swift/blog/?id=27" target="_blank" class="">https://developer.apple.com/swift/blog/?id=27</a>):<br class="">
<br class="">
* Methods are overridable hence dynamically dispatched by default.<br class="">
* In performance critical code use these techniques to restrict this<br class="">
dynamic behavior when it isn’t needed to improve performance:<br class="">
<br class="">
1. Use the `final` keyword when we know that a declaration does<br class="">
not need to be overridden.<br class="">
2. Infer `final` on declarations referenced in one file by<br class="">
applying the `private` keyword.<br class="">
3. Use `Whole Module Optimization` to infer `final` on `internal`<br class="">
declarations.<br class="">
<br class="">
So why abandon this whole system to use another totally different one<br class="">
for differentiating `static dispatch` and `dynamic dispatch` for type<br class="">
methods?<br class="">
<br class="">
If we reuse this system for type methods, not only can we have a<br class="">
consistent design for both instance and type methods, but also we can<br class="">
get rid of the last place where two keywords for type member<br class="">
declarations are needed.<br class="">
<br class="">
## Proposed solution<br class="">
<br class="">
1. Use the keyword `type` to declare type properties and methods.<br class="">
2. Type properties and methods are overridable hence dynamically<br class="">
dispatched by default. Use the `final` keyword or inferred `final` to<br class="">
make them final and statically dispatched, just like instance<br class="">
properties and methods.<br class="">
3. Type properties can be stored or calculated, just like instance properties.<br class="">
<br class="">
As you can see, it is a very simple and elegant design:<br class="">
<br class="">
* Just a single keyword `type` to differentiate type member<br class="">
declarations from instance member declarations. `type` is a good<br class="">
keyword because:<br class="">
<br class="">
1. It is consistent with the wording of the concepts of `type<br class="">
properties` and `type methods`.<br class="">
2. It is never used as a keyword before in Swift, Objective-C or<br class="">
C. There will be no conflicts or overloading of it meanings.<br class="">
* Except for that, how things are declared, differentiated and<br class="">
optimized are exactly the same in both type and instance world. Very<br class="">
consistent.<br class="">
<br class="">
## Comparison with current design<br class="">
<br class="">
* Dynamic Dispatch VS. Static Dispatch<br class="">
<br class="">
```swift<br class="">
// Old<br class="">
class Foo {<br class="">
func dynamicInstanceMethod() {}<br class="">
final func staticInstanceMethod() {}<br class="">
<br class="">
class func dynamicTypeMethod() {}<br class="">
static func staticTypeMethod() {}<br class="">
}<br class="">
```<br class="">
<br class="">
```swift<br class="">
// New<br class="">
class Foo {<br class="">
func dynamicInstanceMethod() {}<br class="">
final func staticInstanceMethod() {}<br class="">
<br class="">
type func dynamicTypeMethod() {}<br class="">
final type func staticTypeMethod() {}<br class="">
}<br class="">
```<br class="">
<br class="">
* Stored Properties VS. Calculated Properties<br class="">
<br class="">
```swift<br class="">
// Old<br class="">
class Bar {<br class="">
static let i = 1<br class="">
<br class="">
class var j: Int {<br class="">
return 1<br class="">
}<br class="">
}<br class="">
```<br class="">
<br class="">
```swift<br class="">
// New<br class="">
class Bar {<br class="">
type let i = 1<br class="">
<br class="">
type var j: Int {<br class="">
return 1<br class="">
}<br class="">
}<br class="">
```<br class="">
<br class="">
* Struct Implementation VS. Class Implementation of Protocol<br class="">
<br class="">
```swift<br class="">
// Old<br class="">
protocol P {<br class="">
static func foo()<br class="">
}<br class="">
<br class="">
struct S: P {<br class="">
static func foo() {}<br class="">
}<br class="">
<br class="">
class C: P {<br class="">
class func foo() {}<br class="">
}<br class="">
```<br class="">
<br class="">
```swift<br class="">
// New<br class="">
protocol P {<br class="">
type func foo()<br class="">
}<br class="">
<br class="">
struct S: P {<br class="">
type func foo() {}<br class="">
}<br class="">
<br class="">
class C: P {<br class="">
type func foo() {}<br class="">
}<br class="">
```<br class="">
<br class="">
## Impact on existing code<br class="">
<br class="">
With the help of a good migration tool, there will be no impact on<br class="">
existing code at all. And the migration rules are very clear and<br class="">
simple:<br class="">
<br class="">
* Map `static` to `type` in protocols.<br class="">
* Map `static` to `type` in structs and enums.<br class="">
* Map `class` to `type` and `static` to `final type` in classes.<br class="">
<br class="">
One concern I can think of is: because type methods are dynamically<br class="">
dispatched by default in the new design, will we forget to do the<br class="">
`final` optimization so the general performance of Swift code become<br class="">
worse?<br class="">
<br class="">
I think it is probably true. But we also forget to do the `final`<br class="">
optimization for instance methods from time to time. Since there are<br class="">
way more instance methods than type methods in most code the<br class="">
performance impact will be very small. Maybe this change is a good<br class="">
opportunity to remind us to do the `final` optimization for instance<br class="">
methods thus even results in a better general performance.<br class="">
<br class="">
And don’t forget we have the tools to automatically infer `final` for<br class="">
us in many cases if we write the proper code and use the proper<br class="">
compiler features.<br class="">
<br class="">
After all, it is mainly on us to write good code to produce good final<br class="">
products. If the system is consistent we’ll have better chances to<br class="">
master it and use it properly.<br class="">
<br class="">
## Alternatives considered<br class="">
<br class="">
Alternatively we could:<br class="">
* Keep using `static` and `class` keywords.<br class="">
* Keep the confusion when implementing `static` protocol requirements<br class="">
using `class` properties and methods in conforming classes.<br class="">
* Keep the inconsistency between type member declarations and instance<br class="">
member declarations.<br class="">
* Keep overloading meanings on the `static` keyword that is already<br class="">
historically overloaded in C and Objective-C with which Swift must mix<br class="">
and match.<br class=""></blockquote></div></div><div class=""><div class=""><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
_______________________________________________<br class="">
swift-evolution mailing list<br class="">
<a class="">swift-evolution@swift.org</a><br class="">
<a href="https://lists.swift.org/mailman/listinfo/swift-evolution" target="_blank" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class="">
</blockquote></div></div></blockquote></div>
</blockquote>
<img src="https://u2002410.ct.sendgrid.net/wf/open?upn=AdkfTiApI80cNEyortTzHW0kAjxqiRekfpEJArOEyyqFpwQRa14kj29zKk9Wzbp4YVvGKIy1f0P77QxCtLkGNJK5ugpUZsEQd-2FjFRVsWx4FUFuEn9hZNVVGB8wJEc6A2kU-2B7lD8beWd9qSlb5vRRdxneAmONl-2BJFsDrQmZn5MGWxWBoYRX9efpaAySudyIqdomUliHoSjUMinifn-2BWe3wPGZTc5gJSh1pyX8m-2F1xtY8-3D" alt="" width="1" height="1" border="0" style="height:1px !important;width:1px !important;border-width:0 !important;margin-top:0 !important;margin-bottom:0 !important;margin-right:0 !important;margin-left:0 !important;padding-top:0 !important;padding-bottom:0 !important;padding-right:0 !important;padding-left:0 !important;" class="">
_______________________________________________<br class="">swift-evolution mailing list<br class=""><a href="mailto:swift-evolution@swift.org" class="">swift-evolution@swift.org</a><br class=""><a href="https://lists.swift.org/mailman/listinfo/swift-evolution" class="">https://lists.swift.org/mailman/listinfo/swift-evolution</a><br class=""></div></blockquote></div><br class=""></div></div></div></blockquote></div><br class=""></div></div></body></html>