Renamed Union to Any

Author: joelmoss

README.md

@@ -71,18 +71,32 @@ sig validate: T.Boolean
 def create(validate:); end
 ```
 
-#### `Union`
+#### `Any`
 
-Value **MUST** be a union of the given list of values, that is, the value must be one of the given list.
+Value **MUST** be any of the given list of values, that is, the value must be one of the given list.
 
 ```ruby
-sig T.Union(:male, :female)
+sig T.Any(:male, :female)
 def create(gender); end
 ```
 
+If no type is given, the value **CAN** be any type or value.
+
+```ruby
+sig save: T.Any
+def create(save: nil); end
+```
+
+You can also pass `nil` to allow a nil value alongside any other types you provide.
+
+```ruby
+sig T.Any(String, nil)
+def create(save = nil); end
+```
+
 #### `Nilable`
 
-When a type is given, the value **MUST** be nil or of the given type.
+When a type is given, the value **MUST** be nil **OR** of the given type.
 
 ```ruby
 sig save: T.Nilable(String)
@@ -98,3 +112,27 @@ If no type is given, the value **CAN** be nil. This essentially allows any value
 sig save: T.Nilable
 def create(save: nil); end
 ```
+
+You may notice that `Nilable` is interchangeable with `Any`. The following are equivilent:
+
+```ruby
+sig save: T.Nilable
+def create(save: nil); end
+```
+
+```ruby
+sig save: T.Any
+def create(save: nil); end
+```
+
+As are these:
+
+```ruby
+sig T.Nilable(String)
+def update(name = nil); end
+```
+
+```ruby
+sig T.Any(String, nil)
+def update(name = nil); end
+```

lib/delivered/types.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 module Delivered
-  class UnionType
+  class AnyType
     def initialize(*types)
       @types = types
     end
 
     def ===(value)
-      @types.any? { |type| type === value }
+      @types.empty? ? true : @types.any? { |type| type === value }
     end
   end
 
@@ -35,7 +35,7 @@ module Types
     module_function
 
     def Nilable(type = nil) = NilableType.new(type)
-    def Union(*types) = UnionType.new(*types)
+    def Any(*types) = AnyType.new(*types)
     def Boolean = BooleanType.new
   end
 end

test/delivered/types.rb

@@ -3,14 +3,32 @@
 describe Delivered::Types do
   T = Delivered::Types
 
-  describe 'Union' do
-    it 'is within union' do
-      assert T.Union(:one, :two) === :one
+  describe 'Any' do
+    with 'no arguments' do
+      it 'any type or nil' do
+        assert T.Any === :one
+        assert T.Any === 'one'
+        assert T.Any === nil
+      end
+    end
+
+    with 'arguments' do
+      it 'one of given arg' do
+        assert T.Any(:one, :two) === :one
+        assert T.Any(String, Integer) === 'one'
+        assert T.Any(String, Integer) === 1
+        assert T.Any(Integer, nil) === nil
+      end
     end
 
-    it 'raises when value is not in union' do
-      expect { :three => ^(T.Union(:one, :two)) }.to raise_exception NoMatchingPatternError
-      expect { :one => ^(T.Union(:one, :two)) }.not.to raise_exception
+    it 'raises when value is not valid' do
+      expect { :three => ^(T.Any(:one, :two)) }.to raise_exception NoMatchingPatternError
+      expect { :one => ^(T.Any(:one, :two)) }.not.to raise_exception
+      expect { 'one' => ^(T.Any(Symbol, String)) }.not.to raise_exception
+      expect { 'one' => ^(T.Any) }.not.to raise_exception
+      expect { nil => ^(T.Any) }.not.to raise_exception
+      expect { nil => ^(T.Any(String, nil)) }.not.to raise_exception
+      expect { true => ^(T.Any(String, nil)) }.to raise_exception NoMatchingPatternError
     end
   end