let john = {firstName="John"; lastName="Doe"}
let alice = {john with FirstName="Alice"}
Current way to do this in Swift is:
let john = (firstName:"John", lastName:"Doe")
var alice = john
alice.firstName = "Alice"
I think this is better modeled in Swift as something like:
let john = (firstName:"John", lastName:"Doe")
let alice = with(john) {
$0.firstName = "Alice"
}
`with` would be something like:
func with<Value>(value: Value, function: Value throws -> Void) rethrows -> Value {
var mutableValue = value
return try function(&mutableValue)
}
This would serve many different purposes:
* If the value is a value type, allows you to return a modified copy
* Allows you to customize a value's properties immediately after initializing it, which many people have asked for
* Acts as a `tap` function when the block doesn't change the value (see <Class: Object (Ruby 2.3.0))
I cannot remember any use of such a feature but instead of a language feature there is also a reasonable library solution:
// inspired by the lens idea (of Joe Groff I think)
// there is probably a better name
func lens<T>(value: T, lensClosure: inout T -> ()) -> T {
var value = value
lensClosure(&value)
return value
}
// usage
let john = (firstName:"John", lastName:"Doe")
let alice = lens(john) { $0.firstName = "Alice" }
Kind regards
- Maximilian
···
Am 23.03.2016 um 09:06 schrieb Zsolt Szatmári via swift-evolution <swift-evolution@swift.org>:
Dear All,
The only thing I am really missing right now from Swift is described as following. This works in some other languages, e.g. F#, Kotlin, and Haskell.
let john = {firstName="John"; lastName="Doe"}
let alice = {john with FirstName="Alice"}
Current way to do this in Swift is:
let john = (firstName:"John", lastName:"Doe")
var alice = john
alice.firstName = "Alice"
This might seem to be a nuance, but it's more cumbersome (especially if one wants to do this frequently), and we are left with a var at the end.
Also, this idea rhymes with the current direction of removing var arguments from functions.
What do You think? Thank You.
I like this. I’m always annoyed when I need var just because I can’t get all my initialization done with let.
- Will
···
On Mar 23, 2016, at 2:32 AM, Brent Royal-Gordon via swift-evolution <swift-evolution@swift.org> wrote:
let john = {firstName="John"; lastName="Doe"}
let alice = {john with FirstName="Alice"}
Current way to do this in Swift is:
let john = (firstName:"John", lastName:"Doe")
var alice = john
alice.firstName = "Alice"
I think this is better modeled in Swift as something like:
let john = (firstName:"John", lastName:"Doe")
let alice = with(john) {
$0.firstName = "Alice"
}
`with` would be something like:
func with<Value>(value: Value, function: Value throws -> Void) rethrows -> Value {
var mutableValue = value
return try function(&mutableValue)
}
This would serve many different purposes:
* If the value is a value type, allows you to return a modified copy
* Allows you to customize a value's properties immediately after initializing it, which many people have asked for
* Acts as a `tap` function when the block doesn't change the value (see <Class: Object (Ruby 2.3.0))
On Wed, Mar 23, 2016 at 2:28 PM, William Dillon via swift-evolution < swift-evolution@swift.org> wrote:
I like this. I’m always annoyed when I need var just because I can’t get
all my initialization done with let.
- Will
> On Mar 23, 2016, at 2:32 AM, Brent Royal-Gordon via swift-evolution < > swift-evolution@swift.org> wrote:
>
>> let john = {firstName="John"; lastName="Doe"}
>> let alice = {john with FirstName="Alice"}
>>
>> Current way to do this in Swift is:
>>
>> let john = (firstName:"John", lastName:"Doe")
>> var alice = john
>> alice.firstName = "Alice"
>
> I think this is better modeled in Swift as something like:
>
> let john = (firstName:"John", lastName:"Doe")
> let alice = with(john) {
> $0.firstName = "Alice"
> }
>
> `with` would be something like:
>
> func with<Value>(value: Value, function: Value throws -> Void)
rethrows -> Value {
> var mutableValue = value
> return try function(&mutableValue)
> }
>
> This would serve many different purposes:
>
> * If the value is a value type, allows you to return a modified copy
> * Allows you to customize a value's properties immediately after
initializing it, which many people have asked for
> * Acts as a `tap` function when the block doesn't change the value (see < Class: Object (Ruby 2.3.0))
>
> --
> Brent Royal-Gordon
> Architechies
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution@swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
I would very much like a standardized way of doing this. I am currently writing a game implementation in a functional style and the syntax for updating fields in pretty clunky. I’d like to avoid having to explicitly use var’s at all to accomplish it.
···
On Mar 23, 2016, at 7:29 AM, James Campbell via swift-evolution <swift-evolution@swift.org> wrote:
Yeah a way to have a function that mutates a struct return a new copy with that mutation would be awesome ! Rather than mutating in place.
On Wed, Mar 23, 2016 at 2:28 PM, William Dillon via swift-evolution <swift-evolution@swift.org <mailto:swift-evolution@swift.org>> wrote:
I like this. I’m always annoyed when I need var just because I can’t get all my initialization done with let.
- Will
> On Mar 23, 2016, at 2:32 AM, Brent Royal-Gordon via swift-evolution <swift-evolution@swift.org <mailto:swift-evolution@swift.org>> wrote:
>
>> let john = {firstName="John"; lastName="Doe"}
>> let alice = {john with FirstName="Alice"}
>>
>> Current way to do this in Swift is:
>>
>> let john = (firstName:"John", lastName:"Doe")
>> var alice = john
>> alice.firstName = "Alice"
>
> I think this is better modeled in Swift as something like:
>
> let john = (firstName:"John", lastName:"Doe")
> let alice = with(john) {
> $0.firstName = "Alice"
> }
>
> `with` would be something like:
>
> func with<Value>(value: Value, function: Value throws -> Void) rethrows -> Value {
> var mutableValue = value
> return try function(&mutableValue)
> }
>
> This would serve many different purposes:
>
> * If the value is a value type, allows you to return a modified copy
> * Allows you to customize a value's properties immediately after initializing it, which many people have asked for
> * Acts as a `tap` function when the block doesn't change the value (see <Class: Object (Ruby 2.3.0))
>
> --
> Brent Royal-Gordon
> Architechies
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution@swift.org <mailto:swift-evolution@swift.org>
> https://lists.swift.org/mailman/listinfo/swift-evolution