literal 1.2.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d40ba211b6f7b2ad3dad97feb118d3742b43dbd2f1773daa8d6979f597cbf428
-  data.tar.gz: 1fb316fac766b9b25041c2bc201c8ddaed8d3e59ed5f5aec9c7f93f0306df921
+  metadata.gz: 8ee13d939895155fc3ce4ae1717036b565b0a59d7a4e87b50ea0a1390cc40bf3
+  data.tar.gz: 42df47f2efce39eb14976d226645adb7a9dacc681948a71a9254ca44e19d8d1f
 SHA512:
-  metadata.gz: 37fee8ee4d14f41573f5a4ce2d27d3d98bc1b78a54a35d850a41fbeedfc7e1b1f6f8a3533cbb82c35b81212079d4f495ad17cde8651a7b56fff3e6ecb99b5078
-  data.tar.gz: ca6fa6e45d9a344880ebbbfba69c82f9444809ad4b6645e89c4cc0c89c58e78ac66d2edf80612cb2084bac0b46b9c0a686458983f47ff5716f4016b9545f723c
+  metadata.gz: f3a9b286744de95185baea476e8d7387238912aeb7f956eeef4e7b203bd0a55313885baaf6c5e71e27eb6d252961d44f850ede7e09abbc05c323c88a099be6f6
+  data.tar.gz: f2cc33927ce452c94b3146dc7714cd9078cd532da5523afbbae5372ec2a5aa0319460db07525d9d7a5d709deb9ff929b804d0f3a86425f3d4844bf641a5a669b

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
@@ -176,6 +176,11 @@ class Literal::Array
 		self
 	end
 
+	def combination(...)
+		@__value__.combination(...)
+		self
+	end
+
 	def compact
 		# @TODO if this is an array of nils, we should return an emtpy array
 		__with__(@__value__)
@@ -190,6 +195,19 @@ class Literal::Array
 		@__value__.count(...)
 	end
 
+	def delete(...)
+		@__value__.delete(...)
+	end
+
+	def delete_at(...)
+		@__value__.delete_at(...)
+	end
+
+	def delete_if(...)
+		@__value__.delete_if(...)
+		self
+	end
+
 	def dig(...)
 		@__value__.dig(...)
 	end
@@ -221,15 +239,33 @@ class Literal::Array
 		self
 	end
 
+	def flatten(...)
+		__with__(@__value__.flatten(...))
+	end
+
 	def first(...)
 		@__value__.first(...)
 	end
 
+	def flatten!(...)
+		@__value__.flatten!(...) ? self : nil
+	end
+
 	def freeze
 		@__value__.freeze
 		super
 	end
 
+	def hash
+		[self.class, @__value__].hash
+	end
+
+	def include?(...)
+		@__value__.include?(...)
+	end
+
+	alias_method :index, :find_index
+
 	def insert(index, *value)
 		Literal.check(actual: value, expected: _Array(@__type__)) do |c|
 			c.fill_receiver(receiver: self, method: "#insert")
@@ -239,6 +275,21 @@ class Literal::Array
 		self
 	end
 
+	def inspect
+		@__value__.inspect
+	end
+
+	def intersect?(other)
+		case other
+		when ::Array
+			@__value__.intersect?(other)
+		when Literal::Array
+			@__value__.intersect?(other.__value__)
+		else
+			raise ArgumentError.new("Cannot perform `intersect?` with #{other.class.name}.")
+		end
+	end
+
 	def intersection(*values)
 		values.map! do |value|
 			case value
@@ -252,6 +303,20 @@ class Literal::Array
 		__with__(@__value__.intersection(*values))
 	end
 
+	def	join(...)
+		@__value__.join(...)
+	end
+
+	def keep_if(...)
+		return_value = @__value__.keep_if(...)
+		case return_value
+		when Array
+			self
+		else
+			return_value
+		end
+	end
+
 	def last(...)
 		@__value__.last(...)
 	end
@@ -285,6 +350,10 @@ class Literal::Array
 
 	alias_method :collect!, :map!
 
+	def sum(...)
+		@__value__.sum(...)
+	end
+
 	def max(n = nil, &)
 		if n
 			__with__(@__value__.max(n, &))
@@ -305,14 +374,67 @@ class Literal::Array
 		__with__(@__value__.minmax(...))
 	end
 
+	def narrow(type)
+		unless Literal.subtype?(type, of: @__type__)
+			raise ArgumentError.new("Cannot narrow #{@__type__} to #{type}")
+		end
+
+		if __type__ != type
+			@__value__.each do |item|
+				Literal.check(actual: item, expected: type) do |c|
+					c.fill_receiver(receiver: self, method: "#narrow")
+				end
+			end
+		end
+
+		Literal::Array.allocate.__initialize_without_check__(
+			@__value__,
+			type:,
+		)
+	end
+
 	def one?(...)
 		@__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")
@@ -354,14 +476,42 @@ 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
 
+	def select(...)
+		__with__(@__value__.select(...))
+	end
+
+	def select!(...)
+		@__value__.select!(...)
+	end
+
 	def shift(...)
 		@__value__.shift(...)
 	end
 
+	def shuffle(...)
+		__with__(@__value__.shuffle(...))
+	end
+
+	def shuffle!(...)
+		@__value__.shuffle!(...)
+		self
+	end
+
 	def size(...)
 		@__value__.size(...)
 	end
@@ -375,12 +525,18 @@ class Literal::Array
 		self
 	end
 
+	def take(...)
+		__with__(@__value__.take(...))
+	end
+
 	def to_a
 		@__value__.dup
 	end
 
 	alias_method :to_ary, :to_a
 
+	alias_method :to_s, :inspect
+
 	def uniq
 		__with__(@__value__.uniq)
 	end
@@ -425,4 +581,30 @@ class Literal::Array
 			@__value__.values_at(*indexes)
 		)
 	end
+
+	def |(other)
+		case other
+		when ::Array
+			Literal.check(actual: other, expected: _Array(@__type__)) do |c|
+				c.fill_receiver(receiver: self, method: "#|")
+			end
+
+			__with__(@__value__ | other)
+		when Literal::Array(@__type__)
+			__with__(@__value__ | other.__value__)
+		when Literal::Array
+			raise Literal::TypeError.new(
+				context: Literal::TypeError::Context.new(
+					expected: Literal::Array(@__type__),
+					actual: other
+				)
+			)
+		else
+			raise ArgumentError.new("Cannot perform `|` with #{other.class.name}.")
+		end
+	end
+
+	def fetch(...)
+		@__value__.fetch(...)
+	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/deferred_type.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Literal::Types::DeferredType
+	include Literal::Type
+
+	def initialize(&block)
+		@block = block
+	end
+
+	attr_reader :block
+
+	def inspect
+		"_Deferred"
+	end
+
+	def ===(other)
+		@block.call === other
+	end
+
+	def >=(other)
+		Literal.subtype?(other, of: @block.call)
+	end
+end

data/lib/literal/enum.rb

@@ -77,6 +77,9 @@ 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
@@ -155,8 +158,12 @@ 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
 

data/lib/literal/properties/schema.rb

@@ -154,7 +154,7 @@ class Literal::Properties::Schema
 	end
 
 	def generate_initializer_body(buffer = +"")
-		buffer << "  properties = self.class.literal_properties.properties_index\n"
+		buffer << "  __properties__ = self.class.literal_properties.properties_index\n"
 		generate_initializer_handle_properties(@sorted_properties, buffer)
 	end
 

data/lib/literal/property.rb

@@ -157,7 +157,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)
@@ -191,7 +191,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 +204,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/transforms.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+# A map of core types to transform Procs mapping to the new type.
+Literal::TRANSFORMS = {
+	Integer => {
+		abs: Integer,
+		ceil: Integer,
+		chr: String,
+		denominator: Integer,
+		even?: Literal::Types::BooleanType::Instance,
+		floor: Integer,
+		hash: Integer,
+		inspect: String,
+		integer?: true,
+		magnitude: Integer,
+		negative?: Literal::Types::BooleanType::Instance,
+		next: Integer,
+		numerator: Integer,
+		odd?: Literal::Types::BooleanType::Instance,
+		ord: Integer,
+		positive?: Literal::Types::BooleanType::Instance,
+		pred: Integer,
+		round: Integer,
+		size: Integer,
+		succ: Integer,
+		to_f: Float,
+		to_i: Integer,
+		to_int: Integer,
+		to_r: Rational,
+		to_s: String,
+		truncate: Integer,
+		zero?: Literal::Types::BooleanType::Instance,
+	},
+	String => {
+		ascii_only?: Literal::Types::BooleanType::Instance,
+		bytesize: Integer,
+		capitalize: String,
+		chomp: String,
+		chop: String,
+		downcase: String,
+		dump: String,
+		empty?: Literal::Types::BooleanType::Instance,
+		hash: Integer,
+		inspect: String,
+		length: Integer,
+		lstrip: String,
+		ord: Integer,
+		reverse: String,
+		rstrip: String,
+		scrub: String,
+		size: Integer,
+		strip: String,
+		swapcase: String,
+		to_str: String,
+		upcase: String,
+		valid_encoding?: Literal::Types::BooleanType::Instance,
+	},
+	Numeric => {
+		to_i: Integer,
+		to_f: Float,
+		to_s: String,
+	},
+	Array => {
+		size: Integer,
+		length: Integer,
+		empty?: Literal::Types::BooleanType::Instance,
+		sort: Array,
+		to_a: Array,
+		to_ary: Array,
+	},
+	Hash => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		keys: Array,
+		length: Integer,
+		size: Integer,
+		to_a: Array,
+		to_h: Hash,
+		to_s: String,
+		values: Array,
+	},
+	Set => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		length: Integer,
+		size: Integer,
+		to_a: Array,
+		to_s: String,
+	},
+	Float => {
+		abs: Float,
+		ceil: Integer,
+		floor: Integer,
+		nan?: Literal::Types::BooleanType::Instance,
+		negative?: Literal::Types::BooleanType::Instance,
+		positive?: Literal::Types::BooleanType::Instance,
+		round: Integer,
+		to_i: Integer,
+		to_s: String,
+		truncate: Integer,
+		zero?: Literal::Types::BooleanType::Instance,
+	},
+	Symbol => {
+		empty?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		length: Integer,
+		size: Integer,
+		to_s: String,
+		to_sym: Symbol,
+	},
+	Range => {
+		begin: Object,
+		end: Object,
+		exclude_end?: Literal::Types::BooleanType::Instance,
+		first: Object,
+		last: Object,
+		max: Object,
+		min: Object,
+		size: Integer,
+		to_a: Array,
+		to_s: String,
+	},
+	Regexp => {
+		casefold?: Literal::Types::BooleanType::Instance,
+		inspect: String,
+		source: String,
+		to_s: String,
+	},
+	Time => {
+		day: Integer,
+		hour: Integer,
+		inspect: String,
+		min: Integer,
+		month: Integer,
+		sec: Integer,
+		to_a: Array,
+		to_f: Float,
+		to_i: Integer,
+		to_s: String,
+		year: Integer,
+	},
+}.transform_values! { |it| it.transform_keys(&:to_proc) }.freeze

data/lib/literal/tuple.rb

@@ -0,0 +1,60 @@
+# 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
+
+	attr_reader :__values__, :__types__
+end

data/lib/literal/types/any_type.rb

@@ -2,6 +2,8 @@
 
 # @api private
 class Literal::Types::AnyType
+	Instance = new.freeze
+
 	include Literal::Type
 
 	def inspect
@@ -16,7 +18,5 @@ class Literal::Types::AnyType
 		!(other === nil)
 	end
 
-	Instance = new.freeze
-
 	freeze
 end

data/lib/literal/types/boolean_type.rb

@@ -2,6 +2,8 @@
 
 # @api private
 class Literal::Types::BooleanType
+	Instance = new.freeze
+
 	include Literal::Type
 
 	def inspect
@@ -21,7 +23,5 @@ class Literal::Types::BooleanType
 		end
 	end
 
-	Instance = new.freeze
-
 	freeze
 end

data/lib/literal/types/constraint_type.rb

@@ -40,7 +40,7 @@ class Literal::Types::ConstraintType
 		when Literal::Types::ConstraintType
 			other_object_constraints = other.object_constraints
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.all? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
 			end
 
 			other_property_constraints = other.property_constraints
@@ -52,10 +52,12 @@ class Literal::Types::ConstraintType
 		when Literal::Types::IntersectionType
 			other_object_constraints = other.types
 			return false unless @object_constraints.all? do |constraint|
-				other_object_constraints.all? { |c| Literal.subtype?(c, of: constraint) }
+				other_object_constraints.any? { |c| Literal.subtype?(c, of: constraint) }
 			end
 
 			true
+		when Literal::Types::FrozenType
+			@object_constraints.all? { |constraint| Literal.subtype?(other.type, of: constraint) }
 		else
 			false
 		end

data/lib/literal/types/falsy_type.rb

@@ -2,6 +2,8 @@
 
 # @api private
 class Literal::Types::FalsyType
+	Instance = new.freeze
+
 	include Literal::Type
 
 	def initialize
@@ -25,7 +27,5 @@ class Literal::Types::FalsyType
 		end
 	end
 
-	Instance = new.freeze
-
 	freeze
 end