rtype 0.6.8-java

data/benchmark/benchmark.rb

@@ -0,0 +1,200 @@
+require 'benchmark/ips'
+
+is_mri = RUBY_ENGINE == 'ruby'
+
+require "rtype"
+require "rubype" if is_mri
+require "sig"
+require "contracts"
+require "contracts/version"
+require "typecheck"
+
+puts "Ruby version: #{RUBY_VERSION}"
+puts "Ruby engine: #{RUBY_ENGINE}"
+puts "Ruby description: #{RUBY_DESCRIPTION}"
+
+puts "Rtype version: #{Rtype::VERSION}"
+puts "Rubype version: #{Rubype::VERSION}" if is_mri
+puts "Sig version: #{Sig::VERSION}"
+puts "Contracts version: #{Contracts::VERSION}"
+puts "Typecheck version: #{Typecheck::VERSION}"
+
+if !Rtype::NATIVE_EXT_VERSION.nil?
+	puts "Rtype with native extension"
+elsif !Rtype::JAVA_EXT_VERSION.nil?
+	puts "Rtype with java extension"
+else
+	puts "Rtype without native extension"
+end
+
+class PureTest
+	def sum(x, y)
+		x + y
+	end
+
+	def mul(x, y)
+		x * y
+	end
+
+	def args(a, b, c, d)
+	end
+end
+pure_obj = PureTest.new
+
+class RtypeTest
+	rtype [Numeric, Numeric] => Numeric
+	def sum(x, y)
+		x + y
+	end
+
+	rtype [:to_i, :to_i] => Numeric
+	def mul(x, y)
+		x * y
+	end
+
+	rtype [Integer, Numeric, String, :to_i] => Any
+	def args(a, b, c, d)
+	end
+end
+rtype_obj = RtypeTest.new
+
+if is_mri
+	class RubypeTest
+		def sum(x, y)
+			x + y
+		end
+		typesig :sum, [Numeric, Numeric] => Numeric
+
+		def mul(x, y)
+			x * y
+		end
+		typesig :mul, [:to_i, :to_i] => Numeric
+
+		def args(a, b, c, d)
+		end
+		typesig :args, [Integer, Numeric, String, :to_i] => Any
+	end
+	rubype_obj = RubypeTest.new
+end
+
+class SigTest
+	sig [Numeric, Numeric], Numeric,
+	def sum(x, y)
+		x + y
+	end
+
+	sig [:to_i, :to_i], Numeric,
+	def mul(x, y)
+		x * y
+	end
+
+	# nil means wildcard
+	sig [Integer, Numeric, String, :to_i], nil,
+	def args(a, b, c, d)
+	end
+end
+sig_obj = SigTest.new
+
+class ContractsTest
+	include Contracts
+
+	Contract Num, Num => Num
+	def sum(x, y)
+		x + y
+	end
+
+	Contract RespondTo[:to_i], RespondTo[:to_i] => Num
+	def mul(x, y)
+		x * y
+	end
+
+	Contract Int, Num, String, RespondTo[:to_i] => Any
+	def args(a, b, c, d)
+	end
+end
+contracts_obj = ContractsTest.new
+
+class TypecheckTest
+	extend Typecheck
+
+	typecheck 'Numeric, Numeric -> Numeric',
+	def sum(x, y)
+		x + y
+	end
+
+	typecheck '#to_i, #to_i -> Numeric',
+	def mul(x, y)
+		x * y
+	end
+
+	typecheck 'Integer, Numeric, String, #to_i -> BasicObject',
+	def args(a, b, c, d)
+	end
+end
+typecheck_obj = TypecheckTest.new
+
+Benchmark.ips do |x|
+	x.report("pure") do |times|
+		i = 0
+		while i < times
+			pure_obj.sum(1, 2)
+			pure_obj.mul(1, 2)
+			pure_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("rtype") do |times|
+		i = 0
+		while i < times
+			rtype_obj.sum(1, 2)
+			rtype_obj.mul(1, 2)
+			rtype_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	if is_mri
+		x.report("rubype") do |times|
+			i = 0
+			while i < times
+				rubype_obj.sum(1, 2)
+				rubype_obj.mul(1, 2)
+				rubype_obj.args(1, 2, "c", 4)
+				i += 1
+			end
+		end
+	end
+	
+	x.report("sig") do |times|
+		i = 0
+		while i < times
+			sig_obj.sum(1, 2)
+			sig_obj.mul(1, 2)
+			sig_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("contracts") do |times|
+		i = 0
+		while i < times
+			contracts_obj.sum(1, 2)
+			contracts_obj.mul(1, 2)
+			contracts_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.report("typecheck") do |times|
+		i = 0
+		while i < times
+			typecheck_obj.sum(1, 2)
+			typecheck_obj.mul(1, 2)
+			typecheck_obj.args(1, 2, "c", 4)
+			i += 1
+		end
+	end
+
+	x.compare!
+end

data/lib/rtype/argument_type_error.rb

@@ -0,0 +1,4 @@
+module Rtype
+	class ArgumentTypeError < ArgumentError
+	end
+end

data/lib/rtype/behavior/and.rb

@@ -0,0 +1,24 @@
+module Rtype
+	module Behavior
+		class And < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				@types.all? do |e|
+					Rtype::valid? e, value
+				end
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| Rtype::type_error_message(e, value) }
+				arr.join "\nAND "
+			end
+		end
+	end
+
+	def self.and(*args)
+		Behavior::And[*args]
+	end
+end

data/lib/rtype/behavior/base.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+		class Base
+			def self.[](*vals)
+				new(*vals)
+			end
+
+			def valid?(value)
+				raise NotImplementedError, "Abstract method"
+			end
+
+			def error_message(value)
+				raise NotImplementedError, "Abstract method"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/core_ext.rb

@@ -0,0 +1,174 @@
+class Object
+	# @return [Rtype::Behavior::And]
+	def and(*others)
+		::Rtype::and(self, *others)
+	end
+
+	# @return [Rtype::Behavior::Nilable]
+	def nilable
+		::Rtype::nilable(self)
+	end
+	alias_method :or_nil, :nilable
+
+	# @return [Rtype::Behavior::Not]
+	def not
+		::Rtype::not(self)
+	end
+
+	# @return [Rtype::Behavior::Xor]
+	def xor(*others)
+		::Rtype::xor(self, *others)
+	end
+end
+
+class Array
+	# @return [Rtype::Behavior::TypedArray]
+	def self.of(type_sig)
+		::Rtype::Behavior::TypedArray.new(type_sig)
+	end
+	
+	# @return [Rtype::Behavior::And]
+	def comb
+		::Rtype::Behavior::And[*self]
+	end
+end
+
+class Set
+	# @return [Rtype::Behavior::TypedSet]
+	def self.of(type_sig)
+		::Rtype::Behavior::TypedSet.new(type_sig)
+	end
+end
+
+class Hash
+	# @return [Rtype::Behavior::TypedHash]
+	def self.of(key_type, value_type)
+		::Rtype::Behavior::TypedHash.new(key_type, value_type)
+	end
+end
+
+class Num
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::NumericCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::NumericCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::NumericCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::NumericCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::NumericCheck]
+	# @example Value must be a Numeric and > 2
+	#   rtype [Num > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::NumericCheck.new(:==, x)
+	end
+end
+
+class Int
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::IntegerCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::IntegerCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::IntegerCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::IntegerCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::IntegerCheck]
+	# @example Value must be a Integer and > 2
+	#   rtype [Int > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::IntegerCheck.new(:==, x)
+	end
+end
+
+class Flo
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>(x)
+		::Rtype::Behavior::FloatCheck.new(:>, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.>=(x)
+		::Rtype::Behavior::FloatCheck.new(:>=, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<(x)
+		::Rtype::Behavior::FloatCheck.new(:<, x)
+	end
+
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.<=(x)
+		::Rtype::Behavior::FloatCheck.new(:<=, x)
+	end
+	
+	# @param [Numeric] x
+	# @return [Rtype::Behavior::FloatCheck]
+	# @example Value must be a Float and > 2
+	#   rtype [Flo > 2] => Any
+	def self.==(x)
+		::Rtype::Behavior::FloatCheck.new(:==, x)
+	end
+end

data/lib/rtype/behavior/float_check.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+		class FloatCheck < NumericCheck
+			def valid?(value)
+				if value.is_a?(Float)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a float #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/integer_check.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+		class IntegerCheck < NumericCheck
+			def valid?(value)
+				if value.is_a?(Integer)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be an integer #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/nilable.rb

@@ -0,0 +1,21 @@
+module Rtype
+	module Behavior
+		class Nilable < Base
+			def initialize(type)
+				@type = type
+			end
+
+			def valid?(value)
+				value.nil? || Rtype::valid?(@type, value)
+			end
+
+			def error_message(value)
+				Rtype::type_error_message(@type, value) + "\nOR " + Rtype::type_error_message(nil, value)
+			end
+		end
+	end
+
+	def nilable(*args)
+		Behavior::Nilable[*args]
+	end
+end

data/lib/rtype/behavior/not.rb

@@ -0,0 +1,24 @@
+module Rtype
+	module Behavior
+		class Not < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				@types.all? do |e|
+					!Rtype::valid?(e, value)
+				end
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| "NOT " + Rtype::type_error_message(e, value) }
+				arr.join "\nAND "
+			end
+		end
+	end
+
+	def not(*args)
+		Behavior::Not[*args]
+	end
+end

data/lib/rtype/behavior/numeric_check.rb

@@ -0,0 +1,42 @@
+module Rtype
+	module Behavior
+		class NumericCheck < Base
+			@@conditions = [
+				:>, :<, :>=, :<=, :==
+			]
+			
+			# @param [Symbol] condition
+			# @param [Numeric] x
+			def initialize(condition, x)
+				raise ArgumentError, "Invalid condition '#{condition}'" unless @@conditions.include?(condition)
+				raise ArgumentError, "x is not a Numeric" unless x.is_a?(Numeric)
+				@condition = condition
+				@x = x
+				@lambda = case condition
+					when :>
+						lambda { |obj| obj > @x }
+					when :<
+						lambda { |obj| obj < @x }
+					when :>=
+						lambda { |obj| obj >= @x }
+					when :<=
+						lambda { |obj| obj <= @x }
+					when :==
+						lambda { |obj| obj == @x }
+				end
+			end
+			
+			def valid?(value)
+				if value.is_a?(Numeric)
+					@lambda.call(value)
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a numeric #{@condition} #{@x}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_array.rb

@@ -0,0 +1,26 @@
+module Rtype
+	module Behavior
+		# Typed array behavior. empty array allowed
+		class TypedArray < Base
+			def initialize(type)
+				@type = type
+				Rtype.assert_valid_argument_type_sig_element(@type)
+			end
+
+			def valid?(value)
+				if value.is_a?(Array)
+					any = value.any? do |e|
+						!Rtype::valid?(@type, e)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be an array with type #{@type.inspect}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_hash.rb

@@ -0,0 +1,29 @@
+module Rtype
+	module Behavior
+		# Typed hash behavior. empty hash allowed
+		class TypedHash < Base
+			def initialize(key_type, value_type)
+				@ktype = key_type
+				@vtype = value_type
+				Rtype.assert_valid_argument_type_sig_element(@ktype)
+				Rtype.assert_valid_argument_type_sig_element(@vtype)
+			end
+
+			def valid?(value)
+				if value.is_a?(Hash)
+					any = value.any? do |k, v|
+						!Rtype::valid?(@ktype, k) ||
+						!Rtype::valid?(@vtype, v)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a hash with key type #{@ktype.inspect} and value type #{@vtype.inspect}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/typed_set.rb

@@ -0,0 +1,26 @@
+module Rtype
+	module Behavior
+		# Typed set behavior. empty set allowed
+		class TypedSet < Base
+			def initialize(type)
+				@type = type
+				Rtype.assert_valid_argument_type_sig_element(@type)
+			end
+
+			def valid?(value)
+				if value.is_a?(Set)
+					any = value.any? do |e|
+						!Rtype::valid?(@type, e)
+					end
+					!any
+				else
+					false
+				end
+			end
+
+			def error_message(value)
+				"Expected #{value.inspect} to be a set with type #{@type.inspect}"
+			end
+		end
+	end
+end

data/lib/rtype/behavior/xor.rb

@@ -0,0 +1,25 @@
+module Rtype
+	module Behavior
+		class Xor < Base
+			def initialize(*types)
+				@types = types
+			end
+
+			def valid?(value)
+				result = @types.map do |e|
+					Rtype::valid? e, value
+				end
+				result.count(true) == 1
+			end
+
+			def error_message(value)
+				arr = @types.map { |e| Rtype::type_error_message(e, value) }
+				arr.join "\nXOR "
+			end
+		end
+	end
+
+	def xor(*args)
+		Behavior::Xor[*args]
+	end
+end

data/lib/rtype/behavior.rb

@@ -0,0 +1,17 @@
+module Rtype
+	module Behavior
+	end
+end
+
+require_relative 'behavior/base'
+require_relative 'behavior/and'
+require_relative 'behavior/xor'
+require_relative 'behavior/not'
+require_relative 'behavior/nilable'
+require_relative 'behavior/typed_array'
+require_relative 'behavior/typed_set'
+require_relative 'behavior/typed_hash'
+require_relative 'behavior/numeric_check'
+require_relative 'behavior/integer_check'
+require_relative 'behavior/float_check'
+require_relative 'behavior/core_ext'