The Data Class (define)

Direct Answer

Data.define creates a class for a value made from a fixed set of members. Point = Data.define(:x, :y) gives instances readers, value-based equality, hashing, inspection, deconstruction, to_h, and with, but no generated writers. All members are required when constructing an instance. It is a strong choice for coordinates, money, or parsed commands whose identity is their contents. The immutability is shallow: a member can still refer to a mutable array or string, so nested values must be frozen or copied when the whole value needs to remain unchanged.

Deep Dive & Architecture

Data.define returns a new class whose members are declared once. Instances expose a reader for each member, but no automatic writer. The constructor expects values for every member and rejects missing or unknown ones. This creates a small explicit shape that is useful at boundaries between parsing, validation, and domain behaviour.

Equality follows the value model. Two objects compare equal when they belong to the same generated Data class and their corresponding members compare equal. Compatible eql? and hash behaviour makes such values suitable as hash keys, provided the member values used for hashing do not change underneath them. Identity with equal? remains a separate concept: equal values may still be different objects.

The with method supports change without a writer. It builds a shallow copy using the current members and replaces only the supplied keywords. This is convenient for transformations such as changing a coordinate or currency code while preserving the original value. to_h exposes the named members, and generated deconstruct and deconstruct_keys methods let the object work directly with Ruby pattern matching.

No writer is not the same as deep freezing. If a Data member holds ['new'], the instance cannot point its tags member at a different array through tags=, but callers can still append to the original array. A robust value object accepts already immutable values, freezes a defensive copy during construction, or documents that contained objects remain shared. The right choice depends on ownership and performance needs.

A block passed to Data.define can add behaviour. That is useful for operations derived entirely from the members, such as adding two coordinates or formatting a currency value. It should not quietly introduce setters that defeat the model. Input validation may live in a custom initialize, a factory, or a boundary before construction, but the design should preserve the promise that a constructed value is complete.

Data, Struct, and a hand-written class solve related but distinct problems. Struct offers concise record classes and can expose writable members. Data emphasizes fixed value state. A normal class can hide its representation, accept partial construction, enforce transitions, or use identity-based persistence. Selecting among them starts with the domain contract, not with which option saves the most lines.

Code Example

Money = Data.define(:cents, :currency) do
  def format
    "#{currency} #{cents / 100.0}"
  end
end

price = Money.new(cents: 500, currency: 'INR')
same_price = Money.new(500, 'INR')
revised = price.with(cents: 650)

puts(price == same_price) # true
puts price.format          # INR 5.0
puts revised.format        # INR 6.5
p price.to_h               # { cents: 500, currency: 'INR' }

Common Mistakes & Pitfalls

Trying to mutate a Data object (raises — they're immutable), or using Struct when you want value equality + immutability.