<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=""><br class=""><div><blockquote type="cite" class=""><div class="">On Feb 19, 2016, at 8:17 AM, Maximilian Hünenberger <<a href="mailto:m.huenenberger@me.com" class="">m.huenenberger@me.com</a>> wrote:</div><br class="Apple-interchange-newline"><div class=""><meta http-equiv="content-type" content="text/html; charset=utf-8" class=""><div dir="auto" class=""><div class=""><span class=""></span></div><div class="">First a general question: Are these behaviors also allowed on normal variables in function bodies (regarding the current proposal)?</div><div class=""><br class=""></div><div class="">----------</div><div class=""><br class=""></div><div class="">The "<b class="">initialValue</b>" should be exposed as closure/function since it can introduce side effects:</div><div class=""><br class=""></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> var [resettable] y = functionWithSideEffects()</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">According to your proposal: "If the behavior includes an <em style="box-sizing: border-box;" class="">initial value requirement declaration</em>, then the identifier <code style="box-sizing: border-box; padding: 0.2em 0px; margin: 0px; border-top-left-radius: 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;" class="">initialValue</code> is bound as a get-only computed property that evaluates the initial value expression for the property"</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">So if I understand it right if I reset "y" "functionWithSideEffects" gets executed.</span></div></div></div></blockquote><div><br class=""></div><div>Perhaps. It would be reasonable to consider initialValue a special accessor.</div><br class=""><blockquote type="cite" class=""><div class=""><div dir="auto" class=""><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">------------</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class="">Can you explain what is the difference between "<b class="">Self</b>" and "<b class="">Value</b>" in the following example?:</div><div class=""><br class=""></div><div class=""><div class="">protocol Fungible {</div><div class=""> typealias Fungus</div><div class=""> func funge() -> Fungus</div><div class="">}</div><div class=""><br class=""></div><div class="">var behavior runcible<Value where Self: Fungible, Self.Fungus == Value>: Value {</div><div class=""> get {</div><div class=""> return self.funge()</div><div class=""> }</div><div class="">}</div></div><div class=""><br class=""></div><div class="">Isn't "Self" the same as "Value"? So it can be rewritten to:</div><div class=""><br class=""></div><div class=""><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">var behavior runcible<Value: Fungible, Value.Fungus == Value>: Value {</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> get {</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> return self.funge()</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> }</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">}</span></div></div></div></div></blockquote><div><br class=""></div><div>`Self` is the type that contains the property. `Value` is the type of the property itself. If you have:</div><div><br class=""></div></div><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;" class=""><div><div>class Foo {</div><div> var [behavior] x: Bar</div><div>}</div><div><br class=""></div></div></blockquote>then behavior's implementation will see Self == Foo and Value == Bar.<br class=""><div><br class=""><blockquote type="cite" class=""><div class=""><div dir="auto" class=""><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class="">----------</span></div><div class=""><br class=""></div><div class="">You've wrote that <b class="">behaviors shouldn't be types/type-like</b> e.g. "var x: lazy<Int>".</div><div class="">Can you mention some disadvantages?</div><div class=""><br class=""></div></div></div></blockquote><div>A few:</div><div><br class=""></div><div>- If the property formally has type `lazy<Int>`, then that impacts overload resolution and method lookup under the property. Even if we introduced implicit conversions, there would inevitably be differences in behavior from a pure `Int` property. It also wouldn't be ABI-resilient to change a property's implementation to be lazy, or to use a different behavior, or to not use a behavior at all.</div><div><br class=""></div><div>- Types aren't quite zero-cost abstractions in Swift today. Unspecialized code would generate type metadata records for every lazy<T> it instantiated at runtime.</div><div class=""><br class=""></div><div class="">- A purely type-encapsulated property delegate design like Kotlin's requires the property delegate instance to carry any information about the declaration it may need for later inside the instance itself; for instance, for a lazy property, the closure that evaluates the initial value would have to be stored in-line inside every instance of every property. The </div><div class=""><br class=""></div><blockquote type="cite" class=""><div class=""><div dir="auto" class=""><div class="">I can't see huge ones. However I don't see any advantages.</div><div class=""><br class=""></div><div class="">Is there any advantage regarding a type-like behavior?</div></div></div></blockquote><div><br class=""></div><div>A type-like behavior could provide an arguably simpler user model, possibly with less impact on the language as a whole.</div><div><br class=""></div><blockquote type="cite" class=""><div class=""><div dir="auto" class=""><div class=""><br class=""></div><div class="">---------</div><div class=""><br class=""></div><div class="">I just remembered recursive value types...</div><div class="">We can even eliminate another keyword: "<b class="">indirect</b>"</div><div class=""><br class=""></div><div class="">implementation:</div><div class=""><br class=""></div><div class="">var behavior indirect<Value>: Value {</div><div class=""> class Ref<T> {</div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> var value: T</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> init(_ value: T) { self.value = value }</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> }</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""><br class=""></span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> var reference: Ref<Value> = Ref(initialValue())</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> get { return reference.value }</span></div><div class=""><span style="background-color: rgba(255, 255, 255, 0);" class=""> set { reference.value = newValue }</span></div><div class="">}</div><div class=""><br class=""></div></div></div></blockquote><br class=""></div><div>Yeah, indirect would be another good use for property behaviors.</div><br class=""><div class="">-Joe</div></body></html>