I agree with the intent of this, but perhaps not the solution; sticking with
the original example, simply being able to have an implied initialiser for
classes, as we have for structs, would be enough, for example:
class Foo {
let foo:String
let bar:String
let baz:Int
var barCount:Int { return self.bar.characters.count } // Computed
property, could be lazy instead I think?
// Implied init(foo:String, bar:String, baz:Int)
}
Personally I’m not a fan of the syntax, I wonder if an #autoinit or such
directive could be used to indicate properties that should be initialised
automatically where possible, like so:
class Foo {
#autoInit let foo:String
#autoInit let bar:String
#autoInit let baz:Int
let barCount:Int
init(foo:String, bar:String, baz:Int) {
// foo, bar, baz handled behind the scenes
self.barCount = bar.characters.count
}
}
(or it could be on the parameters of the init function, might be clearer that
way)
Just an idea anyway
> On 16 Apr 2016, at 14:17, Jonathan Hull via swift-evolution
> <[email protected]> wrote:
>
> Since we know the types of the properties, how about we replace the type in
> the signature with either an indication that the property should be
> automatically set, or better yet, the property which should be set:
>
> class Foo
> {
> let foo : String
> let bar : String
> let barCount : Int
> let baz : Int
>
> init(foo: self.foo, bar: self.bar, baz: self.baz)
> {
> self.barCount = bar.characters.count
> }
> }
>
> That way you don’t always have to have the init’s parameter names match the
> names of the properties they set (even though they often would). We could
> also allow a leading dot as a shorthand for ‘self.’
>
> init(foo: .foo, bar: .bar, baz: .baz)
>
> I think I like explicit ‘self.’ better, but that may just be my preference.
> In either case, the generated interface would show the actual type.
>
> // init(foo: String, bar: String, baz: Int)
>
> Thanks,
> Jon
>
>> This is a common pattern for initialisers at the moment:
>>
>> class Foo
>>
>> {
>>
>> let foo : String
>>
>> let bar : String
>>
>> let barCount : Int
>>
>> let baz : Int
>>
>>
>> init(foo: String, bar: String, baz: Int)
>>
>> {
>>
>> self.foo = foo
>>
>> self.bar = bar
>>
>> self.baz = baz
>>
>> barCount = bar.characters.count
>>
>> }
>>
>> }
>>
>> This involves a lot of using 'self.'. For those who prefer not to use
>> 'self.' explicitly everywhere, this is probably the main place it gets
>> used. It's a lot of boilerplate code.
>>
>> How would it be if, like default variables, we could pack some of that
>> information into the argument tuple, and unify parameters with properties
>> immediately?
>>
>> class Foo
>>
>> {
>>
>> let foo : String
>>
>> let bar : String
>>
>> let barCount : Int
>>
>> let baz : Int
>>
>>
>> init(self.foo: String, self.bar: String, self.baz: Int)
>>
>> {
>>
>> barCount = bar.characters.count
>>
>> }
>>
>> }
>>
>> Less boilerplate, more focus on the properties which need to be generated.
>>
>> Thoughts?
>
> _______________________________________________
> swift-evolution mailing list
> [email protected]
> https://lists.swift.org/mailman/listinfo/swift-evolution
_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
