rtype 0.6.0 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 545e8dc3a8ac3c44aa68d87126c6dbf8d57302bb
-  data.tar.gz: f3d34bb1fb2ecd9cb7f4b0a9315d14fa5a726940
+  metadata.gz: 4edbfe36753db1a9d6a413bf31ccbed37c499df5
+  data.tar.gz: bfa734ba5689e7fca457b247e0f03dbcde507f8e
 SHA512:
-  metadata.gz: e39262cd99fdf372ed953a2e4c09cafcc09b7d236946d66d3d37acd03f432e72a0de4f7aaf3cd7d74e0d8997ef0178846ba35c040e209acc08a4a60b4e43f7b5
-  data.tar.gz: e31ad200c1d08bb0077ef429cfa4d813bff2732f04f705eafc0ce4166c9dbbf0f82581a9e4655500fdb35ec09721cc22c3d29104fccf40c789fd2cdc7bd3f8b2
+  metadata.gz: 60031209128806548c02edc8944e18a103c3f34a2ddca144dd53716050e939d9f7e4baf9ec7d33a3cf70da28ef156b5fcafd8177cddba6f11be6029cf0a4357a
+  data.tar.gz: 5f40a360733043804e02478347ec2a8a3c187b3d7ea943e31d470a7b4727fa4d89770ad93d1e08bb349550ea1a733fc4f2908d0776db4df777567dcc6083b8e1

data/README.md

@@ -32,9 +32,9 @@ Test::invert(state: 0)
 ## Requirements
 - Ruby >= 2.1
 - MRI
-  - If C native extension is used, otherwise it is not required
-- JRuby
-  - If Java extension is used, otherwise it is not required
+  - If C native extension is used. otherwise it is not required
+- JRuby (JRuby 9000+)
+  - If Java extension is used. otherwise it is not required
 
 ## Features
 - Provides type checking for arguments and return
@@ -80,52 +80,58 @@ then, Rtype use it. (Do not `require 'rtype-java'`)
 
 ### Supported Type Behaviors
 - `Module`
-  - Value must be an instance of the module/class or one of its superclasses
+  - A value must be an instance of the module/class or one of its superclasses (`is_a?`)
   - `Any` : An alias for `BasicObject` (means Any Object)
   - `Boolean` : `true` or `false`
 - `Symbol`
-  - Value must have(respond to) a method with the name
+  - A value must have(respond to) a method with the name
 - `Regexp`
-  - Value must match the regexp pattern
+  - A value must match the regexp pattern
 - `Range`
-  - Value must be included in the range
+  - A value must be included in the range
 - `Array`
-  - Value can be any type in the array
+  - A value can be any type in the array
 - `Hash`
-  - Value must be an hash
-  - Each of value’s elements must be valid
-  - Value's key list must be equal to the hash's key list
+  - A value must be a hash
+  - Each of the value’s elements must be valid
+  - The value's key list must be equal to the hash's key list
   - **String** key is **different** from **symbol** key
-  - vs Keyword arguments (e.g.)
-    - `[{}]` is **not** hash type argument. it is keyword argument because its position is last
-    - `[{}, {}]` is empty hash type argument (first) and one empty keyword argument (second)
-    - `[{}, {}, {}]` is two empty hash type argument (first, second) and empty keyword argument (last)
+  - vs. Keyword arguments (e.g.)
+    - `[{}]` is **not** hash type argument. it is keyword argument, because its position is last
+    - `[{}, {}]` is empty hash type argument (first), and one empty keyword argument (second)
+    - `[{}, {}, {}]` is two empty hash type argument (first, second), and empty keyword argument (last)
     - `{}` is keyword argument. non-keyword arguments must be in array.
   - Of course, nested hash works
   - Example: [Hash](#hash)
 - `Proc`
-  - Value must return a truthy value for the proc
+  - A value must return a truthy value for the proc
 - `true`
-  - Value must be **truthy**
+  - A value must be **truthy**
 - `false`
-  - Value must be **falsy**
+  - A value must be **falsy**
 - `nil`
-  - Value must be nil
+  - A value must be nil
+  
 - Special Behaviors
-  - `Rtype::and(*types)` : Ensure value is valid for all the types
+  - `Rtype::TypedArray` : Ensures a value is an array with the type (type signature)
+    - `Array::of(type)` (recommended)
+    - `Rtype::Behavior::TypedArray[type]`
+    - Example: [TypedArray](#typed-array)
+    
+  - `Rtype::and(*types)` : Ensures a value is valid for all the types
     - `Rtype::and(*types)`, `Rtype::Behavior::And[*types]`, `include Rtype::Behavior; And[...]`
     - `Array#comb`
     - `Object#and(*others)`
     
-  - `Rtype::xor(*types)` : Ensure value is valid for only one of the types
+  - `Rtype::xor(*types)` : Ensures a value is valid for only one of the types
     - `Rtype::xor(*types)`, `Rtype::Behavior::Xor[*types]`, `include Rtype::Behavior; Xor[...]`
     - `Object#xor(*others)`
 
-  - `Rtype::not(*types)` : Ensure value is not valid for all the types
+  - `Rtype::not(*types)` : Ensures a value is not valid for all the types
     - `Rtype::not(*types)`, `Rtype::Behavior::Not[*types]`, `include Rtype::Behavior; Not[...]`
     - `Object#not`
 
-  - `Rtype::nilable(type)` : Ensure value can be nil
+  - `Rtype::nilable(type)` : Ensures a value can be nil
     - `Rtype::nilable(type)`, `Rtype::Behavior::Nilable[type]`, `include Rtype::Behavior; Nilable[...]`
     - `Object#nilable`
     - `Object#or_nil`
@@ -231,29 +237,29 @@ end
 # last hash is keyword arguments
 func({}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected {} to be an hash with 1 elements:
+# Expected {} to be a hash with 1 elements:
 # - msg : Expected nil to be a String
 
 func({msg: 123}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected {:msg=>123} to be an hash with 1 elements:
+# Expected {:msg=>123} to be a hash with 1 elements:
 # - msg : Expected 123 to be a String
 
 func({msg: "hello", key: 'value'}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected {:msg=>"hello", :key=>"value"} to be an hash with 1 elements:
+# Expected {:msg=>"hello", :key=>"value"} to be a hash with 1 elements:
 # - msg : Expected "hello" to be a String
 
 func({"msg" => "hello hash"}, {})
 # (Rtype::ArgumentTypeError) for 1st argument:
-# Expected {"msg"=>"hello hash"} to be an hash with 1 elements:
+# Expected {"msg"=>"hello hash"} to be a hash with 1 elements:
 # - msg : Expected nil to be a String
 
 func({msg: "hello hash"}, {}) # hello hash
 ```
 
 #### rtype with attr_accessor
-`rtype_accessor` : calls `attr_accessor` if the accessor method(getter/setter) is not defined, and makes it typed method
+`rtype_accessor` : calls `attr_accessor` if the accessor method(getter/setter) is not defined. and makes it typed
 
 You can use `rtype_accessor_self` for static accessor.
 
@@ -277,6 +283,38 @@ Example.new.value
 # Expected 456 to be a String
 ```
 
+#### Typed Array
+```ruby
+### TEST 1 ###
+class Test
+	rtype [Array.of(Integer)] => Any
+	def sum(args)
+		num = 0
+		args.each { |e| num += e }
+	end
+end
+
+sum([1, 2, 3]) # => 6
+
+sum([1.0, 2, 3])
+# (Rtype::ArgumentTypeError) for 1st argument:
+# Expected [1.0, 2, 3] to be an array with type Integer"
+```
+
+```ruby
+### TEST 2 ###
+class Test
+	rtype [ Array.of([Integer, Float]) ] => Any
+	def sum(args)
+		num = 0
+		args.each { |e| num += e }
+	end
+end
+
+sum([1, 2, 3]) # => 6
+sum([1.0, 2, 3]) # => 6.0
+```
+
 #### Combined type
 ```ruby
 ### TEST 1 ###
@@ -342,7 +380,7 @@ Game::Player.new.attacks Game::Slime.new
 # Player attacks 'Powerful Slime' (level 123)!
 ```
 
-#### Position of `rtype` && (Specify method name || annotation mode) && (Symbol || String)
+#### Position of `rtype` && (specifying method name || annotation mode) && (symbol || string)
 ```ruby
 require 'rtype'
 
@@ -371,7 +409,7 @@ class Example
     puts "Hello? #{i} #{str}"
   end
 
-  # Don't works. `rtype` works for next method
+  # Doesn't work. `rtype` works for following (next) method
   def hello_world_four(i, str)
     puts "Hello? #{i} #{str}"
   end
@@ -380,7 +418,7 @@ end
 ```
 
 #### Outside of module (root)
-Outside of module, annotation mode don't works. You must specify method name.
+In the outside of module, annotation mode don't works. You must specify method name.
 
 ```ruby
 rtype :say, [String] => Any
@@ -394,7 +432,7 @@ rtype [String] => Any
 # (ArgumentError) Annotation mode not working out of module
 ```
 
-#### Static(singleton) method
+#### Class method
 rtype annotation mode works both instance and class method
 
 ```ruby
@@ -410,7 +448,7 @@ end
 Example::say_ya(3) #say ya ya ya
 ```
 
-however, if you specify method name, you must use `rtype_self` instead of `rtype`
+if you specify method name, however, you must use `rtype_self` instead of `rtype`
 
 ```ruby
 require 'rtype'
@@ -425,7 +463,7 @@ end
 Example::say_ya(3) #say ya ya ya
 ```
 
-#### Check type information
+#### Checking type information
 This is just the 'information'
 
 Any change of this doesn't affect type checking
@@ -524,7 +562,7 @@ Comparison:
 ## Rubype, Sig
 Rtype is influenced by [Rubype](https://github.com/gogotanaka/Rubype) and [Sig](https://github.com/janlelis/sig).
 
-If you don't like Rtype, You can use other type checking gem such as Contracts, Rubype, Rtc, Typecheck, Sig.
+If you don't like Rtype, You can use other library such as Contracts, Rubype, Rtc, Typecheck, Sig.
 
 ## Author
 Sputnik Gugja (sputnikgugja@gmail.com)

data/lib/rtype.rb

@@ -2,16 +2,16 @@ if defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
 	begin
 		require 'java'
 		require 'rtype/rtype_java'
-		puts "Rtype with Java extension"
+		# puts "Rtype with Java extension"
 	rescue LoadError
-		puts "Rtype without native extension"
+		# puts "Rtype without native extension"
 	end
 else
 	begin
 		require "rtype/rtype_native"
-		puts "Rtype with C native extension"
+		# puts "Rtype with C native extension"
 	rescue LoadError
-		puts "Rtype without native extension"
+		# puts "Rtype without native extension"
 	end
 end
 
@@ -28,10 +28,18 @@ require_relative 'rtype/behavior'
 module Rtype
 	extend self
 
-	# This is just the 'information'
+	# This is just 'information'
 	# Any change of this doesn't affect type checking
 	@@type_signatures = Hash.new
 
+	# Makes the method typed
+	# @param owner Owner of the method
+	# @param [#to_sym] method_name
+	# @param [Hash] type_sig_info A type signature. e.g. `[Integer, Float] => Float`
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If method_name is nil
+	# @raise [TypeSignatureError] If type_sig_info is invalid
 	def define_typed_method(owner, method_name, type_sig_info)
 		method_name = method_name.to_sym
 		raise ArgumentError, "method_name is nil" if method_name.nil?
@@ -64,7 +72,20 @@ module Rtype
 		define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
 	end
 
+	# Calls `attr_accessor` if the accessor method(getter/setter) is not defined.
+	# and makes it typed.
+	# 
+	# this method uses `define_typed_method` for getter and setter.
+	# 
+	# @param owner Owner of the accessor
+	# @param [#to_sym] accessor_name
+	# @param type_behavior A type behavior. e.g. Integer
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If accessor_name is nil
+	# @raise [TypeSignatureError]
 	def define_typed_accessor(owner, accessor_name, type_behavior)
+		raise ArgumentError, "accessor_name is nil" if accessor_name.nil?
 		getter = accessor_name.to_sym
 		setter = :"#{accessor_name}="
 		valid?(type_behavior, nil)
@@ -72,6 +93,11 @@ module Rtype
 		define_typed_method owner, setter, [type_behavior] => Any
 	end
 
+	# This is just 'information'
+	# Any change of this doesn't affect type checking
+	# 
+	# @return [Hash]
+	# @note type_signatures[owner][method_name]
 	def type_signatures
 		@@type_signatures
 	end
@@ -89,22 +115,44 @@ module Rtype
 	end
 =end
 
+	# @param [Integer] idx
+	# @param expected A type behavior
+	# @param value
+	# @return [String] A error message
+	# 
+	# @raise [ArgumentError] If expected is invalid
 	def arg_type_error_message(idx, expected, value)
 		"#{arg_message(idx)}\n" + type_error_message(expected, value)
 	end
 
+	# @param [String, Symbol] key
+	# @param expected A type behavior
+	# @param value
+	# @return [String] A error message
+	# 
+	# @raise [ArgumentError] If expected is invalid
 	def kwarg_type_error_message(key, expected, value)
 		"#{kwarg_message(key)}\n" + type_error_message(expected, value)
 	end
-
+	
+	# @return [String]
 	def arg_message(idx)
 		"for #{ordinalize_number(idx+1)} argument:"
 	end
 
+	# @return [String]
 	def kwarg_message(key)
 		"for '#{key}' argument:"
 	end
 
+	# Returns a error message for the pair of type behavior and value
+	# 
+	# @param expected A type behavior
+	# @param value
+	# @return [String] error message
+	# 
+	# @note This method doesn't check the value is valid
+	# @raise [TypeSignatureError] If expected is invalid
 	def type_error_message(expected, value)
 		case expected
 		when Rtype::Behavior::Base
@@ -130,9 +178,9 @@ module Rtype
 						arr << "- #{k} : " + type_error_message(v, value[k])
 					end
 				end
-				"Expected #{value.inspect} to be an hash with #{expected.length} elements:\n" + arr.join("\n")
+				"Expected #{value.inspect} to be a hash with #{expected.length} elements:\n" + arr.join("\n")
 			else
-				"Expected #{value.inspect} to be an hash"
+				"Expected #{value.inspect} to be a hash"
 			end
 		when Proc
 			"Expected #{value.inspect} to return a truthy value for proc #{expected}"
@@ -142,9 +190,19 @@ module Rtype
 			"Expected #{value.inspect} to be a falsy value"
 		when nil # for return
 			"Expected #{value.inspect} to be nil"
+		else
+			raise TypeSignatureError, "Invalid type behavior #{expected}"
 		end
 	end
 
+	# Checks the type signature is valid
+	# 
+	# e.g.
+	# `[Integer] => Any` is valid.
+	# `[Integer]` or `Any` are invalid
+	# 
+	# @param sig A type signature
+	# @raise [TypeSignatureError] If sig is invalid
 	def assert_valid_type_sig(sig)
 		unless sig.is_a?(Hash)
 			raise TypeSignatureError, "Invalid type signature: type signature is not hash"
@@ -156,6 +214,14 @@ module Rtype
 		assert_valid_return_type_sig(sig.first[1])
 	end
 
+	# Checks the arguments type signature is valid
+	# 
+	# e.g.
+	# `[Integer]`, `{key: "value"} are valid.
+	# `Integer` is invalid
+	# 
+	# @param sig A arguments type signature
+	# @raise [TypeSignatureError] If sig is invalid
 	def assert_valid_arguments_type_sig(sig)
 		if sig.is_a?(Array)
 			sig = sig.dup
@@ -179,6 +245,10 @@ module Rtype
 		end
 	end
 
+	# Checks the type behavior is valid
+	# 
+	# @param sig A type behavior
+	# @raise [TypeSignatureError] If sig is invalid
 	def assert_valid_argument_type_sig_element(sig)
 		case sig
 		when Rtype::Behavior::Base
@@ -203,42 +273,19 @@ module Rtype
 		end
 	end
 
+	# @see #assert_valid_argument_type_sig_element
 	def assert_valid_return_type_sig(sig)
 		assert_valid_argument_type_sig_element(sig)
 	end
-
-private
-	def define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
-		# `send` is faster than `method(...).call`
-		owner.send(:_rtype_proxy).send :define_method, method_name do |*args, **kwargs, &block|
-			if kwargs.empty?
-				::Rtype::assert_arguments_type(expected_args, args)
-				result = super(*args, &block)
-			else
-				::Rtype::assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
-				result = super(*args, **kwargs, &block)
-			end
-			::Rtype::assert_return_type(return_sig, result)
-			result
-		end
-		nil
-	end
 	
-	def ordinalize_number(num)
-	    if (11..13).include?(num % 100)
-			"#{num}th"
-	    else
-			case num % 10
-			when 1; "#{num}st"
-			when 2; "#{num}nd"
-			when 3; "#{num}rd"
-			else "#{num}th"
-			end
-	    end
-	end
-public
 	unless respond_to?(:valid?)
-	# validate argument type
+	# Checks the value is valid for the type behavior
+	# 
+	# @param expected A type behavior
+	# @param value
+	# @return [Boolean]
+	# 
+	# @raise [TypeSignatureError] If expected is invalid
 	def valid?(expected, value)
 		case expected
 		when Module
@@ -272,6 +319,14 @@ public
 	end
 
 	unless respond_to?(:assert_arguments_type)
+	# Validates arguments
+	# 
+	# @param [Array] expected_args A type signature for non-keyword arguments
+	# @param args
+	# @return [void]
+	# 
+	# @raise [TypeSignatureError] If expected_args is invalid
+	# @raise [ArgumentTypeError] If args is invalid
 	def assert_arguments_type(expected_args, args)
 		e_len = expected_args.length
 		# `length.times` is faster than `each_with_index`
@@ -283,10 +338,21 @@ public
 				raise ArgumentTypeError, "#{arg_message(i)}\n" + type_error_message(expected, value)
 			end
 		end
+		nil
 	end
 	end
 
 	unless respond_to?(:assert_arguments_type_with_keywords)
+	# Validates arguments and keyword arguments
+	# 
+	# @param [Array] expected_args A type signature for non-keyword arguments
+	# @param args Arguments
+	# @param [Hash] expected_kwargs A type signature for keyword arguments
+	# @param kwargs Keword arguments
+	# @return [void]
+	# 
+	# @raise [TypeSignatureError] If expected_args or expected_kwargs are invalid
+	# @raise [ArgumentTypeError] If args or kwargs are invalid
 	def assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
 		e_len = expected_args.length
 		# `length.times` is faster than `each_with_index`
@@ -307,14 +373,62 @@ public
 				end
 			end
 		end
+		nil
 	end
 	end
 
+	# Validates result
+	# 
+	# @param expected A type behavior
+	# @param result
+	# @return [void]
+	# 
+	# @raise [TypeSignatureError] If expected is invalid
+	# @raise [ReturnTypeError] If result is invalid
 	unless respond_to?(:assert_return_type)
 	def assert_return_type(expected, result)
 		unless valid?(expected, result)
 			raise ReturnTypeError, "for return:\n" + type_error_message(expected, result)
 		end
+		nil
 	end
 	end
+
+private
+	# @param owner
+	# @param [Symbol] method_name
+	# @param expected_args
+	# @param expected_kwargs
+	# @param return_sig
+	# @return [void]
+	def define_typed_method_to_proxy(owner, method_name, expected_args, expected_kwargs, return_sig)
+		# `send` is faster than `method(...).call`
+		owner.send(:_rtype_proxy).send :define_method, method_name do |*args, **kwargs, &block|
+			if kwargs.empty?
+				::Rtype::assert_arguments_type(expected_args, args)
+				result = super(*args, &block)
+			else
+				::Rtype::assert_arguments_type_with_keywords(expected_args, args, expected_kwargs, kwargs)
+				result = super(*args, **kwargs, &block)
+			end
+			::Rtype::assert_return_type(return_sig, result)
+			result
+		end
+		nil
+	end
+	
+	# @param [Integer] num
+	# @return [String]
+	def ordinalize_number(num)
+	    if (11..13).include?(num % 100)
+			"#{num}th"
+	    else
+			case num % 10
+			when 1; "#{num}st"
+			when 2; "#{num}nd"
+			when 3; "#{num}rd"
+			else "#{num}th"
+			end
+	    end
+	end
 end

data/lib/rtype/behavior.rb

@@ -8,4 +8,5 @@ require_relative 'behavior/and'
 require_relative 'behavior/xor'
 require_relative 'behavior/not'
 require_relative 'behavior/nilable'
+require_relative 'behavior/typed_array'
 require_relative 'behavior/core_ext'

data/lib/rtype/behavior/core_ext.rb

@@ -16,3 +16,13 @@ class Object
 		::Rtype::xor(self, *others)
 	end
 end
+
+class Array
+	def self.of(type_sig)
+		::Rtype::Behavior::TypedArray.new(type_sig)
+	end
+	
+	def comb
+		::Rtype::Behavior::And[*self]
+	end
+end

data/lib/rtype/behavior/typed_array.rb

@@ -0,0 +1,25 @@
+module Rtype
+	module Behavior
+		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/core_ext.rb

@@ -1,6 +1,8 @@
+# true or false
 module Boolean; end
 class TrueClass; include Boolean; end
 class FalseClass; include Boolean; end
+
 Any = BasicObject
 
 class Object
@@ -17,74 +19,119 @@ private
 		@_rtype_proxy
 	end
 
+	# Makes the method typed
+	# 
+	# With 'annotation mode', this method works for both instance method and singleton method (class method).
+	# Without it (specifying method name), this method only works for instance method.
+	# 
+	# @param [#to_sym, nil] method_name The name of method. If nil, annotation mode works
+	# @param [Hash] type_sig_info A type signature. e.g. [Integer] => Any
+	# @return [void]
+	# 
+	# @note Annotation mode doesn't work in the outside of module
+	# @raise [ArgumentError] If method_name is nil in the outside of module
+	# @raise [TypeSignatureError] If type_sig_info is invalid
 	def rtype(method_name=nil, type_sig_info)
 		if is_a?(Module)
 			if method_name.nil?
 				::Rtype::assert_valid_type_sig(type_sig_info)
 				_rtype_proxy.annotation_mode = true
 				_rtype_proxy.annotation_type_sig = type_sig_info
+				nil
 			else
 				::Rtype::define_typed_method(self, method_name, type_sig_info)
 			end
 		else
 			if method_name.nil?
-				raise ArgumentError, "Annotation mode not working out of module"
+				raise ArgumentError, "Annotation mode doesn't work in the outside of module"
 			else
 				rtype_self(method_name, type_sig_info)
 			end
 		end
 	end
 
+	# Makes the singleton method (class method) typed
+	# 
+	# @param [#to_sym] method_name
+	# @param [Hash] type_sig_info A type signature. e.g. [Integer] => Any
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If method_name is nil
+	# @raise [TypeSignatureError] If type_sig_info is invalid
 	def rtype_self(method_name, type_sig_info)
 		::Rtype.define_typed_method(singleton_class, method_name, type_sig_info)
 	end
+	
+	# Makes the accessor methods (getter and setter) typed
+	# 
+	# @param [Array<#to_sym>] accessor_names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If accessor_names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @see #rtype
+	def rtype_accessor(*accessor_names, type_behavior)
+		accessor_names.each do |accessor_name|
+			accessor_name = accessor_name.to_sym
+			if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
+				attr_accessor accessor_name
+			end
 
-	def rtype_accessor(accessor_name, type_behavior)
-		accessor_name = accessor_name.to_sym
-		if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
-			attr_accessor accessor_name
-		end
-
-		if is_a?(Module)
-			::Rtype::define_typed_accessor(self, accessor_name, type_behavior)
-		else
-			rtype_accessor_self(accessor_name, type_behavior)
+			if is_a?(Module)
+				::Rtype::define_typed_accessor(self, accessor_name, type_behavior)
+			else
+				rtype_accessor_self(accessor_name, type_behavior)
+			end
 		end
+		nil
 	end
-
-	def rtype_accessor_self(accessor_name, type_behavior)
-		accessor_name = accessor_name.to_sym
-		if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
-			singleton_class.send(:attr_accessor, accessor_name)
+	
+	# Makes the accessor methods (getter and setter) typed
+	# 
+	# @param [Array<#to_sym>] accessor_names
+	# @param type_behavior A type behavior
+	# @return [void]
+	# 
+	# @raise [ArgumentError] If accessor_names contains nil
+	# @raise [TypeSignatureError] If type_behavior is invalid
+	# @see #rtype_self
+	def rtype_accessor_self(*accessor_names, type_behavior)
+		accessor_names.each do |accessor_name|
+			accessor_name = accessor_name.to_sym
+			if !respond_to?(accessor_name) || !respond_to?(:"#{accessor_name}=")
+				singleton_class.send(:attr_accessor, accessor_name)
+			end
+			::Rtype::define_typed_accessor(singleton_class, accessor_name, type_behavior)
 		end
-		::Rtype::define_typed_accessor(singleton_class, accessor_name, type_behavior)
+		nil
 	end
 end
 
 class Method
+	# @return [Boolean] Whether the method is typed with rtype
 	def typed?
 		!!::Rtype.type_signatures[owner][name]
 	end
 
+	# @return [TypeSignature]
 	def type_signature
 		::Rtype.type_signatures[owner][name]
 	end
 
+	# @return [Hash]
+	# @see TypeSignature#info
 	def type_info
 		::Rtype.type_signatures[owner][name].info
 	end
-
+	
+	# @return [Array, Hash]
 	def argument_type
 		::Rtype.type_signatures[owner][name].argument_type
 	end
 
+	# @return A type behavior
 	def return_type
 		::Rtype.type_signatures[owner][name].return_type
 	end
 end
-
-class Array
-	def comb
-		::Rtype::Behavior::And[*self]
-	end
-end

data/lib/rtype/type_signature.rb

@@ -1,9 +1,10 @@
 module Rtype
 	class TypeSignature
 		attr_accessor :argument_type, :return_type
-
+		
+		# @return [Hash] A type signature
 		def info
 			{argument_type => return_type}
 		end
 	end
-end
+end

data/lib/rtype/version.rb

@@ -1,5 +1,5 @@
 module Rtype
-	VERSION = "0.6.0".freeze
+	VERSION = "0.6.3".freeze
 	# rtype java extension version. nil If the extension is not used
 	JAVA_EXT_VERSION = nil unless defined?(JAVA_EXT_VERSION)
 	# rtype c extension version. nil If the extension is not used

data/spec/rtype_spec.rb

@@ -150,24 +150,30 @@ describe Rtype do
 
 	it 'Kernel#rtype_accessor' do
 		class TestClass
-			rtype_accessor :value, String
+			rtype_accessor :value, :value2, String
 
 			def initialize
 				@value = 123
+				@value2 = 123
 			end
 		end
 		expect {TestClass.new.value = 123}.to raise_error Rtype::ArgumentTypeError
 		expect {TestClass.new.value}.to raise_error Rtype::ReturnTypeError
+		expect {TestClass.new.value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass.new.value2}.to raise_error Rtype::ReturnTypeError
 	end
 
 	it 'Kernel#rtype_accessor_self' do
 		class TestClass
-			@@val = 123
+			@@value = 123
+			@@value2 = 123
 
-			rtype_accessor_self :value, String
+			rtype_accessor_self :value, :value2, String
 		end
 		expect {TestClass::value = 123}.to raise_error Rtype::ArgumentTypeError
 		expect {TestClass::value}.to raise_error Rtype::ReturnTypeError
+		expect {TestClass::value2 = 123}.to raise_error Rtype::ArgumentTypeError
+		expect {TestClass::value2}.to raise_error Rtype::ReturnTypeError
 	end
 
 	describe 'Test type behaviors' do
@@ -440,6 +446,34 @@ describe Rtype do
 					expect {instance.return_nil("abc")}.to raise_error Rtype::ArgumentTypeError
 				end
 			end
+			
+			describe 'Rtype::Behavior::TypedArray' do
+				it 'class singleton [] method' do
+					klass.send :rtype, :return_nil, [ Rtype::Behavior::TypedArray[Integer] ] => nil
+					instance.return_nil([123])
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([1.0])}.to raise_error Rtype::ArgumentTypeError
+				end
+
+				it 'core extension method (Array::of)' do
+					klass.send :rtype, :return_nil, [ Array.of(Integer) ] => nil
+					instance.return_nil([123])
+					expect {instance.return_nil(123)}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([1.0])}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'complicated type sig' do
+					klass.send :rtype, :return_nil, [ Array.of(:to_i.and(:chars)) ] => nil
+					instance.return_nil(["hello"])
+					expect {instance.return_nil("hello")}.to raise_error Rtype::ArgumentTypeError
+					expect {instance.return_nil([123])}.to raise_error Rtype::ArgumentTypeError
+				end
+				
+				it 'allows empty array' do
+					klass.send :rtype, :return_nil, [ Array.of(Integer) ] => nil
+					instance.return_nil([])
+				end
+			end
 		end
 	end
 

data/spec/spec_helper.rb

@@ -2,4 +2,12 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'rtype'
-require 'rspec'
+require 'rspec'
+
+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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rtype
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.3
 platform: ruby
 authors:
 - Sputnik Gugja
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-05 00:00:00.000000000 Z
+date: 2016-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -72,6 +72,7 @@ files:
 - lib/rtype/behavior/core_ext.rb
 - lib/rtype/behavior/nilable.rb
 - lib/rtype/behavior/not.rb
+- lib/rtype/behavior/typed_array.rb
 - lib/rtype/behavior/xor.rb
 - lib/rtype/core_ext.rb
 - lib/rtype/method_annotator.rb