union-type 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: edfcd1ae4c61f2097f644de21b2403419afc6c121d751823de6018a00975b921
+  data.tar.gz: a70a742afc27d29e14b62f420f00cee5bd97b8a97a736a577a566846e422af0c
+SHA512:
+  metadata.gz: ce9eaa5d32bf49436f52697773c6ab38aadbda78f27749602d8dda4b13ee87e6f3b5a7fa0c232df7b5a9444257b9304297a0d7401d1b09b04baf1f1cac42d597
+  data.tar.gz: e3f0954b10a66a9577ae019017c607def1d9af198d2679211c592d0a26416d158510ea5ee7b5539c891dc41c103a9ec62b21611a74165b0afaaf0bb6b0cc35d5

data/README.md

@@ -0,0 +1,128 @@
+# union-type
+
+Union types for Ruby. Combine classes into a single type that matches any of them.
+
+## Installation
+
+```ruby
+gem "union-type"
+```
+
+## Usage
+
+### Creating a union type
+
+```ruby
+require "union-type"
+
+StringOrInt = String | Integer        # via Class#|
+StringOrInt = UnionType[String, Integer]  # bracket syntax
+# => UnionType(Integer | String)
+```
+
+Types are stored in a `SortedSet` (sorted alphabetically by class name) and deduplicated. Subclasses are dropped when a superclass is already present:
+
+```ruby
+UnionType[Integer, Float, Numeric]
+# => UnionType(Numeric)  — Integer and Float are redundant
+```
+
+### Matching values
+
+```ruby
+union = String | Integer
+
+union === "hello"   # => true
+union === 42        # => true
+union === :sym      # => false
+
+"hello".is_a?(union)       # => true
+42.kind_of?(union)         # => true
+"hi".instance_of?(union)   # => true  (exact class match)
+42.instance_of?(union)     # => true
+42.instance_of?(Numeric | String)  # => false (42 is not exactly Numeric)
+```
+
+### case/when
+
+```ruby
+case value
+when String | Integer then "string or int"
+when Float            then "float"
+end
+```
+
+### Combining unions
+
+```ruby
+# Union (|)
+(String | Integer) | Float
+# => UnionType(Float | Integer | String)
+
+[String, Integer, Float].reduce(:|)
+# => UnionType(Float | Integer | String)
+
+# Intersection (&) — returns nil when empty
+(String | Integer) & (Integer | Float)
+# => UnionType(Integer)
+
+(String | Integer) & Float
+# => nil
+```
+
+### Subtraction and coverage
+
+```ruby
+union = String | Integer | Float
+
+union.cover?(Integer)  # => true  (exact member)
+union.cover?(Numeric)  # => false (superclass, not covered)
+
+numeric = Numeric | String
+numeric.cover?(Integer)  # => true  (subclass of Numeric)
+```
+
+### Enumerable
+
+`UnionType` includes `Enumerable`, yielding classes in sorted order:
+
+```ruby
+union = String | Integer | Float
+
+union.to_a              # => [Float, Integer, String]
+union.map(&:name)       # => ["Float", "Integer", "String"]
+union.include?(String)  # => true
+union.count             # => 3
+union.min_by(&:name)    # => Float
+```
+
+### Opting out of core extensions
+
+If you don't want `Class#|`, `Object#is_a?`, `Object#kind_of?`, or `Object#instance_of?` patched, require the no-ext variant instead:
+
+```ruby
+require "union-type-no-ext"
+
+union = UnionType[String, Integer]   # construction still works
+union === "hello"                    # => true
+"hello".is_a?(union)                 # => false (Object#is_a? not patched)
+```
+
+## API reference
+
+| Method | Description |
+|---|---|
+| `UnionType.new(*classes)` | Create a union; raises `ArgumentError` if empty |
+| `UnionType[*classes]` | Alias for `.new` |
+| `String \| Integer` | Create via `Class#\|` (requires core ext) |
+| `union === value` | True if value matches any member |
+| `union.cover?(klass)` | True if klass is a member or subclass of a member |
+| `union \| other` | Union of two unions (or a class) |
+| `union & other` | Intersection; returns `nil` if empty |
+| `union.types` | The underlying `SortedSet` |
+| `value.is_a?(union)` | Patched `is_a?` (requires core ext) |
+| `value.instance_of?(union)` | Exact class match against members (requires core ext) |
+
+## License
+
+MIT

data/lib/union-type-no-ext.rb

@@ -0,0 +1,2 @@
+require_relative "union_type/version"
+require_relative "union_type/union_type"

data/lib/union-type.rb

@@ -0,0 +1,3 @@
+require_relative "union_type/version"
+require_relative "union_type/union_type"
+require_relative "union_type/core_ext"

data/lib/union_type/core_ext.rb

@@ -0,0 +1,26 @@
+class Class
+  def |(other)
+    case other
+    when Class
+      UnionType.new(self, other)
+    when UnionType
+      UnionType.new(self, *other)
+    else
+      raise TypeError, "expected Class or UnionType, got #{other.class}"
+    end
+  end
+end
+
+class Object
+  alias_method :__is_a__?, :is_a?
+  alias_method :__instance_of__?, :instance_of?
+
+  def is_a?(type)
+    type.__is_a__?(UnionType) ? type === self : __is_a__?(type)
+  end
+  alias kind_of? is_a?
+
+  def instance_of?(type)
+    type.__is_a__?(UnionType) ? type.include?(self.class) : __instance_of__?(type)
+  end
+end

data/lib/union_type/union_type.rb

@@ -0,0 +1,84 @@
+require "sorted_set"
+
+class UnionType
+  include Enumerable
+
+  class Entry
+    include Comparable
+
+    attr_reader :klass
+
+    def initialize(klass) = (@klass = klass)
+    def <=>(other) = klass.name.to_s <=> other.klass.name.to_s
+  end
+  private_constant :Entry
+
+  def self.[](*classes) = new(*classes)
+
+  def initialize(*classes)
+    raise ArgumentError, "requires at least one class" if classes.empty?
+
+    minimal = classes.reject { |c| classes.any? { |other| c != other && c < other } }
+    @types = SortedSet.new(minimal.map { Entry.new(_1) })
+  end
+
+  def each(&block)
+    @types.each { block.call(_1.klass) }
+  end
+
+  # Supports case/when and the === operator.
+  def ===(value)
+    any? { _1 === value }
+  end
+
+  # The underlying SortedSet of Entry objects (sorted by class name).
+  def types
+    @types
+  end
+
+  def cover?(klass)
+    any? { klass <= _1 }
+  end
+
+  def |(other)
+    case other
+    when Class      then UnionType.new(*self, other)
+    when UnionType  then UnionType.new(*self, *other)
+    else raise TypeError, "expected Class or UnionType, got #{other.class}"
+    end
+  end
+
+  # Returns a new UnionType covering only values matched by both unions,
+  # or nil when the intersection is empty.
+  def &(other)
+    other_types = case other
+                  when UnionType then other.to_a
+                  when Class     then [other]
+                  else raise TypeError, "expected Class or UnionType, got #{other.class}"
+                  end
+
+    classes = flat_map { |a|
+      other_types.filter_map { |b|
+        if a == b || a < b then a
+        elsif b < a        then b
+        end
+      }
+    }.uniq
+
+    UnionType.new(*classes) unless classes.empty?
+  end
+
+  def ==(other)
+    other.class == UnionType && to_a == other.to_a
+  end
+  alias eql? ==
+
+  def hash
+    to_a.hash
+  end
+
+  def inspect
+    "UnionType(#{map(&:name).join(" | ")})"
+  end
+  alias to_s inspect
+end

data/lib/union_type/version.rb

@@ -0,0 +1,3 @@
+class UnionType
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: union-type
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bogdan Gusiev
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorted_set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Union types for Ruby
+email:
+- agresso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/union-type-no-ext.rb
+- lib/union-type.rb
+- lib/union_type/core_ext.rb
+- lib/union_type/union_type.rb
+- lib/union_type/version.rb
+homepage: https://github.com/bogdangusiev/union-type
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: Union types for Ruby
+test_files: []