lab42_data_class 0.7.1 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fdfa61b721a7e006b42dd59c3dc61c4f3442faaa0d50feeaa5ed4b20ea5838c
-  data.tar.gz: fa5d7ab0e6133c398caaaa1762e75a5820123e67088acc4750c36e9246ff2dc0
+  metadata.gz: 6534869faa807d9d3f774d0fd1deef2d12d23475f06ab07208a46f7ef998056b
+  data.tar.gz: f099a45edac8b2daf5d0637e7345ba3301c1ac379f2d0f4319b34172f847e431
 SHA512:
-  metadata.gz: 53af67931648a621cd0ff18912ce191dc2d0a005eacfd4df741bbdf8a58a9c695e168055129c76be08efcb4810d3910a5df362512996c8d2375da6ff17b61be8
-  data.tar.gz: c65a655f447f154b1a4e7584393fe3058403ef53cf5651a51fd39e5af7ebbd88768e90dc9b8d1a7d582316a35d2786abff6c6a04cc2f445f8d725657773c9a21
+  metadata.gz: 005cd3a1d4a52bfabaa371fb36769bce9530ed061d331f0009d39342a5af70c9126373eda6164471c0a58a14e27039261568439d40742b35b18e426b1fa61733
+  data.tar.gz: ed3c5a31cc163448ba912e76284946c0f4ed47bd7b2ee3841e7e5918ad350f5763656da819bea96826da614285de7b981092ae4ee924dce574e638dd684919af

data/README.md

@@ -235,6 +235,57 @@ And of course the factory functions are equivalent to the constructors
     expect(node).to eq(Lab42::Triple.new("42", 4, 2))
 ```
 
+#### Context: Pseudo Assignments
+
+... in reality return a new object
+
+Given an instance of `Pair`
+```ruby
+    let(:original) { Pair(1, 1) }
+```
+
+And one of `Triple`
+```ruby
+    let(:xyz) { Triple(1, 1, 1) }
+```
+
+Then
+```ruby
+    second = original.set_first(2)
+    third  = second.set_second(2)
+    expect(original).to eq( Pair(1, 1) )
+    expect(second).to eq(Pair(2, 1))
+    expect(third).to eq(Pair(2, 2))
+```
+
+And also
+```ruby
+    second = xyz.set_first(2)
+    third  = second.set_second(2)
+    fourth = third.set_third(2)
+    expect(xyz).to eq(Triple(1, 1, 1))
+    expect(second).to eq(Triple(2, 1, 1))
+    expect(third).to eq(Triple(2, 2, 1))
+    expect(fourth).to eq(Triple(2, 2, 2))
+```
+
+## Context: `List`
+
+A `List` is what a _list_ is in Lisp or Elixir it exposes the following API
+
+Given such a _list_
+```ruby
+    let(:three) { List(*%w[a b c]) }
+```
+
+Then this becomes really a _linked_list_
+```ruby
+    expect(three.car).to eq("a")
+    expect(three.cdr).to eq(List(*%w[b c]))
+```
+
+For all details please consult the [List speculations](speculations/LIST.md)
+
 # LICENSE
 
 Copyright 2022 Robert Dober robert.dober@gmail.com

data/lib/lab42/data_class/builtin_constraints.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "constraints/constraint"
+require_relative "constraints/list_of_constraint"
+require_relative "constraints/pair_of_constraint"
+require_relative "constraints/triple_of_constraint"
+require_relative "constraints/kernel"
+
+module Lab42
+  module DataClass
+    module BuiltinConstraints
+      extend self
+    end
+  end
+end
+
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/attribute_setters/attribute_setter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lab42
+  module DataClass
+    module Constraints
+      module AttributeSetters
+        module AttributeSetter
+          attr_reader :attribute, :constraint, :instance
+
+          private
+
+          def initialize(attribute:, constraint:, instance:)
+            @attribute = attribute
+            @constraint = constraint
+            @instance = instance
+          end
+
+          def _set_attr!(value)
+            new_values = instance.to_h.merge(attribute => value)
+            instance.class.send(:_new_from_merge, {}, new_values)
+          end
+
+          def _value = @___value__ ||= instance[attribute]
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/attribute_setters/list_of_attribute_setter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      module AttributeSetters
+        class ListOfAttributeSetter
+          include AttributeSetter
+
+          def cons(value)
+            constraint.constraint.(value) or raise ConstraintError,
+                                                   "cannot set value #{value} in set(#{attribute}).cons"
+
+            _set_attr!(_value.cons(value))
+          end
+
+          def cdr
+            _set_attr!(_value.cdr)
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/attribute_setters/pair_of_attribute_setter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      module AttributeSetters
+        class PairOfAttributeSetter
+          include AttributeSetter
+
+          def first_element(value)
+            constraint.constraint.first.(value) or raise ConstraintError,
+                                                         "cannot set value #{value} in set(#{attribute}).first_element"
+
+            _set_attr!(_value.set_first(value))
+          end
+
+          def second_element(value)
+            constraint.constraint.last.(value) or raise ConstraintError,
+                                                        "cannot set value #{value} in set(#{attribute}).second_element"
+            _set_attr!(_value.set_second(value))
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/attribute_setters/triple_of_attribute_setter.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      module AttributeSetters
+        class TripleOfAttributeSetter
+          include AttributeSetter
+
+          def first_element(value)
+            constraint.constraint.first.(value) or raise ConstraintError,
+                                                         "cannot set value #{value} in set(#{attribute}).first_element"
+
+            _set_attr!(_value.set_first(value))
+          end
+
+          def second_element(value)
+            constraint.constraint[1].(value) or raise ConstraintError,
+                                                      "cannot set value #{value} in set(#{attribute}).second_element"
+            _set_attr!(_value.set_second(value))
+          end
+
+          def third_element(value)
+            constraint.constraint.last.(value) or raise ConstraintError,
+                                                        "cannot set value #{value} in set(#{attribute}).third_element"
+            _set_attr!(_value.set_third(value))
+          end
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/constraint.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "lab42/data_class"
+module Lab42
+  module DataClass
+    module Constraints
+      class Constraint
+        attr_reader :name, :function
+
+        def call(value) = function.(value)
+        def setter_constraint? = false
+        def to_s = "Constraint<#{name}>"
+
+        private
+        def initialize(name:, function:)
+          raise ArgumentError, "name not a String, but #{name}" unless String === name
+          unless function.respond_to?(:arity) && function.arity == 1
+            raise ArgumentError, "function not a callable with arity 1 #{function}"
+          end
+
+          @name = name
+          @function = function
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/kernel.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Kernel
+  Constraints = Lab42::DataClass::Constraints
+  Constraint = Constraints::Constraint
+  ListOfConstraint = Constraints::ListOfConstraint
+  PairOfConstraint = Constraints::PairOfConstraint
+  TripleOfConstraint = Constraints::TripleOfConstraint
+
+  Maker = Lab42::DataClass::Proxy::Constraints::Maker # TODO: Move Maker to Lab42::DataClass:ConstraintMaker
+  Anything = Constraint.new(name: "Anything", function: ->(_) { true })
+  Boolean = Constraint.new(name: "Boolean", function: -> { [false, true].member?(_1) })
+
+  def All?(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> do
+      _1.all?(&constraint)
+    end
+    Constraint.new(name: "All?(#{constraint})", function: f)
+  end
+
+  def Any?(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> do
+      _1.any?(&constraint)
+    end
+    Constraint.new(name: "Any?(#{constraint})", function: f)
+  end
+
+  def Choice(*constraints)
+    constraints = constraints.map{ Maker.make_constraint _1 }
+    f = ->(value) do
+      constraints.any?{ _1.(value) }
+    end
+    Constraint.new(name: "Choice(#{constraints.join(', ')})", function: f)
+  end
+
+  def Contains(str)
+    f = -> { _1.include?(str) rescue false }
+    Constraint.new(name: "Contains(#{str})", function: f)
+  end
+
+  def EndsWith(str)
+    f = -> { _1.end_with?(str) rescue false }
+    Constraint.new(name: "EndsWith(#{str})", function: f)
+  end
+
+  def Lambda(arity)
+    function = -> do
+      _1.arity == arity rescue false
+    end
+    Constraint.new(name: "Lambda(#{arity})", function:)
+  end
+
+  def ListOf(constraint, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    function = -> do
+      (Lab42::List === _1 || Lab42::Nil == _1) &&
+      _1.all?(&constraint)
+    end
+    ListOfConstraint.new(name: "ListOf(#{constraint})", constraint:, function:)
+  end
+
+  def NilOr(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> { _1.nil? || constraint.(_1) }
+    Constraint.new(name: "NilOr(#{constraint})", function: f)
+  end
+
+  def Not(constraint = nil, &blk)
+    constraint = Maker.make_constraint(constraint, &blk)
+    f = -> { !constraint.(_1) }
+    Constraint.new(name: "Not(#{constraint})", function: f)
+  end
+
+  def PairOf(fst, snd)
+    fst_constraint = Maker.make_constraint(fst)
+    snd_constraint = Maker.make_constraint(snd)
+    constraint = [fst_constraint, snd_constraint]
+    f = -> do
+      Lab42::Pair === _1 && fst_constraint.(_1.first) && snd_constraint.(_1.second)
+    end
+    PairOfConstraint.new(name: "PairOf(#{fst_constraint}, #{snd_constraint})", function: f, constraint:)
+  end
+
+  def StartsWith(str)
+    f = -> { _1.start_with?(str) rescue false }
+    Constraint.new(name: "StartsWith(#{str})", function: f)
+  end
+
+  def TripleOf(fst, snd, trd)
+    fst_constraint = Maker.make_constraint(fst)
+    snd_constraint = Maker.make_constraint(snd)
+    trd_constraint = Maker.make_constraint(trd)
+    constraint = [fst_constraint, snd_constraint, trd_constraint]
+    f = -> do
+      Lab42::Triple === _1 && fst_constraint.(_1.first) && snd_constraint.(_1.second) && trd_constraint.(_1.third)
+    end
+    TripleOfConstraint.new(
+      name: "TripleOf(#{fst_constraint}, #{snd_constraint}, #{trd_constraint})",
+      function: f,
+      constraint:
+    )
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/list_of_constraint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "constraint"
+require_relative "setter_constraint"
+require_relative "attribute_setters/list_of_attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      class ListOfConstraint < Constraint
+        include SetterConstraint
+
+        def attribute_setter = AttributeSetters::ListOfAttributeSetter
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/pair_of_constraint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "constraint"
+require_relative "setter_constraint"
+require_relative "attribute_setters/pair_of_attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      class PairOfConstraint < Constraint
+        include SetterConstraint
+
+        def attribute_setter = AttributeSetters::PairOfAttributeSetter
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/setter_constraint.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lab42
+  module DataClass
+    module Constraints
+      module SetterConstraint
+        attr_reader :constraint
+
+        def setter_constraint? = true
+
+        def setter_for(attribute:, instance:)
+          attribute_setter.new(
+            attribute:,
+            constraint: self,
+            instance:
+          )
+        end
+        private
+
+        def initialize(constraint:, **other)
+          super(**other)
+          @constraint = constraint
+        end
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/constraints/triple_of_constraint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "constraint"
+require_relative "setter_constraint"
+require_relative "attribute_setters/triple_of_attribute_setter"
+module Lab42
+  module DataClass
+    module Constraints
+      class TripleOfConstraint < Constraint
+        include SetterConstraint
+
+        def attribute_setter = AttributeSetters::TripleOfAttributeSetter
+      end
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/kernel.rb

@@ -1,11 +1,18 @@
 # frozen_string_literal: true
 
+require_relative '../nil'
 module Kernel
+  Nil = Lab42::Nil
+
   def DataClass(*args, **kwds, &blk)
     proxy = Lab42::DataClass::Proxy.new(*args, **kwds, &blk)
     proxy.define_class!
   end
 
+  def List(*elements)
+    Lab42::List.new(*elements)
+  end
+
   def Pair(first, second)
     Lab42::Pair.new(first, second)
   end

data/lib/lab42/data_class/proxy/constraints/maker.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "lab42/data_class/constraints/constraint"
 module Lab42
   module DataClass
     class Proxy
@@ -7,9 +8,17 @@ module Lab42
         module Maker
           extend self
 
-          def make_constraint(constraint)
+          def make_constraint(constraint, &blk)
+            raise ArgumentError, "must not pass a callable #{constraint} and a block" if constraint && blk
+
+            _make_constraint(constraint || blk)
+          end
+
+          private
+
+          def _make_constraint(constraint)
             case constraint
-            when Proc, Method
+            when Lab42::DataClass::Constraints::Constraint, Proc, Method
               constraint
             when Symbol
               -> { _1.send(constraint) }
@@ -26,8 +35,6 @@ module Lab42
             end
           end
 
-          private
-
           def _make_member_constraint(constraint)
             if constraint.respond_to?(:member?)
               -> { constraint.member?(_1) }

data/lib/lab42/data_class/proxy/constraints.rb

@@ -12,19 +12,8 @@ module Lab42
           raise ConstraintError, errors.join("\n\n") unless errors.empty?
         end
 
-        def define_constraint
-          ->((attr, constraint)) do
-            if members!.member?(attr)
-              constraints[attr] << Maker.make_constraint(constraint)
-              nil
-            else
-              attr
-            end
-          end
-        end
-
         def define_constraints(constraints)
-          errors = constraints.map(&define_constraint).compact
+          errors = constraints.map(&_define_constraint).compact
           unless errors.empty?
             raise UndefinedAttributeError,
                   "constraints cannot be defined for undefined attributes #{errors.inspect}"
@@ -74,6 +63,19 @@ module Lab42
           raise ConstraintError, errors.join("\n\n") unless errors.empty?
         end
 
+        def _define_constraint
+          ->((attr, constraint)) do
+            if members!.member?(attr)
+              constraint = Maker.make_constraint(constraint)
+              _maybe_define_setter_constraint(attr, constraint)
+              constraints[attr] << constraint
+              nil
+            else
+              attr
+            end
+          end
+        end
+
         def _define_with_constraint
           proxy = self
           ->(*) do
@@ -83,6 +85,12 @@ module Lab42
             end
           end
         end
+
+        def _maybe_define_setter_constraint(attr, constraint)
+          if Lab42::DataClass::Constraints::Constraint === constraint && constraint.setter_constraint?
+            setter_attributes.update(attr => constraint)
+          end
+        end
       end
     end
   end

data/lib/lab42/data_class/proxy/memos.rb

@@ -38,6 +38,8 @@ module Lab42
           @__validations__ ||= []
         end
 
+        def setter_attributes = @__setter_attributes__ ||= {}
+
         private
 
         def _missing_initializers

data/lib/lab42/data_class/proxy.rb

@@ -30,12 +30,11 @@ module Lab42
         end
       end
 
-      def check!(**params)
-        @actual_params = params
+      def check!(params, merge_with = defaults)
         raise ArgumentError, "missing initializers for #{_missing_initializers}" unless _missing_initializers.empty?
         raise ArgumentError, "illegal initializers #{_illegal_initializers}" unless _illegal_initializers.empty?
 
-        _check_constraints!(defaults.merge(params))
+        _check_constraints!(merge_with.merge(params))
       end
 
       def define_class!
@@ -63,6 +62,10 @@ module Lab42
         _init(data_class, defaults.merge(params))
       end
 
+      def set_actual_params(params)
+        @actual_params = params
+      end
+
       def to_hash(data_class_instance)
         all_attributes
           .inject({}) { |result, (k, _)| result.merge(k => data_class_instance[k]) }
@@ -96,15 +99,40 @@ module Lab42
 
       def _define_derived_attribute(name, &blk)
         ->(*) do
+          if instance_methods.include?(name)
+            begin
+              remove_method(name)
+            rescue StandardError
+              nil
+            end
+          end
           define_method(name) { blk.call(self) }
         end
       end
 
       def _define_freezing_constructor
+        proxy = self
+        ->(*) do
+          define_method :new do |**params, &b|
+            allocate.tap do |o|
+              proxy.set_actual_params(params)
+              proxy.check!(params)
+              o.send(:initialize, **params, &b)
+            end.freeze
+          end
+        end
+      end
+
+      def _define_merging_constructor
+        proxy = self
         ->(*) do
-          define_method :new do |*a, **p, &b|
-            super(*a, **p, &b).freeze
+          define_method :_new_from_merge do |new_params, params|
+            allocate.tap do |o|
+              proxy.check!(new_params, {})
+              o.send(:initialize, **params)
+            end.freeze
           end
+          private :_new_from_merge
         end
       end
 
@@ -112,7 +140,6 @@ module Lab42
         proxy = self
         ->(*) do
           define_method :initialize do |**params|
-            proxy.check!(**params)
             proxy.init(self, **params)
             proxy.validate!(self)
           end
@@ -123,7 +150,7 @@ module Lab42
         ->(*) do
           define_method :merge do |**params|
             values = to_h.merge(params)
-            self.class.new(**values)
+            self.class.send(:_new_from_merge, params, values)
           end
         end
       end
@@ -133,10 +160,12 @@ module Lab42
         klass.module_eval(&_define_access)
         klass.module_eval(&_define_to_h)
         klass.module_eval(&_define_merge)
+        klass.module_eval(&_define_set)
       end
 
       def _define_singleton_methods(singleton)
         singleton.module_eval(&_define_freezing_constructor)
+        singleton.module_eval(&_define_merging_constructor)
         singleton.module_eval(&_define_to_proc)
         singleton.module_eval(&_define_with_constraint)
         singleton.module_eval(&_define_derived)
@@ -170,9 +199,21 @@ module Lab42
         end
       end
 
+      def _define_set
+        proxy = self
+        ->(*) do
+          define_method :set do |attribute|
+            setter_constraint = proxy.setter_attributes.fetch(attribute) do
+              raise UndefinedSetterError, "There is no constraint implementing a setter for attribute #{attribute}"
+            end
+            setter_constraint.setter_for(attribute:, instance: self)
+          end
+        end
+      end
+
       def _init(data_class_instance, params)
         params.each do |key, value|
-          data_class_instance.instance_variable_set("@#{key}", value)
+          data_class_instance.instance_variable_set("@#{key}", value.freeze)
         end
       end
     end

data/lib/lab42/data_class/undefined_setter_error.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lab42
+  module DataClass
+    class UndefinedSetterError < RuntimeError
+    end
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class/version.rb

@@ -2,7 +2,7 @@
 
 module Lab42
   module DataClass
-    VERSION = "0.7.1"
+    VERSION = "0.8.1"
   end
 end
 #  SPDX-License-Identifier: Apache-2.0

data/lib/lab42/data_class.rb

@@ -4,8 +4,11 @@ require_relative './data_class/constraint_error'
 require_relative './data_class/duplicate_definition_error'
 require_relative './data_class/kernel'
 require_relative './data_class/undefined_attribute_error'
+require_relative './data_class/undefined_setter_error'
 require_relative './data_class/validation_error'
 require_relative './data_class/proxy'
+require_relative './list'
+require_relative './nil'
 require_relative './pair'
 require_relative './triple'
 

data/lib/lab42/list/class_methods.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lab42
+  class List
+    module ClassMethods
+      def cons(element, list)
+        raise ArgumentError, "list needs to be a list instance" unless list?(list)
+
+        allocate.tap do |o|
+          o.instance_variable_set("@car", element)
+          o.instance_variable_set("@cdr", list)
+          o.instance_variable_set("@length", list.length.succ)
+          o.freeze
+        end
+      end
+
+      def each(subject, &blk)
+        unless subject.empty?
+          blk.(subject.car)
+          each(subject.cdr, &blk)
+        end
+      end
+
+      def list?(subject)
+        self === subject || Nil == subject
+      end
+
+      def new(*elements)
+        elements.reverse.inject(Nil) do |list, element|
+          cons(element, list)
+        end
+      end
+    end
+    extend ClassMethods
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/list.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "nil"
+require_relative "list/class_methods"
+module Lab42
+  class List
+    include Enumerable
+    attr_reader :car, :cdr, :length
+
+    def ==(other) =
+      self.class.list?(other) &&
+        length == other.length &&
+        car == other.car &&
+        cdr == other.cdr
+
+    def cadr = cdr.car
+
+    def caddr = cdr.cdr.car
+
+    def cddr = cdr.cdr
+
+    def cdddr = cdr.cdr.cdr
+
+    def cons(new_head) = self.class.cons(new_head, self)
+
+    def deconstruct = [car, cdr]
+
+    def each(&blk) = self.class.each(self, &blk)
+
+    def empty? = false
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/nil.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lab42
+  module Nil
+    extend self, Enumerable
+
+    def deconstruct = []
+    def each = self
+    def empty? = true
+    def length = 0
+  end
+end
+# SPDX-License-Identifier: Apache-2.0

data/lib/lab42/pair.rb

@@ -10,6 +10,9 @@ module Lab42
       [first, second]
     end
 
+    def set_first(new_first) = self.class.new(new_first, second)
+    def set_second(new_second) = self.class.new(first, new_second)
+
     private
 
     def initialize(first, second)

data/lib/lab42/triple.rb

@@ -10,6 +10,10 @@ module Lab42
       [first, second, third]
     end
 
+    def set_first(new_first) = self.class.new(new_first, second, third)
+    def set_second(new_second) = self.class.new(first, new_second, third)
+    def set_third(new_third) = self.class.new(first, second, new_third)
+
     private
 
     def initialize(first, second, third)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lab42_data_class
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.1
 platform: ruby
 authors:
 - Robert Dober
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-28 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies: []
 description: |
   An Immutable DataClass for Ruby
@@ -24,7 +24,18 @@ files:
 - LICENSE
 - README.md
 - lib/lab42/data_class.rb
+- lib/lab42/data_class/builtin_constraints.rb
 - lib/lab42/data_class/constraint_error.rb
+- lib/lab42/data_class/constraints/attribute_setters/attribute_setter.rb
+- lib/lab42/data_class/constraints/attribute_setters/list_of_attribute_setter.rb
+- lib/lab42/data_class/constraints/attribute_setters/pair_of_attribute_setter.rb
+- lib/lab42/data_class/constraints/attribute_setters/triple_of_attribute_setter.rb
+- lib/lab42/data_class/constraints/constraint.rb
+- lib/lab42/data_class/constraints/kernel.rb
+- lib/lab42/data_class/constraints/list_of_constraint.rb
+- lib/lab42/data_class/constraints/pair_of_constraint.rb
+- lib/lab42/data_class/constraints/setter_constraint.rb
+- lib/lab42/data_class/constraints/triple_of_constraint.rb
 - lib/lab42/data_class/duplicate_definition_error.rb
 - lib/lab42/data_class/kernel.rb
 - lib/lab42/data_class/proxy.rb
@@ -35,9 +46,13 @@ files:
 - lib/lab42/data_class/proxy/mixin.rb
 - lib/lab42/data_class/proxy/validations.rb
 - lib/lab42/data_class/undefined_attribute_error.rb
+- lib/lab42/data_class/undefined_setter_error.rb
 - lib/lab42/data_class/validation_error.rb
 - lib/lab42/data_class/version.rb
 - lib/lab42/eq_and_patterns.rb
+- lib/lab42/list.rb
+- lib/lab42/list/class_methods.rb
+- lib/lab42/nil.rb
 - lib/lab42/pair.rb
 - lib/lab42/triple.rb
 homepage: https://github.com/robertdober/lab42_data_class