Struct::Value: simple immutable value object
- representing some relatively simple data;
- compared by type & value;
- nicely represented.
Value objects are super-useful especially for defining APIs, their input/return values. Recently, there were some movement towards using more immutability-friendly approach in Ruby programming, leading to creating several discussions/libraries with value objects. For example, Tom Dalling's gem, Good Ruby Value object convention (disclaimer: the latter is maintained by yours truly).
I propose to introduce native value objects to Ruby as a core class.
Why not a gem?
- I believe that concept is that simple, that nobody will even try to use a gem for representing it with, unless the framework/library used already provides one.
- Potentially, a lot of standard library (and probably even core) APIs could benefit from the concept.
Struct is not enough
Struct class is "somewhat alike" value-object, and frequently used instead of one: it is compared by value and consists of simple attributes. On the other hand,
- collection-alike (defines
- dictionary-alike (has
The above traits somehow erodes the semantics, making code less clear, especially when duck-typing is used.
For example, this code snippet shows why
to_a is problematic:
Result = Struct.new(:success, :content) # Now, imagine that other code assumes `data` could be either Result, or [Result, Result, Result] # So, ... data = Result.new(true, 'it is awesome') Array(data) # => expected [Result(true, 'it is awesome')], got [true, 'it is awesome'] # or... def foo(arg1, arg2 = nil) p arg1, arg2 end foo(*data) # => expected [Result(true, 'it is awesome'), nil], got [true, 'it is awesome']
each defined on something that is thought as "just value" can also lead to subtle bugs, when some method checks "if the received argument is collection-alike", and value object's author doesn't thought of it as a collection.
- Class name:
Struct::Value: lot of Rubyists are used to have
Structas a quick "something-like-value" drop-in, so alternative, more strict implementation, being part of
StructAPI, will be quite discoverable; alternative: just
- Class API is copying
Structs one (most of the time -- even reuses the implementation), with the following exceptions (note: the immutability is **not* the only difference)*:
- Doesn't think of itself as "almost hash" (doesn't have
- Can have empty members list (fun fact:
Struct::Foo, is allowed, but
Struct.new()is not) to allow usage patterns like:
class MyService Success = Struct::Value.new(:results) NotFound = Struct::Value.new end
NotFound here, unlike, say,
Object.new.freeze (another pattern for creating "empty typed value object"), has nice inspect
#<value NotFound>, and created consistently with the
Success, making the code more readable. And if it will evolve to have some attributes, the code change would be easy.
Patch is provided