From: "ufuk (Ufuk Kayserilioglu) via ruby-core" <ruby-core@...>
Date: 2022-12-20T22:02:33+00:00
Subject: [ruby-core:111358] [Ruby master Feature#19000] Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]

Issue #19000 has been updated by ufuk (Ufuk Kayserilioglu).





**Status update**



@alanwu and I reworked the PR at https://github.com/ruby/ruby/pull/6766 to ensure the following:



1. Calls to `.with` with no arguments is valid and returns the receiver as-is. As @eregon said, there is no way to differentiate between no args and empty kwargs, so the ability to do `.with(**hash)` freely won the discussion over.

2. The implementation works correctly with Data objects being frozen now.

3. The implementation checks explicitly for keyword arguments and raises argument error for hashes passed as positional argument, as well.



Apart from the decision on the name, the PR should be good to merge. As @k0kubun said above, I also feel like this should be a part of the Ruby 3.2 release.



If the only blocker is the name, @matz can you pick the final name in the next few days, so that we can ship this with 3.2?



Thank you everyone for the discussion and ideas.



----------------------------------------

Feature #19000: Data: Add "Copy with changes method" [Follow-on to #16122 Data: simple immutable value object]

https://bugs.ruby-lang.org/issues/19000#change-100734



* Author: RubyBugs (A Nonymous)

* Status: Open

* Priority: Normal

----------------------------------------

*As requested: extracted a follow-up to #16122 Data: simple immutable value object from [this comment](http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/109815)*





# Proposal: Add a "Copy with changes" method to Data



Assume the proposed `Data.define` exists.

Seeing examples from the [[Values gem]](https://github.com/ms-ati/Values):



```ruby

require "values"



# A new class

Point = Value.new(:x, :y)



# An immutable instance

Origin = Point.with(x: 0, y: 0)



# Q: How do we make copies that change 1 or more values?

right        = Origin.with(x: 1.0)

up           = Origin.with(y: 1.0)

up_and_right = right.with(y: up.y)



# In loops

movements = [

  [ :x, +0.5 ],

  [ :x, +0.5 ],

  [ :y, -1.0 ],

  [ :x, +0.5 ],

]



# position = Point(x: 1.5, y: -1.0)

position = movements.inject(Origin) do |p, (field, delta)|

  p.with(field => p.send(field) + delta)

end

```



## Proposed detail: Call this method: `#with`



```ruby

Money = Data.define(:amount, :currency)



account = Money.new(amount: 100, currency: 'USD')



transactions = [+10, -5, +15]



account = transactions.inject(account) { |a, t| a.with(amount: a.amount + t) }

#=> Money(amount: 120, currency: "USD")

```



## Why add this "Copy with changes" method to the Data simple immutable value class?



Called on an instance, it returns a new instance with only the provided parameters changed.



This API affordance is now **widely adopted across many languages** for its usefulness. Why is it so useful? Because copying immutable value object instances, with 1 or more discrete changes to specific fields, is the proper and ubiquitous pattern that takes the place of mutation when working with immutable value objects.



**Other languages**



C# Records: ���immutable record structs ��� Non-destructive mutation��� ��� is called `with { ... }`

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/record#nondestructive-mutation



Scala Case Classes ��� is called `#copy`

https://docs.scala-lang.org/tour/case-classes.html



Java 14+ Records ��� Brian Goetz at Oracle is working on adding a with copy constructor inspired by C# above as we speak, likely to be called `#with`

https://mail.openjdk.org/pipermail/amber-spec-experts/2022-June/003461.html



Rust ���Struct Update Syntax��� via `..` syntax in constructor

https://doc.rust-lang.org/book/ch05-01-defining-structs.html#creating-instances-from-other-instances-with-struct-update-syntax



## Alternatives



Without a copy-with-changes method, one must construct entirely new instances using the constructor. This can either be (a) fully spelled out as boilerplate code, or (b) use a symmetrical `#to_h` to feed the keyword-args constructor.



**(a) Boilerplate using constructor**



```ruby

Point = Data.define(:x, :y, :z)

Origin = Point.new(x: 0.0, y: 0.0, z: 0.0)



change = { z: -1.5 }



# Have to use full constructor -- does this even work?

point = Point.new(x: Origin.x, y: Origin.y, **change)

```



**(b) Using a separately proposed `#to_h` method and constructor symmetry**



```ruby

Point = Data.define(:x, :y, :z)

Origin = Point.new(x: 0.0, y: 0.0, z: 0.0)



change = { z: -1.5 }



# Have to use full constructor -- does this even work?

point = Point.new(**(Origin.to_h.merge(change)))

```



Notice that the above are not ergonomic -- leading so many of our peer language communities to adopt the `#with` method to copy an instance with discrete changes.







-- 

https://bugs.ruby-lang.org/

 ______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-core.ml.ruby-lang.org/