[swift-evolution] [Pitch] Unifying init parameters with properties

[Haravikk]

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 <swift-evolution at swift.org> 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
> 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/20160418/697b3968/attachment.html>