Add _TaggedUnion type with subtype compatibility and tests

lib/literal/types.rb

···
 		)
 	end
 
+	# Matches if the value matches any of the given tagged types. Tags are used to identify which type was matched.
+	def _TaggedUnion(**members)
+		TaggedUnionType.new(**members)
+	end
+
+	# Nilable version of `_TaggedUnion`
+	def _TaggedUnion?(...)
+		_Nilable(
+			_TaggedUnion(...)
+		)
+	end
+
 	# Matches if *any* given type is matched.
 	def _Union(*types)
 		UnionType.new(types)

lib/literal/types/tagged_union_type.rb

···
+# frozen_string_literal: true
+
+class Literal::Types::TaggedUnionType
+	include Literal::Type
+
+	def initialize(**members)
+		raise Literal::ArgumentError.new("_TaggedUnion type must have at least one member.") if members.empty?
+
+		flattened = {}
+		members.each do |tag, type|
+			if Literal::Types::TaggedUnionType === type
+				type.members.each do |inner_tag, inner_type|
+					raise Literal::ArgumentError.new("_TaggedUnion has duplicate tag: #{inner_tag.inspect}") if flattened.key?(inner_tag)
+					flattened[inner_tag] = inner_type
+				end
+			else
+				raise Literal::ArgumentError.new("_TaggedUnion has duplicate tag: #{tag.inspect}") if flattened.key?(tag)
+				flattened[tag] = type
+			end
+		end
+
+		@members = flattened.freeze
+		freeze
+	end
+
+	attr_reader :members
+
+	def inspect
+		pairs = @members.map { |tag, type| "#{tag}: #{type.inspect}" }
+		"_TaggedUnion(#{pairs.join(', ')})"
+	end
+
+	def ===(value)
+		@members.any? { |_, type| type === value }
+	end
+
+	def [](tag)
+		@members[tag]
+	end
+
+	def tag_for(value)
+		@members.each { |tag, type| return tag if type === value }
+		nil
+	end
+
+	def >=(other)
+		types = @members.values
+
+		case other
+		when Literal::Types::TaggedUnionType
+			other.members.values.all? { |t| types.any? { |t2| Literal.subtype?(t, t2) } }
+		when Literal::Types::UnionType
+			other.types.all? { |t| types.any? { |t2| Literal.subtype?(t, t2) } } &&
+				other.primitives.all? { |p| types.any? { |t| Literal.subtype?(p, t) } }
+		else
+			types.any? { |t| Literal.subtype?(other, t) }
+		end
+	end
+
+	freeze
+end

lib/literal/types/union_type.rb

···
 
 		case other
 		when Literal::Types::UnionType
-			types_have_at_least_one_subtype = other.types.all? do |other_type|
-				primitives.any? { |p| Literal.subtype?(other_type, p) } || types.any? { |t| Literal.subtype?(other_type, t) }
-			end
-
-			primitives_have_at_least_one_subtype = other.primitives.all? do |other_primitive|
-				primitives.any? { |p| Literal.subtype?(other_primitive, p) } || types.any? { |t| Literal.subtype?(other_primitive, t) }
-			end
-
-			types_have_at_least_one_subtype && primitives_have_at_least_one_subtype
+			other.types.all? { |t| primitives.any? { |p| Literal.subtype?(t, p) } || types.any? { |t2| Literal.subtype?(t, t2) } } &&
+				other.primitives.all? { |p| primitives.any? { |p2| Literal.subtype?(p, p2) } || types.any? { |t| Literal.subtype?(p, t) } }
+		when Literal::Types::TaggedUnionType
+			other.members.values.all? { |t| primitives.any? { |p| Literal.subtype?(t, p) } || types.any? { |t2| Literal.subtype?(t, t2) } }
 		else
 			types.any? { |t| Literal.subtype?(other, t) } || primitives.any? { |p| Literal.subtype?(other, p) }
 		end

test/types/_tagged_union.test.rb

···
+# frozen_string_literal: true
+
+include Literal::Types
+
+test "#members" do
+	type = _TaggedUnion(name: String, age: Integer)
+
+	assert_equal type.members, { name: String, age: Integer }
+end
+
+test "#[]" do
+	type = _TaggedUnion(name: String, age: Integer)
+
+	assert_equal type[:name], String
+	assert_equal type[:age], Integer
+	assert_equal type[:missing], nil
+end
+
+test "#tag_for" do
+	type = _TaggedUnion(name: String, age: Integer)
+
+	assert_equal type.tag_for("Alice"), :name
+	assert_equal type.tag_for(42), :age
+	assert_equal type.tag_for(:other), nil
+end
+
+test "#inspect" do
+	type = _TaggedUnion(name: String, age: Integer)
+
+	assert_equal type.inspect, "_TaggedUnion(name: String, age: Integer)"
+end
+
+test "===" do
+	type = _TaggedUnion(name: String, age: Integer, flag: _Boolean)
+
+	assert type === "Alice"
+	assert type === 42
+	assert type === true
+	assert type === false
+
+	refute type === :symbol
+	refute type === nil
+end
+
+test "nested tagged unions are flattened" do
+	type = _TaggedUnion(
+		name: String,
+		**_TaggedUnion(age: Integer, flag: _Boolean).members,
+	)
+
+	assert_equal type.inspect, "_TaggedUnion(name: String, age: Integer, flag: _Boolean)"
+end
+
+test "raises on empty members" do
+	assert_raises(Literal::ArgumentError) { _TaggedUnion }
+end
+
+test "hierarchy: tagged union vs tagged union" do
+	assert_subtype _TaggedUnion(name: String), _TaggedUnion(name: String)
+	assert_subtype _TaggedUnion(name: String), _TaggedUnion(name: String, age: Integer)
+	assert_subtype _TaggedUnion(name: String), _TaggedUnion(name: Comparable)
+
+	refute_subtype _TaggedUnion(name: String, age: Integer), _TaggedUnion(name: String)
+	refute_subtype _TaggedUnion(name: String), _TaggedUnion(age: Integer)
+end
+
+test "hierarchy: plain type vs tagged union" do
+	assert_subtype String, _TaggedUnion(name: String, age: Integer)
+	assert_subtype String, _TaggedUnion(name: Comparable)
+	assert_subtype Integer, _TaggedUnion(name: String, age: Integer)
+
+	refute_subtype Symbol, _TaggedUnion(name: String, age: Integer)
+end
+
+test "hierarchy: tagged union vs union" do
+	assert_subtype _TaggedUnion(name: String, age: Integer), _Union(String, Integer)
+	assert_subtype _TaggedUnion(name: String), _Union(String, Integer)
+
+	refute_subtype _TaggedUnion(name: String, age: Integer), _Union(String)
+end
+
+test "hierarchy: union vs tagged union" do
+	assert_subtype _Union(String, Integer), _TaggedUnion(name: String, age: Integer)
+	assert_subtype _Union(String), _TaggedUnion(name: String, age: Integer)
+
+	refute_subtype _Union(String, Symbol), _TaggedUnion(name: String, age: Integer)
+end
+
+test "error message" do
+	error = assert_raises Literal::TypeError do
+		Literal.check(:symbol, _TaggedUnion(name: String, age: Integer))
+	end
+
+	assert_equal error.message, <<~ERROR
+		Type mismatch
+
+		  Expected: _TaggedUnion(name: String, age: Integer)
+		  Actual (Symbol): :symbol
+	ERROR
+end