Add Dry::Struct.merge

It's also aliased as `.compose`

docsite/source/hash-schemas.html.md

@@ -124,6 +124,29 @@ user_hash['name' => 'Jane', 'city' => 'London']
 # => Dry::Types::UnknownKeysError: unexpected keys [:city] in Hash input
 ```
 
+### Merging schemas
+
+Similar than inheritance, two schemas can be merged.
+The resulting schema will have the sum of both sets
+of attributes.
+
+user_hash = Types::Hash.schema(
+  name: Types::String
+)
+
+address_hash = Types::Hash.schema(
+  address: Types::String
+)
+
+user_with_address_schema = user_hash.merge(address_hash)
+
+user_with_address_schema['name' => 'Jane', 'address' => 'C/ Foo']
+# => { name: 'Jane', address: 'C/ Foo' }
+```
+
+Keep in mind that key transformations from the caller schema are preserved,
+while each attribute keeps the type transformations from its original hash.
+
 ### Transforming types
 
 A schema can transform types with a block. For example, the following code makes all keys optional:

lib/dry/types/hash/constructor.rb

@@ -13,6 +13,9 @@ class Constructor < ::Dry::Types::Constructor
         def constructor_type
           ::Dry::Types::Hash::Constructor
         end
+
+        def merge
+        end
 
         # @return [Lax]
         #

lib/dry/types/schema.rb

@@ -284,6 +284,19 @@ def lax
         Lax.new(schema(keys.map(&:lax)))
       end
 
+      # Merges given schema keys into current schema.
+      #
+      # A new instance is returned.
+      #
+      # @param schema [Schema]
+      # @return [Schema]
+      #
+      # @api public
+      def merge(schema)
+        with(keys: keys + schema.keys)
+      end
+      alias_method :compose, :merge
+
       private
 
       # @param [Array<Dry::Types::Schema::Keys>] keys

spec/dry/types/schema_spec.rb

@@ -501,4 +501,45 @@ def self.meta
       specify { expect(type.transform_keys?).to be(true) }
     end
   end
+
+  describe '#merge' do
+    it 'adds keys and values from given schema' do
+      schema1 = Dry::Types['hash'].schema(name: 'string')
+      schema2 = Dry::Types['hash'].schema(age: 'integer')
+
+      schema = schema1.merge(schema2)
+
+      expect(schema.keys.map(&:name)).to eq([:name, :age])
+    end
+
+    it 'gives preference to given struct' do
+      schema1 = Dry::Types['hash'].schema(foo: 'string')
+      schema2 = Dry::Types['hash'].schema(foo: 'integer')
+
+      schema = schema1.merge(schema2)
+
+      expect(schema[foo: 1]).to eq(foo: 1)
+    end
+
+    it 'keeps type transformations from both schemas' do
+      transf1 = ->(key) { key.constructor { 'Transf 1' } }
+      transf2 = ->(key) { key.constructor { 'Transf 2' } }
+      schema1 = Dry::Types['hash'].with_type_transform(transf1).schema(foo: 'string')
+      schema2 = Dry::Types['hash'].with_type_transform(transf2).schema(bar: 'string')
+
+      schema = schema1.merge(schema2)
+
+      expect(schema[foo: 'foo', bar: 'bar']).to eq(foo: 'Transf 1', bar: 'Transf 2')
+    end
+
+    it 'preserves key transformations from the caller schema' do
+      schema1 = Dry::Types['hash'].schema(foo: 'string').with_key_transform(&:to_sym)
+      transf2 = ->(key) { (key + '_').to_sym }
+      schema2 = Dry::Types['hash'].schema(bar: 'string').with_key_transform(transf2)
+
+      schema = schema1.merge(schema2)
+
+      expect(schema['foo' => 'foo', 'bar' => 'bar']).to eq(foo: 'foo', bar: 'bar')
+    end
+  end
 end