What is Struct and when do you use it?

Question

Accepted Answer

**`Struct`** is a built-in Ruby class for quickly creating simple classes that bundle together a few **attributes** — generating the constructor, accessors, equality, and more automatically. It's a concise way to define lightweight data classes without writing a full class.

## The problem Struct solves

```ruby
# ❌ a full class for simple data is verbose boilerplate
class Point
  attr_accessor :x, :y
  def initialize(x, y)
    @x = x
    @y = y
  end
  def ==(other)
    x == other.x && y == other.y
  end
end

# ✅ Struct does all of that in ONE line
Point = Struct.new(:x, :y)
```

`Struct.new(:x, :y)` generates a class with a constructor, `attr_accessor`s for `x` and `y`, value-based equality, `to_s`, and more — eliminating the boilerplate of a simple data class.

## Using a Struct

```ruby
Point = Struct.new(:x, :y)

p = Point.new(1, 2)
p.x              # 1 — accessor generated
p.y = 5           # setter generated
p == Point.new(1, 5)   # true — VALUE-based equality (generated)
p.to_a            # [1, 5] — convertible

# Structs can have methods too
Point = Struct.new(:x, :y) do
  def distance_from_origin
    Math.sqrt(x**2 + y**2)
  end
end
Point.new(3, 4).distance_from_origin   # 5.0
```

Structs provide accessors and **value-based equality** (two structs with equal attributes are equal — convenient for data objects), and you can add custom methods in a block.

## Keyword-initialized structs and Data (Ruby 3.2)

```ruby
# keyword arguments (clearer for many fields)
Point = Struct.new(:x, :y, keyword_init: true)
Point.new(x: 1, y: 2)

# Data (Ruby 3.2+) — an IMMUTABLE alternative to Struct (for value objects)
Point = Data.define(:x, :y)
p = Point.new(1, 2)
p.x              # 1 (read-only — immutable)
p2 = p.with(x: 5)  # non-destructive copy with a change
```

Ruby 3.2's **`Data`** is an immutable variant of Struct — ideal for value objects that shouldn't change.

## Why it matters

`Struct` is a useful Ruby feature for **quickly creating simple data classes** without boilerplate, so understanding it is valuable for writing concise, clean Ruby.

The core benefit is eliminating the repetitive code a simple data-holding class requires — instead of writing a full class with a constructor, `attr_accessor`s, and equality, `Struct.new(:x, :y)` generates all of that in one line, including **value-based equality** (two structs with equal attributes are equal, which is what you want for data objects and differs from regular classes' reference equality).

This makes Struct ideal for lightweight data structures, value objects, returning grouped values from methods, and simple records where a full class would be overkill — a practical productivity tool that keeps code concise.

Understanding Struct (concise data classes with generated accessors and value equality, plus the ability to add custom methods), keyword-initialized structs (clearer for many fields), and the modern **`Data`** class (Ruby 3.2's immutable alternative for value objects that shouldn't change) is valuable knowledge for modeling simple data elegantly.

Since defining small data classes is a common need, and since Struct (and Data) provide a concise, idiomatic way to do it with useful generated behavior (especially value equality), knowing when to reach for Struct/Data versus a full class is practically-relevant Ruby knowledge that reflects writing clean, concise code — a useful tool in the Ruby developer's toolkit for the frequent task of bundling related attributes into a lightweight type, embodying Ruby's emphasis on conciseness and reducing boilerplate.