literal 1.3.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9721432521677aa431dda4e94240521a54a8ac21ece07fef009393544d19214d
-  data.tar.gz: c5b41c95f4c24ff4fad28869bf61ff93174118a2d3e5890928961b382bf9b285
+  metadata.gz: e3b0596d3836316a8c9f2dc13b42707da7e4b158cdf17af864c22be88856e76c
+  data.tar.gz: be38909c66845eb4d09187803903f46cbe8d4392d0245d089aa7aec03c0ac7af
 SHA512:
-  metadata.gz: 715a03576aed152e2fd5737236eb227dd98da9f02b421a14722395a3b9992dc667302574490955f0f9d81192dc5f64f793d916b196bc4509244afad5daa8a37b
-  data.tar.gz: 475df2645d537e5c8151ba6431e1469fdcfdd1a80d766489bfa00b135f3c3e57a86b0c09c7e6738c6033609a69864a596660a0b5498bd6762e314588a67bac35
+  metadata.gz: cfe44962b770aa87464249cd41540e2c26cce61a1b59292fca71b3d79331595483214e22eaa907e3b8453d49a75365219291d196854d843ec09ac1c4ed3b19dd
+  data.tar.gz: 3b6cd6cfeb4fd440c43385462ac3147606389f2afe046eab45cdd3cd9b626dc1fd6e7cdce39c4c5f9b060ea659b99b6ffb7a9ab930a5edb393a11e64f7234557

data/README.md

@@ -1,3 +1,3 @@
 # A Literal Ruby Gem
 
-See the website for [documentation](https://literal.fun/docs).
+See the website for [documentation](https://literal.fun/docs/).

data/lib/literal/array.rb

@@ -23,7 +23,7 @@ class Literal::Array
 		def >=(other)
 			case other
 			when Literal::Array::Generic
-				@type >= other.type
+				Literal.subtype?(other.type, of: @type)
 			else
 				false
 			end
@@ -32,6 +32,19 @@ class Literal::Array
 		def inspect
 			"Literal::Array(#{@type.inspect})"
 		end
+
+		def coerce(value)
+			case value
+			when self
+				value
+			when Array
+				Literal::Array.new(value, type: @type)
+			end
+		end
+
+		def to_proc
+			method(:coerce).to_proc
+		end
 	end
 
 	include Enumerable
@@ -224,6 +237,10 @@ class Literal::Array
 		@__value__.each(...)
 	end
 
+	def each_index(...)
+		@__value__.each_index(...)
+	end
+
 	def empty?
 		@__value__.empty?
 	end
@@ -256,6 +273,14 @@ class Literal::Array
 		super
 	end
 
+	def hash
+		[self.class, @__value__].hash
+	end
+
+	def include?(...)
+		@__value__.include?(...)
+	end
+
 	alias_method :index, :find_index
 
 	def insert(index, *value)
@@ -268,7 +293,7 @@ class Literal::Array
 	end
 
 	def inspect
-		@__value__.inspect
+		"Literal::Array(#{@__type__.inspect})#{@__value__.inspect}"
 	end
 
 	def intersect?(other)
@@ -389,10 +414,44 @@ class Literal::Array
 		@__value__.one?(...)
 	end
 
+	def pack(...)
+		@__value__.pack(...)
+	end
+
 	def pop(...)
 		@__value__.pop(...)
 	end
 
+	def product(*others, &)
+		if block_given?
+			@__value__.product(
+				*others.map do |other|
+					case other
+					when Array
+						other
+					when Literal::Array
+						other.__value__
+					end
+				end, &
+			)
+
+			self
+		elsif others.all?(Literal::Array)
+			tuple_type = Literal::Tuple(
+				@__type__,
+				*others.map(&:__type__)
+			)
+
+			values = @__value__.product(*others.map(&:__value__)).map do |tuple_values|
+				tuple_type.new(*tuple_values)
+			end
+
+			Literal::Array(tuple_type).new(*values)
+		else
+			@__value__.product(*others)
+		end
+	end
+
 	def push(*value)
 		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#push")
@@ -434,6 +493,17 @@ class Literal::Array
 		self
 	end
 
+	alias_method :initialize_copy, :replace
+
+	def rotate(...)
+		__with__(@__value__.rotate(...))
+	end
+
+	def rotate!(...)
+		@__value__.rotate!(...)
+		self
+	end
+
 	def sample(...)
 		@__value__.sample(...)
 	end
@@ -444,12 +514,22 @@ class Literal::Array
 
 	def select!(...)
 		@__value__.select!(...)
+		self
 	end
 
 	def shift(...)
 		@__value__.shift(...)
 	end
 
+	def shuffle(...)
+		__with__(@__value__.shuffle(...))
+	end
+
+	def shuffle!(...)
+		@__value__.shuffle!(...)
+		self
+	end
+
 	def size(...)
 		@__value__.size(...)
 	end
@@ -463,13 +543,50 @@ class Literal::Array
 		self
 	end
 
+	def sort_by!(...)
+		@__value__.sort_by!(...)
+		self
+	end
+
+	def take(...)
+		__with__(@__value__.take(...))
+	end
+
+	def take_while(...)
+		__with__(@__value__.take_while(...))
+	end
+
+	def transpose
+		case @__type__
+		when Literal::Tuple::Generic
+			tuple_types = @__type__.types
+			new_array_types = tuple_types.map { |t| Literal::Array(t) }
+
+			Literal::Tuple(*new_array_types).new(
+				*new_array_types.each_with_index.map do |t, i|
+					t.new(
+						*@__value__.map { |it| it[i] }
+					)
+				end
+			)
+		when Literal::Array::Generic
+			__with__(
+				@__value__.map(&:to_a).transpose.map! { |it| @__type__.new(*it) }
+			)
+		else
+			@__value__.transpose
+		end
+	end
+
 	def to_a
 		@__value__.dup
 	end
 
 	alias_method :to_ary, :to_a
 
-	alias_method :to_s, :inspect
+	def to_s
+		@__value__.to_s
+	end
 
 	def uniq
 		__with__(@__value__.uniq)
@@ -541,4 +658,75 @@ class Literal::Array
 	def fetch(...)
 		@__value__.fetch(...)
 	end
+
+	def zip(*others)
+		other_types = others.map do |other|
+			case other
+			when Literal::Array
+				other.__type__
+			when Array
+				_Any?
+			else
+				raise ArgumentError
+			end
+		end
+
+		tuple = Literal::Tuple(
+			@__type__,
+			*other_types
+		)
+
+		my_length = length
+		max_length = [my_length, *others.map(&:length)].max
+
+		# Check we match the max length or our type is nilable
+		unless my_length == max_length || @__type__ === nil
+			raise ArgumentError.new(<<~MESSAGE)
+				The literal array could not be zipped becuase its type is not nilable and it has fewer items than the maximum number of items in the other arrays.
+
+				You can either make the type of this array nilable, or add more items so its length matches the others.
+
+				#{inspect}
+			MESSAGE
+		end
+
+		# Check others match the max length or their types is nilable
+		others.each_with_index do |other, index|
+			unless other.length == max_length || other_types[index] === nil
+				raise ArgumentError.new(<<~MESSAGE)
+					The literal array could not be zipped becuase its type is not nilable and it has fewer items than the maximum number of items in the other arrays.
+
+					You can either make the type of this array nilable, or add more items so its length matches the others.
+
+					#{inspect}
+				MESSAGE
+			end
+		end
+
+		i = 0
+
+		if block_given?
+			while i < max_length
+				yield tuple.new(
+					@__value__[i],
+					*others.map { |it| it[i] }
+				)
+				i += 1
+			end
+
+			nil
+		else
+			result_value = []
+
+			while i < max_length
+				result_value << tuple.new(
+					@__value__[i],
+					*others.map { |it| it[i] }
+				)
+				i += 1
+			end
+
+			__with__(result_value)
+		end
+	end
 end

data/lib/literal/data.rb

@@ -9,17 +9,11 @@ class Literal::Data < Literal::DataStructure
 		def literal_properties
 			return @literal_properties if defined?(@literal_properties)
 
-			if superclass.is_a?(Literal::Data)
+			if superclass < Literal::Data
 				@literal_properties = superclass.literal_properties.dup
 			else
 				@literal_properties = Literal::Properties::DataSchema.new
 			end
 		end
-
-		private
-
-		def __literal_property_class__
-			Literal::DataProperty
-		end
 	end
 end

data/lib/literal/enum.rb

@@ -9,17 +9,19 @@ class Literal::Enum
 		attr_reader :members
 
 		def values = @values.keys
+		def names = @names
 
-		def prop(name, type, kind = :keyword, reader: :public, default: nil)
-			super(name, type, kind, reader:, writer: false, default:)
+		def prop(name, type, kind = :keyword, reader: :public, predicate: false, default: nil)
+			super(name, type, kind, reader:, writer: false, predicate:, default:)
 		end
 
 		def inherited(subclass)
 			subclass.instance_exec do
 				@values = {}
-				@members = Set[]
+				@members = []
+				@indexes_definitions = {}
 				@indexes = {}
-				@index = {}
+				@names = {}
 			end
 
 			if RUBY_ENGINE != "truffleruby"
@@ -32,8 +34,16 @@ class Literal::Enum
 			end
 		end
 
+		def position_of(member)
+			coerce(member).__position__
+		end
+
+		def at_position(n)
+			@members[n]
+		end
+
 		def index(name, type, unique: true, &block)
-			@indexes[name] = [type, unique, block || name.to_proc]
+			@indexes_definitions[name] = [type, unique, block || name.to_proc]
 		end
 
 		def where(**kwargs)
@@ -43,11 +53,11 @@ class Literal::Enum
 
 			key, value = kwargs.first
 
-			types = @indexes.fetch(key)
+			types = @indexes_definitions.fetch(key)
 			type = types.first
 			Literal.check(actual: value, expected: type) { |c| raise NotImplementedError }
 
-			@index.fetch(key)[value]
+			@indexes.fetch(key)[value]
 		end
 
 		def find_by(**kwargs)
@@ -57,15 +67,15 @@ class Literal::Enum
 
 			key, value = kwargs.first
 
-			unless @indexes.fetch(key)[1]
+			unless @indexes_definitions.fetch(key)[1]
 				raise ArgumentError.new("You can only use `find_by` on unique indexes.")
 			end
 
-			unless (type = @indexes.fetch(key)[0]) === value
+			unless (type = @indexes_definitions.fetch(key)[0]) === value
 				raise Literal::TypeError.expected(value, to_be_a: type)
 			end
 
-			@index.fetch(key)[value]&.first
+			@indexes.fetch(key)[value]&.first
 		end
 
 		def _load(data)
@@ -77,9 +87,8 @@ class Literal::Enum
 			object = const_get(name)
 
 			if self === object
-				object.instance_variable_set(:@name, name)
-				@values[object.value] = object
-				@members << object
+				# object.instance_variable_set(:@name, name)
+				@names[object] = name
 				define_method("#{name.to_s.gsub(/([^A-Z])([A-Z]+)/, '\1_\2').downcase}?") { self == object }
 				object.freeze
 			end
@@ -87,12 +96,21 @@ class Literal::Enum
 
 		def new(*args, **kwargs, &block)
 			raise ArgumentError if frozen?
+
 			new_object = super(*args, **kwargs, &nil)
 
-			if block
-				new_object.instance_exec(&block)
+			if @values.key?(new_object.value)
+				raise ArgumentError.new("The value #{new_object.value} is already used by #{@values[new_object.value].name}.")
 			end
 
+			@values[new_object.value] = new_object
+
+			new_object.instance_variable_set(:@__position__, @members.length)
+
+			@members << new_object
+
+			new_object.instance_exec(&block) if block
+
 			new_object
 		end
 
@@ -103,7 +121,7 @@ class Literal::Enum
 				constants(false).each { |name| const_added(name) }
 			end
 
-			@indexes.each do |name, (type, unique, block)|
+			@indexes_definitions.each do |name, (type, unique, block)|
 				index = @members.group_by(&block).freeze
 
 				index.each do |key, values|
@@ -116,7 +134,7 @@ class Literal::Enum
 					end
 				end
 
-				@index[name] = index
+				@indexes[name] = index
 			end
 
 			@values.freeze
@@ -146,8 +164,20 @@ class Literal::Enum
 			case value
 			when self
 				value
+			when Symbol
+				self[value] || begin
+					const_get(value)
+				rescue NameError
+					raise ArgumentError.new(
+						"Can't coerce #{value.inspect} into a #{inspect}."
+					)
+				end
 			else
-				self[value]
+				self[value] || raise(
+					ArgumentError.new(
+						"Can't coerce #{value.inspect} into a #{inspect}."
+					)
+				)
 			end
 		end
 
@@ -155,25 +185,22 @@ class Literal::Enum
 			method(:coerce).to_proc
 		end
 
-		def to_h(*args)
-			@values.dup
+		def to_h(&)
+			if block_given?
+				@members.to_h(&)
+			else
+				@members.to_h { |it| [it, it.value] }
+			end
 		end
 	end
 
-	def initialize(name, value, &block)
-		@name = name
-		@value = value
-		instance_exec(&block) if block
-		freeze
-	end
-
-	attr_reader :value
-
 	def name
-		"#{self.class.name}::#{@name}"
+		klass = self.class
+		"#{klass.name}::#{klass.names[self]}"
 	end
 
 	alias_method :inspect, :name
+	alias_method :to_s, :name
 
 	def deconstruct
 		[@value]
@@ -187,4 +214,27 @@ class Literal::Enum
 	def _dump(level)
 		Marshal.dump(@value)
 	end
+
+	def <=>(other)
+		case other
+		when self.class
+			@__position__ <=> other.__position__
+		else
+			raise ArgumentError.new("Can't compare instances of #{other.class} to instances of #{self.class}")
+		end
+	end
+
+	def succ
+		self.class.members[@__position__ + 1]
+	end
+
+	def pred
+		if @__position__ <= 0
+			nil
+		else
+			self.class.members[@__position__ - 1]
+		end
+	end
+
+	attr_reader :__position__
 end

data/lib/literal/failure.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Failure < Literal::Result
+	def initialize(error)
+		@error = error
+	end
+end

data/lib/literal/null.rb

@@ -5,5 +5,9 @@ module Literal::Null
 		"Literal::Null"
 	end
 
+	def self.===(value)
+		self == value
+	end
+
 	freeze
 end

data/lib/literal/property.rb

@@ -118,29 +118,18 @@ class Literal::Property
 			"\n  value\nend\n"
 	end
 
-	if Literal::TYPE_CHECKS_DISABLED
-		def generate_writer_method(buffer = +"")
-			buffer <<
-				(@writer ? @writer.name : "public") <<
-				" def " <<
-				@name.name <<
-				"=(value)\n" <<
-				"  @#{@name.name} = value\nend\n"
-		end
-	else # type checks are enabled
-		def generate_writer_method(buffer = +"")
-			buffer <<
-				(@writer ? @writer.name : "public") <<
-				" def " <<
-				@name.name <<
-				"=(value)\n" <<
-				"  self.class.literal_properties[:" <<
-				@name.name <<
-				"].check_writer(self, value)\n" <<
-				"  @" << @name.name << " = value\n" <<
-				"rescue Literal::TypeError => error\n  error.set_backtrace(caller(1))\n  raise\n" <<
-				"end\n"
-		end
+	def generate_writer_method(buffer = +"")
+		buffer <<
+			(@writer ? @writer.name : "public") <<
+			" def " <<
+			@name.name <<
+			"=(value)\n" <<
+			"  self.class.literal_properties[:" <<
+			@name.name <<
+			"].check_writer(self, value)\n" <<
+			"  @" << @name.name << " = value\n" <<
+			"rescue Literal::TypeError => error\n  error.set_backtrace(caller(1))\n  raise\n" <<
+			"end\n"
 	end
 
 	def generate_predicate_method(buffer = +"")
@@ -157,7 +146,7 @@ class Literal::Property
 
 	def generate_initializer_handle_property(buffer = +"")
 		buffer << "  # " << @name.name << "\n" <<
-			"  property = __properties__[:" << @name.name << "]\n"
+			"  __property__ = __properties__[:" << @name.name << "]\n"
 
 		if @kind == :keyword && ruby_keyword?
 			generate_initializer_escape_keyword(buffer)
@@ -171,10 +160,7 @@ class Literal::Property
 			generate_initializer_coerce_property(buffer)
 		end
 
-		unless Literal::TYPE_CHECKS_DISABLED
-			generate_initializer_check_type(buffer)
-		end
-
+		generate_initializer_check_type(buffer)
 		generate_initializer_assign_value(buffer)
 	end
 
@@ -191,7 +177,7 @@ class Literal::Property
 	def generate_initializer_coerce_property(buffer = +"")
 		buffer <<
 			escaped_name <<
-			"= property.coerce(" <<
+			"= __property__.coerce(" <<
 			escaped_name <<
 			", context: self)\n"
 	end
@@ -204,12 +190,12 @@ class Literal::Property
 			escaped_name <<
 			"\n    " <<
 			escaped_name <<
-			" = property.default_value\n  end\n"
+			" = __property__.default_value\n  end\n"
 	end
 
 	def generate_initializer_check_type(buffer = +"")
 		buffer <<
-			"  property.check_initializer(self, " << escaped_name << ")\n"
+			"  __property__.check_initializer(self, " << escaped_name << ")\n"
 	end
 
 	def generate_initializer_assign_value(buffer = +"")

data/lib/literal/rails/enum_type.rb

@@ -8,10 +8,10 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 
 	def cast(value)
 		case value
-		when @enum
-			value
+		when nil
+			nil
 		else
-			deserialize(value)
+			@enum.coerce(value)
 		end
 	end
 
@@ -19,12 +19,8 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		case value
 		when nil
 			nil
-		when @enum
-			value.value
 		else
-			raise Literal::ArgumentError.new(
-				"Invalid value: #{value.inspect}. Expected an #{@enum.inspect}.",
-			)
+			@enum.coerce(value).value
 		end
 	end
 
@@ -33,9 +29,7 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		when nil
 			nil
 		else
-			@enum[value] || raise(
-				ArgumentError.new("Invalid value: #{value.inspect} for #{@enum}"),
-			)
+			@enum.coerce(value)
 		end
 	end
 end

data/lib/literal/rails/patches/active_record.rb

@@ -4,9 +4,10 @@ module ActiveRecord
 	class RelationType
 		def initialize(model_class)
 			unless Class === model_class && model_class < ActiveRecord::Base
-				raise Literal::TypeError.expected(
-					model_class,
-					to_be_a: ActiveRecord::Base,
+				raise Literal::TypeError.new(
+					context: Literal::TypeError::Context.new(
+						expected: ActiveRecord::Base, actual: model_class
+					)
 				)
 			end
 

data/lib/literal/railtie.rb

@@ -2,20 +2,14 @@
 
 class Literal::Railtie < Rails::Railtie
 	initializer "literal.register_literal_enum_type" do
-		ActiveRecord::Type.register(:literal_enum) do |name, type:|
-			Literal::Rails::EnumType.new(type)
-		end
-
-		ActiveRecord::Type.register(:literal_flags) do |name, type:|
-			Literal::Rails::FlagsType.new(type)
-		end
-
-		ActiveModel::Type.register(:literal_enum) do |name, type:|
-			Literal::Rails::EnumType.new(type)
-		end
-
-		ActiveModel::Type.register(:literal_flags) do |name, type:|
-			Literal::Rails::FlagsType.new(type)
+		[ActiveRecord::Type, ActiveModel::Type].each do |registry|
+			registry.register(:literal_enum) do |name, type:|
+				Literal::Rails::EnumType.new(type)
+			end
+
+			registry.register(:literal_flags) do |name, type:|
+				Literal::Rails::FlagsType.new(type)
+			end
 		end
 	end
 end

data/lib/literal/result.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Literal::Result
+end

data/lib/literal/success.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Literal::Success < Literal::Result
+	def initialize(value)
+		@value = value
+	end
+end

data/lib/literal/transforms.rb

@@ -54,6 +54,7 @@ Literal::TRANSFORMS = {
 		to_str: String,
 		upcase: String,
 		valid_encoding?: Literal::Types::BooleanType::Instance,
+		to_i: Integer,
 	},
 	Numeric => {
 		to_i: Integer,

data/lib/literal/tuple.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class Literal::Tuple
+	class Generic
+		include Literal::Type
+
+		def initialize(*types)
+			@types = types
+		end
+
+		attr_reader :types
+
+		def ===(other)
+			return false unless Literal::Tuple === other
+			types = @types
+			other_types = other.__types__
+
+			return false unless types.size == other_types.size
+
+			i, len = 0, types.size
+			while i < len
+				return false unless Literal.subtype?(other_types[i], of: types[i])
+				i += 1
+			end
+
+			true
+		end
+
+		def >=(other)
+			case other
+			when Literal::Tuple::Generic
+				types = @types
+				other_types = other.types
+
+				return false unless types.size == other_types.size
+
+				i, len = 0, types.size
+				while i < len
+					return false unless Literal.subtype?(other_types[i], of: types[i])
+					i += 1
+				end
+
+				true
+			else
+				false
+			end
+		end
+
+		def new(*values)
+			Literal::Tuple.new(values, @types)
+		end
+	end
+
+	def initialize(values, types)
+		@__values__ = values
+		@__types__ = types
+	end
+
+	def inspect
+		"Literal::Tuple(#{@__types__.map(&:inspect).join(', ')})#{@__values__.inspect}"
+	end
+
+	attr_reader :__values__, :__types__
+
+	def ==(other)
+		(Literal::Tuple === other) && (@__values__ == other.__values__)
+	end
+
+	def [](index)
+		@__values__[index]
+	end
+end

data/lib/literal/types/constraint_type.rb

@@ -25,14 +25,19 @@ class Literal::Types::ConstraintType
 			i += 1
 		end
 
+		result = true
+
 		@property_constraints.each do |a, t|
-			return false unless t === value.public_send(a)
+			# We intentionally don’t return early here becuase it triggers an allocation.
+			if result && !(t === value.public_send(a))
+				result = false
+			end
 		rescue NoMethodError => e
 			raise unless e.name == a && e.receiver == value
 			return false
 		end
 
-		true
+		result
 	end
 
 	def >=(other)

data/lib/literal/types.rb

@@ -103,6 +103,19 @@ module Literal::Types
 		)
 	end
 
+	# Matches if the value is a `Date` and matches the given constraints.
+	# If you don't need any constraints, use `Date` instead of `_Date`.
+	def _Date(...)
+		_Constraint(Date, ...)
+	end
+
+	# Nilable version of `_Date`
+	def _Date?(...)
+		_Nilable(
+			_Date(...)
+		)
+	end
+
 	def _Deferred(...)
 		DeferredType.new(...)
 	end
@@ -324,6 +337,19 @@ module Literal::Types
 		)
 	end
 
+	# Matches if the value is a `Time` and matches the given constraints.
+	# If you don't need any constraints, use `Time` instead of `_Time`.
+	def _Time(...)
+		_Constraint(Time, ...)
+	end
+
+	# Nilable version of `_Time`
+	def _Time?(...)
+		_Nilable(
+			_Time(...)
+		)
+	end
+
 	# Matches *"truthy"* values (anything except `nil` and `false`).
 	def _Truthy
 		TruthyType::Instance

data/lib/literal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Literal
-	VERSION = "1.3.0"
+	VERSION = "1.5.0"
 end

data/lib/literal.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 module Literal
-	TYPE_CHECKS_DISABLED = ENV["LITERAL_TYPE_CHECKS"] == "false"
-
 	autoload :Array, "literal/array"
 	autoload :Data, "literal/data"
 	autoload :DataProperty, "literal/data_property"
@@ -22,6 +20,7 @@ module Literal
 	autoload :Struct, "literal/struct"
 	autoload :Type, "literal/type"
 	autoload :Types, "literal/types"
+	autoload :Tuple, "literal/tuple"
 
 	# Errors
 	autoload :Error, "literal/errors/error"
@@ -32,7 +31,7 @@ module Literal
 
 	def self.Enum(type)
 		Class.new(Literal::Enum) do
-			prop :value, type, :positional
+			prop :value, type, :positional, reader: :public
 		end
 	end
 
@@ -48,6 +47,10 @@ module Literal
 		Literal::Hash::Generic.new(key_type, value_type)
 	end
 
+	def self.Tuple(*types)
+		Literal::Tuple::Generic.new(*types)
+	end
+
 	def self.check(actual:, expected:)
 		if expected === actual
 			true

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: literal
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Joel Drapper
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-29 00:00:00.000000000 Z
+date: 2025-01-17 00:00:00.000000000 Z
 dependencies: []
-description: A literal Ruby gem.
+description: Enums, properties, generics, structured objects and runtime type checking.
 email:
 - joel@drapper.me
 executables: []
@@ -22,13 +21,13 @@ files:
 - lib/literal.rb
 - lib/literal/array.rb
 - lib/literal/data.rb
-- lib/literal/data_property.rb
 - lib/literal/data_structure.rb
 - lib/literal/deferred_type.rb
 - lib/literal/enum.rb
 - lib/literal/errors/argument_error.rb
 - lib/literal/errors/error.rb
 - lib/literal/errors/type_error.rb
+- lib/literal/failure.rb
 - lib/literal/flags.rb
 - lib/literal/hash.rb
 - lib/literal/null.rb
@@ -43,9 +42,12 @@ files:
 - lib/literal/rails/flags_type.rb
 - lib/literal/rails/patches/active_record.rb
 - lib/literal/railtie.rb
+- lib/literal/result.rb
 - lib/literal/set.rb
 - lib/literal/struct.rb
+- lib/literal/success.rb
 - lib/literal/transforms.rb
+- lib/literal/tuple.rb
 - lib/literal/type.rb
 - lib/literal/types.rb
 - lib/literal/types/any_type.rb
@@ -78,10 +80,9 @@ licenses:
 metadata:
   homepage_uri: https://literal.fun
   source_code_uri: https://github.com/joeldrapper/literal
-  changelog_uri: https://github.com/joeldrapper/literal/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/joeldrapper/literal/releases
   funding_uri: https://github.com/sponsors/joeldrapper
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -96,8 +97,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.18
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Enums, properties, generics, structured objects and runtime type checking.
 test_files: []

data/lib/literal/data_property.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-class Literal::DataProperty < Literal::Property
-	def generate_initializer_assign_value(buffer = +"")
-		buffer <<
-			"@" <<
-			@name.name <<
-			" = " <<
-			escaped_name <<
-			".frozen? ? " <<
-			escaped_name <<
-			" : " <<
-			escaped_name <<
-			".dup.freeze\n"
-	end
-end