00232.rb

# How to update values on immutable objects?

class Foo
  def initialize(attrs)
    @x = attrs.fetch(:x)
    @y = attrs.fetch(:y)
    freeze
  end
end

foo = Foo.new(x: 5, y: 7)


# Option 0

# Use x=9. Would be great but doesn't work in Ruby, it will always
# return it's argument so you can chain assignments


# Option 1

class Foo
  attr_reader :x, :y
  def set_x(x)
    self.class.new(x: x, y: y)
  end
end

foo.set_x(9) # => #<Foo:0x007fbe1e7acc48 @x=9, @y=7>
foo          # => #<Foo:0x007fbe1e7acd60 @x=5, @y=7>

# Option 2

Undefined = Object.new
def Undefined.inspect ; 'Undefined' ; end

class Foo
  def x(x = Undefined)
    if x == Undefined
      @x
    else
      self.class.new(x: x, y: @y)
    end
  end
end

foo.x(9) # => #<Foo:0x007fbe1e7ac4c8 @x=9, @y=7>
foo      # => #<Foo:0x007fbe1e7acd60 @x=5, @y=7>


# Option 3

# Same as #1, but with_x, apparently common in Scala/Java


# Option 4

# Anima style, use explicit "update" function

require 'anima'

class Foo
  include Anima.new(:x, :y)
  include Anima::Update
end

foo.update(x: 9) # => #<Foo x=9 y=7>
foo              # => #<Foo x=5 y=7>


# Option 5

# ...
# Any other ideas?

Option 2.

+1 for option #2

Option 1

Option 2.

option 1.

Option 1 looks cleaner than option 2 BUT option 2 seems to be the right way to do it.

+1 for option 2!

Finally the hipster option

def ←x(x)
  self.class.new(x: x, y: @y)
end

Thanks a lot for the input! Some more considerations / tradeoffs
#1

Looks too much like it mutates the object
#2

I actually liked that best at first as well, but after using it extensively I'm coming back from it. It's happened to me a few times that I'm fetching an attribute instead of updating it, so somewhere later down the line a completely unexpected type of object pops up. It can also be very non-obvious when reading the code what it does. Finally the arity check is extra work, can give a small performance hit.
#3

I didn't know that Scala had this convention. It's different from set so more obvious it's not mutating, and already has precendent elsewhere. I think I'll start using this. Thanks @gamache and @eljojo for pointing it out.
#4

A great addition to #3 I think, has the benefit that you can update multiple attributes without allocating intermediate objects. It has been suggested to use with(x: 3) which would go really well with #3.

#3 and #4 :)

Option #4, but I would use copy to make it obvious that you get a new object back 😄

@plexus, reading your comments about it made me switch from #1 to #3 😄

Option #4 is common in plain Scala where it's called copy. Probably for the reason @moonglum stated.

case class Foo(x: Int, y: Int)

val foo = Foo(5, 7) // => Foo(5, 7)
val bar = foo.copy(x = 9) // => Foo(9, 7)

All those options will be a pain with nested, immutable data structures, though. At that point lenses will come in handy. I'm not aware of a library for that in Ruby, though. You can probably do something more convenient with Ruby meta magic anyway, though. I'd think something like this:

Person = Sruct.new :name, :address
Address = Struct.new :name, :number

person = Person.new "Hans", Addres.new("Doubledykes Rd.", 42)

person.copy(
  name: "Richard",
  address: {
    number: 1
  })

As opposed to

person.copy(
  name: "Richard",
  address: person.address.copy(number: 1))

Great to get so many replies on this! It seems some people also name their update / copy / with method new. I've seen this and think I might have actually used it at some point, although I'm not a fan because it's different enough from the class method new to cause confusion.