literal 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ee13d939895155fc3ce4ae1717036b565b0a59d7a4e87b50ea0a1390cc40bf3
-  data.tar.gz: 42df47f2efce39eb14976d226645adb7a9dacc681948a71a9254ca44e19d8d1f
+  metadata.gz: 98bc237de806f82733e8c812bccc840c5451183afd22f369ecffc6720c3b88ba
+  data.tar.gz: b340a2c25c5d23d033a83dbf3ab1483a9b071424f343f0edf5c104bee83402c2
 SHA512:
-  metadata.gz: f3a9b286744de95185baea476e8d7387238912aeb7f956eeef4e7b203bd0a55313885baaf6c5e71e27eb6d252961d44f850ede7e09abbc05c323c88a099be6f6
-  data.tar.gz: f2cc33927ce452c94b3146dc7714cd9078cd532da5523afbbae5372ec2a5aa0319460db07525d9d7a5d709deb9ff929b804d0f3a86425f3d4844bf641a5a669b
+  metadata.gz: 17b16bdea93b6dff73b9fdcbdd269053648e996f3e2b5d6773933710281b756a50eb93684d727b46711aef990858985111f9d59d80250d20a3f71963767032ca
+  data.tar.gz: 67647cf3e25cdbdbdb12638081a7cbd40b5bee6771d9be54ca4100646740a97989259f24242b60064c41b016c7687d91a3969632d2195a0715c6015bede8e839

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

@@ -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
@@ -276,7 +293,7 @@ class Literal::Array
 	end
 
 	def inspect
-		@__value__.inspect
+		"Literal::Array(#{@__type__.inspect})#{@__value__.inspect}"
 	end
 
 	def intersect?(other)
@@ -497,6 +514,7 @@ class Literal::Array
 
 	def select!(...)
 		@__value__.select!(...)
+		self
 	end
 
 	def shift(...)
@@ -525,17 +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)
@@ -607,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/enum.rb

@@ -9,20 +9,22 @@ 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"
+			if subclass.name && RUBY_ENGINE != "truffleruby"
 				TracePoint.trace(:end) do |tp|
 					if tp.self == subclass
 						tp.self.__after_defined__
@@ -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,14 @@ 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
-				raise Literal::TypeError.expected(value, to_be_a: type)
-			end
+			type = @indexes_definitions.fetch(key)[0]
+			Literal.check(actual: value, expected: type)
 
-			@index.fetch(key)[value]&.first
+			@indexes.fetch(key)[value]&.first
 		end
 
 		def _load(data)
@@ -77,12 +86,8 @@ class Literal::Enum
 			object = const_get(name)
 
 			if self === object
-				if @values.key?(object.value)
-					raise ArgumentError.new("The value #{object.value} is already used by #{@values[object.value].name}.")
-				end
-				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
@@ -90,12 +95,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
 
@@ -106,7 +120,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|
@@ -119,7 +133,7 @@ class Literal::Enum
 					end
 				end
 
-				@index[name] = index
+				@indexes[name] = index
 			end
 
 			@values.freeze
@@ -149,8 +163,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
 
@@ -167,20 +193,13 @@ class Literal::Enum
 		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]
@@ -194,4 +213,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/properties/schema.rb

@@ -102,7 +102,7 @@ class Literal::Properties::Schema
 		i, n = 0, sorted_properties.size
 		while i < n
 			property = sorted_properties[i]
-			buffer << "  @" << property.name.name << " == other." << property.name.name
+			buffer << "  @#{property.name.name} == other.instance_variable_get(:@#{property.name.name})"
 			buffer << " &&\n  " if i < n - 1
 			i += 1
 		end

data/lib/literal/properties.rb

@@ -30,7 +30,7 @@ module Literal::Properties
 		end
 
 		unless Literal::Property::VISIBILITY_OPTIONS.include?(predicate)
-				raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
+			raise Literal::ArgumentError.new("The predicate must be one of #{Literal::Property::VISIBILITY_OPTIONS.map(&:inspect).join(', ')}.")
 		end
 
 		if reader && :class == name
@@ -90,7 +90,7 @@ module Literal::Properties
 				end
 
 				def to_h
-						{}
+					{}
 				end
 
 				set_temporary_name "Literal::Properties(Extension)" if respond_to?(:set_temporary_name)

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 = +"")
@@ -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
 

data/lib/literal/rails/enum_type.rb

@@ -6,12 +6,16 @@ class Literal::Rails::EnumType < ActiveModel::Type::Value
 		super()
 	end
 
+	def type
+		:literal_enum
+	end
+
 	def cast(value)
 		case value
-		when @enum
-			value
+		when nil
+			nil
 		else
-			deserialize(value)
+			@enum.coerce(value)
 		end
 	end
 
@@ -19,12 +23,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 +33,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

@@ -56,5 +56,17 @@ class Literal::Tuple
 		@__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/array_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ArrayType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/class_type.rb

@@ -6,6 +6,7 @@ class Literal::Types::ClassType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type

data/lib/literal/types/constraint_type.rb

@@ -7,6 +7,7 @@ class Literal::Types::ConstraintType
 	def initialize(*object_constraints, **property_constraints)
 		@object_constraints = object_constraints
 		@property_constraints = property_constraints
+		freeze
 	end
 
 	attr_reader :object_constraints
@@ -25,14 +26,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/descendant_type.rb

@@ -5,6 +5,7 @@ class Literal::Types::DescendantType
 
 	def initialize(type)
 		@type = type
+		freeze
 	end
 
 	attr_reader :type