blankity 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ac387131a2ec24c66cc4c22c214addbf73b0ab121350a39d4db6556fa78113c
-  data.tar.gz: 35a28db8ef6f0d040683c16e241897cc96ab4d0f0e754e6399cefd5d384a775f
+  metadata.gz: 82b868a367489a12b73f469c8bda91b12bd4342ea50eca5014594dc852b9e77a
+  data.tar.gz: 9bc3240a45986f4781d0c69bb40614555e5be376e25ef47813f5063bea024bde
 SHA512:
-  metadata.gz: 9d189e2a9a0b63d7cd30636d7f0a645341fe8cf5fca106b2c1569f54ab15ef93984884014b69aa6bad0542669cf7c6eb9627a3d4d75a10d9bfa6b243a14179a1
-  data.tar.gz: 815454f7b361da955246a3f7119f8634b0e422563c3a41e5da22ae08c713c910dd7c017ee1879ce33070e4bb144957743da4293aedc8a8601dd3610f0e63c937
+  metadata.gz: b322727491e488bd3c72a52b2018d5898f0e2a53049f745738bb4c22ed71647184b5b235492a17fbc103c2e5e69c72b6d1aa8035c0f0ae4dc921f36b22bfc0e7
+  data.tar.gz: 424882212731398452338d31e67a68d8b3832ffb8ae0bb3b924ee14290182227fe1aa1722c1d9c0844fd15f23a8328e10b67dd2907f50d0b04dab9428abb3e8b

data/README.md

@@ -1,38 +1,86 @@
 # Blankity
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/blankity`. To experiment with that code, run `bin/console` for an interactive prompt.
+Blankity is a gem that provides "blank objects," which define minimal methods.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
 Install the gem and add to the application's Gemfile by executing:
-
 ```bash
-bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+bundle add blankity
 ```
 
 If bundler is not being used to manage dependencies, install the gem by executing:
-
 ```bash
-gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+gem install blankity
 ```
 
 ## Usage
 
-TODO: Write usage instructions here
+The `Blankity::Blank` class `undef`s all methods (other than `__send__` and `__id__`) from `BasicObject`:
+```ruby
+# No methods are defined
+blank = Blankity::Blank.new
+p defined?(blank.==)      #=> nil
+p defined?(blank.inspect) #=> nil
+
+# Include specific `Object` methods:
+blank = Blankity::Blank.new(methods: [:==])
+p blank == blank #=> true
+
+# Also supports blocks, which are `instance_exec`ed
+p Blankity::Blank.new { def inspect = "hi" } #=> "hi"
+```
+
+Also supplied are `Blankity::ToXXX` classes, which just define the conversion methods that are used throughout Ruby's stdlib:
+```ruby
+# String#* calls `.to_int` on its argument:
+p 'a' * Blankity::ToInt.new(3) #=> "aaa"
+
+# File.exist? calls `.to_path` on its argument:
+p File.exist? Blankity::ToPath.new('/tmp/foo') #=> false
+
+# Array#[] accepts custom ranges:
+p %w[a b c d][Blankity::Range.new(1, 3)] #=> ["b", "c", "d"]
+
+```
+
+As a convenience, `Blankity::To` defines these conversion methods:
+```ruby
+puts 'hello' + Blankity::To.str(' world')
+#=> hello world
+
+puts 'hello'.gsub(/[eo]/, Blankity::To.hash('e' => 'E', 'o' => 'O'))
+#=> hEllO
+```
+
+The `Blankity::To` module is also a mixin!
+```ruby
+extend Blankity::To
+
+puts 'hello' + str(' world')
+exit int(0)
+
+# Let's get crazy!
+system(
+  hash(
+    str('HELLO', hash: true) => str('WORLD')
+  ),
+  ary(str('sh'), str('-sh')),
+  str('-c'),
+  str('echo $0 $HELLO $PWD'),
+  chdir: path('/'),
+)
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Run tests via `rake test` and `steep check`.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Before pushing new versions, make sure to run `bundle exec rbs-inline --output lib` to generate new rbs signatures, and to update the `version.rb` file.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/blankity.
+Bug reports and pull requests are welcome on GitHub at https://github.com/sampersand/blankity.
 
 ## License
 

data/lib/blankity/blank.rb

@@ -4,7 +4,7 @@
 module Blankity
   # An "emptier" class than {BasicObject}, which +undef+ines nearly all instance methods.
   #
-  # Not _all_ methods are undefined (see {AboslutelyBlank} for a class which does):
+  # Not _all_ methods are undefined (see {Top} for a class which does):
   #
   # - Methods which match +/\\A__.*__\\z/+ are not removed. Traditionally, these methods are expected
   #   to always be present (and +undef+ing them warns you!). Ruby has two of these: +__send__+

data/lib/blankity/classes.rb

@@ -2,55 +2,66 @@
 # rbs_inline: enabled
 
 module Blankity
-  # Superclass of +ToXXX+ types
-  #
-  # @rbs generic T -- type of @__value__
-  class BlankValue < Blank
-    # @rbs @__value__: T
+  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
+  class ToI < Blank
+    # @rbs @__value__: Integer
 
-    # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
-    #
-    # @param value [T] the backing value for this class
-    # @param methods [Array[interned]] a list of {OBject} methods to define on +self+.
-    # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +methods+ so the resulting
-    #                    type can be used as a key in +Hash+es
-    # @yield [] if a block is given, runs it via +instance_exec+.
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(value, ...)
       @__value__ = value
       super(...)
     end
-  end
 
-  # A Class which exclusively defines +#to_i+; it implements RBS's +_ToI+ interface.
-  #
-  # @rbs inherits BlankValue[Integer]
-  class ToI < BlankValue
     #: () -> Integer
     def to_i = @__value__
   end
 
   # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
-  #
-  # @rbs inherits BlankValue[Integer]
-  class ToInt < BlankValue
+  class ToInt < Blank
+    # @rbs @__value__: Integer
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Integer
     def to_int = @__value__
   end
 
   # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToS < BlankValue
+  class ToS < Blank
+    # @rbs @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> String
     def to_s = @__value__
   end
 
   # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToStr < BlankValue
+  class ToStr < Blank
+    # @rbs @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> String
     def to_str = @__value__
   end
@@ -58,8 +69,17 @@ module Blankity
   # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
   #
   # @rbs generic unchecked out T -- Type of elements
-  # @rbs inherits BlankValue[Array[T]]
-  class ToA < BlankValue
+  class ToA < Blank
+    # @rbs @__value__: Array[T]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Array[T]
     def to_a = @__value__
   end
@@ -67,8 +87,17 @@ module Blankity
   # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
   #
   # @rbs generic unchecked out T -- Type of elements
-  # @rbs inherits BlankValue[Array[T]]
-  class ToAry < BlankValue
+  class ToAry < Blank
+    # @rbs @__value__: Array[T]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Array[T]
     def to_ary = @__value__
   end
@@ -77,8 +106,17 @@ module Blankity
   #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  # @rbs inherits BlankValue[Hash[K, V]]
-  class ToH < BlankValue
+  class ToH < Blank
+    # @rbs @__value__: Hash[K, V]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Hash[K, V]
     def to_h = @__value__
   end
@@ -87,72 +125,145 @@ module Blankity
   #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  # @rbs inherits BlankValue[Hash[K, V]]
-  class ToHash < BlankValue
+  class ToHash < Blank
+    # @rbs @__value__: Hash[K, V]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Hash[K, V]
     def to_hash = @__value__
   end
 
   # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
-  #
-  # @rbs inherits BlankValue[Symbol]
-  class ToSym < BlankValue
+  class ToSym < Blank
+    # @rbs @__value__: Symbol
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Symbol, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Symbol
     def to_sym = @__value__
   end
 
   # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
-  #
-  # @rbs inherits BlankValue[Rational]
-  class ToR < BlankValue
+  class ToR < Blank
+    # @rbs @__value__: Rational
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Rational, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Rational
     def to_r = @__value__
   end
 
   # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
-  #
-  # @rbs inherits BlankValue[Complex]
-  class ToC < BlankValue
+  class ToC < Blank
+    # @rbs @__value__: Complex
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Complex, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Complex
-    def to_C = @__value__
+    def to_c = @__value__
   end
 
   # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
-  #
-  # @rbs inherits BlankValue[Float]
-  class ToF < BlankValue
+  class ToF < Blank
+    # @rbs @__value__: Float
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Float, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Float
     def to_f = @__value__
   end
 
   # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
-  #
-  # @rbs inherits BlankValue[Regexp]
-  class ToRegexp < BlankValue
+  class ToRegexp < Blank
+    # @rbs @__value__: Regexp
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Regexp
     def to_regexp = @__value__
   end
 
   # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToPath < BlankValue
+  class ToPath < Blank
+    # @rbs @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> String
     def to_path = @__value__
   end
 
   # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
-  #
-  # @rbs inherits BlankValue[IO]
-  class ToIO < BlankValue
+  class ToIO < Blank
+    # @rbs @__value__: IO
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (IO, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> IO
     def to_io = @__value__
   end
 
   # A Class which exclusively defines +#to_proc+; it implements RBS's +_ToProc+ interface.
-  #
-  # @rbs inherits BlankValue[Proc]
-  class ToProc < BlankValue
+  class ToProc < Blank
+    # @rbs @__value__: Proc
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Proc, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+
     #: () -> Proc
     def to_proc = @__value__
   end
@@ -166,6 +277,8 @@ module Blankity
     # @rbs @end: T?
     # @rbs @exclude_end: bool
 
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
     # @rbs (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize(begin_, end_, exclude_end = false, ...)
       @__begin__ = begin_

data/lib/blankity/to.rb

@@ -5,119 +5,123 @@ module Blankity
   module To
     module_function
 
+    # Convenience method to make {ToI}s from +value.to_i+
+    #
     # @rbs (_ToI, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
     def i(value, ...) = ToI.new(value.to_i, ...)
 
+    # Convenience method to make {ToInt}s from +value.to_int+
+    #
     # @rbs (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
     def int(value, ...) = ToInt.new(value.to_int, ...)
 
+    # Convenience method to make {ToS}s from +value.to_s+
+    #
     # @rbs (_ToS, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
     def s(value, ...) = ToS.new(value.to_s, ...)
 
+    # Convenience method to make {ToStr}s from +value.to_str+
+    #
     # @rbs (string, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
     def str(value, ...) = ToStr.new(value.to_str, ...)
 
-    # Create a type which _only_ responds to `.to_a`. See `to_helper` for details.
-    #
-    # This supports `a(1, 2, 3)` as a convenient shorthand for `a([1, 2, 3])`. To
-    # create a `.to_a` that returns an array containing just an array, just use `a([array])`.
+    # Convenience method to make {ToA}s from +elements+
     #
-    # @rbs [T] (_ToA[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-    #    | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-    def a(*elements, **, &)
-      if elements.length == 1 && defined?(elements[0].to_a)
-        elements = (__any__ = elements[0]).to_a
-      end
-
-      ToA.new(elements, **, &)
-    end
+    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
+    def a(*elements, **, &) = ToA.new(elements, **, &)
 
-    # Create a type which _only_ responds to `.to_ary`. See `to_helper` for details.
-    #
-    # This supports `ary(1, 2, 3)` as a convenient shorthand for `ary([1, 2, 3])`. To
-    # create a `.to_ary` that returns an array containing just an array, use `ary([array])`.
+    # Convenience method to make {ToAry}s from +elements+
     #
-    # @rbs [T] (array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-    #    | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-    def ary(*elements, **, &)
-      if elements.length == 1 && defined?(elements[0].to_ary)
-        elements = (__any__ = elements[0]).to_ary
-      end
-
-      ToAry.new(elements, **, &)
-    end
+    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
+    def ary(*elements, **, &) = ToAry.new(elements, **, &)
 
-    # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
+    # Convenience method to make {ToH}s from +hash+
     #
-    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
-    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
-    # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
+    # This supports passing in key/values directly via +Blankity::To.h('a' => 'b')+ as a convenient
+    # shorthand, but you can't then pass keyword arguments to {ToH}'s constructor. To do so, instead
+    # pass in a Hash as a positional argument (e.g. +Blankity::To.h({ 'a' => 'b' }, ...)+)
     #
     # @rbs [K, V] (_ToH[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
     #    | [K, V] (**V) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
-    def h(hash = nohash=true, **, &)
-      if nohash
-        ToH.new({**}, &)
-      else
+    def h(hash = nil, **, &)
+      if hash
         ToH.new(hash.to_h, **, &)
+      else
+        ToH.new({**}, &)
       end
     end
 
-    # Create a type which _only_ responds to `.to_hash`. See `to_helper` for details.
+    # Convenience method to make {ToHash}s from +hash+
     #
-    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
-    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
-    # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
+    # This supports passing in key/values directly via +Blankity::To.hash('a' => 'b')+ as a convenient
+    # shorthand, but you can't then pass keyword arguments to {ToHash}'s constructor. To do so, instead
+    # pass in a Hash as a positional argument (e.g. +Blankity::To.hash({ 'a' => 'b' }, ...)+)
     #
     # @rbs [K, V] (hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
     #    | [K, V] (**V) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
-    def hash(hash = nohash=true, **, &)
-      if nohash
-        ToHash.new({**}, &)
+    def hash(hash = nil, **, &)
+      if hash
+        ToHash.new(hash.to_hash, **, &)
       else
-        ToHash.new((__any__ = hash).to_hash, **, &)
+        ToHash.new({**}, &)
       end
     end
 
+    # Convenience method to make {ToSym}s from +value.to_sym+
+    #
     # @rbs (_ToSym, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
     def sym(value, ...) = ToSym.new(value.to_sym, ...)
 
+    # Convenience method to make {ToR}s from +value.to_r+
+    #
     # @rbs (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
     def r(value, ...) = ToR.new(value.to_r, ...)
 
+    # Convenience method to make {ToC}s from +value.to_c+
+    #
     # @rbs (_ToC, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
     def c(value, ...) = ToC.new(value.to_c, ...)
 
+    # Convenience method to make {ToF}s from +value.to_f+
+    #
     # @rbs (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
     def f(value, ...) = ToF.new(value.to_f, ...)
 
+    # Convenience method to make {ToRegexp}s from +value.to_regexp+
+    #
     # @rbs (Regexp::_ToRegexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
     def regexp(value, ...) = ToRegexp.new(value.to_regexp, ...)
 
+    # Convenience method to make {ToPath}s from +value.to_path+, or +Kernel#String(value)+
+    # if +value+ doesn't define +#to_path+.
+    #
     # @rbs (path, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
-    def path(value, ...)
-      ToPath.new(defined?(value.to_path) ? value.to_path : String(value), ...)
-    end
+    def path(value, ...) = ToPath.new(defined?(value.to_path) ? value.to_path : String(value), ...)
 
+    # Convenience method to make {ToIO}s from +value.to_io+
+    #
     # @rbs (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
     def io(value, ...) = ToIO.new(value.to_io, ...)
 
+    # Convenience method to make {ToProc}s from the supplied block, or +proc+ if no block is given.
+    #
+    # This supports passing blocks in directly via +Blankity::To.proc { ... }+ as a convenient
+    # shorthand, but then you can't pass a block to {ToProc}'s constructor. To so do, instead pass
+    # the block as a positional parameter (eg +Blankity::To.proc(proc { ... }) { ... }+)
+    #
     # @rbs (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
-    def proc(proc = noproc=true, **, &block)
-      if noproc
-        unless block_given?
-          raise ArgumentError, 'if an explicit proc is omitted, a block must be passed'
-        end
-
-        ToProc.new(__any__ = block, **)
-      else
+    #    | (?methods: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
+    def proc(proc = nil, **, &block)
+      if proc
         ToProc.new(proc.to_proc, **, &block)
+      elsif !block_given?
+        raise ArgumentError, 'if an explicit proc is omitted, a block must be passed'
+      else
+        ToProc.new(__any__ = block, **)
       end
     end
 
-    # Create a type which _only_ responds to `.begin`, `.end`, and `.exclude_end?`
-    # (the methods required to be considered a "custom range," eg for `Array#[]`.) See
-    # `to_helper` for details.
+    # Convenience method to make {Range}s from the supplied arguments.
     #
     # @rbs [T] (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
     def range(begin_, end_, exclude_end = false, ...)

data/lib/blankity/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Blankity
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/sig/generated/blankity/blank.rbs

@@ -3,7 +3,7 @@
 module Blankity
   # An "emptier" class than {BasicObject}, which +undef+ines nearly all instance methods.
   #
-  # Not _all_ methods are undefined (see {AboslutelyBlank} for a class which does):
+  # Not _all_ methods are undefined (see {Top} for a class which does):
   #
   # - Methods which match +/\\A__.*__\\z/+ are not removed. Traditionally, these methods are expected
   #   to always be present (and +undef+ing them warns you!). Ruby has two of these: +__send__+

data/sig/generated/blankity/classes.rbs

@@ -1,52 +1,54 @@
 # Generated from lib/blankity/classes.rb with RBS::Inline
 
 module Blankity
-  # Superclass of +ToXXX+ types
-  #
-  # @rbs generic T -- type of @__value__
-  class BlankValue[T] < Blank
-    @__value__: T
+  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
+  class ToI < Blank
+    @__value__: Integer
 
-    # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
-    #
-    # @param value [T] the backing value for this class
-    # @param methods [Array[interned]] a list of {OBject} methods to define on +self+.
-    # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +methods+ so the resulting
-    #                    type can be used as a key in +Hash+es
-    # @yield [] if a block is given, runs it via +instance_exec+.
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
     #
-    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize: (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-  end
+    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
 
-  # A Class which exclusively defines +#to_i+; it implements RBS's +_ToI+ interface.
-  #
-  # @rbs inherits BlankValue[Integer]
-  class ToI < BlankValue[Integer]
     # : () -> Integer
     def to_i: () -> Integer
   end
 
   # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
-  #
-  # @rbs inherits BlankValue[Integer]
-  class ToInt < BlankValue[Integer]
+  class ToInt < Blank
+    @__value__: Integer
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Integer, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Integer
     def to_int: () -> Integer
   end
 
   # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToS < BlankValue[String]
+  class ToS < Blank
+    @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> String
     def to_s: () -> String
   end
 
   # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToStr < BlankValue[String]
+  class ToStr < Blank
+    @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> String
     def to_str: () -> String
   end
@@ -54,8 +56,14 @@ module Blankity
   # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
   #
   # @rbs generic unchecked out T -- Type of elements
-  # @rbs inherits BlankValue[Array[T]]
-  class ToA[unchecked out T] < BlankValue[Array[T]]
+  class ToA[unchecked out T] < Blank
+    @__value__: Array[T]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Array[T]
     def to_a: () -> Array[T]
   end
@@ -63,8 +71,14 @@ module Blankity
   # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
   #
   # @rbs generic unchecked out T -- Type of elements
-  # @rbs inherits BlankValue[Array[T]]
-  class ToAry[unchecked out T] < BlankValue[Array[T]]
+  class ToAry[unchecked out T] < Blank
+    @__value__: Array[T]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Array[T]
     def to_ary: () -> Array[T]
   end
@@ -73,8 +87,14 @@ module Blankity
   #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  # @rbs inherits BlankValue[Hash[K, V]]
-  class ToH[unchecked out K, unchecked out V] < BlankValue[Hash[K, V]]
+  class ToH[unchecked out K, unchecked out V] < Blank
+    @__value__: Hash[K, V]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Hash[K, V]
     def to_h: () -> Hash[K, V]
   end
@@ -83,72 +103,118 @@ module Blankity
   #
   # @rbs generic unchecked out K -- Type of Key
   # @rbs generic unchecked out V -- Type of Value
-  # @rbs inherits BlankValue[Hash[K, V]]
-  class ToHash[unchecked out K, unchecked out V] < BlankValue[Hash[K, V]]
+  class ToHash[unchecked out K, unchecked out V] < Blank
+    @__value__: Hash[K, V]
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Hash[K, V]
     def to_hash: () -> Hash[K, V]
   end
 
   # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
-  #
-  # @rbs inherits BlankValue[Symbol]
-  class ToSym < BlankValue[Symbol]
+  class ToSym < Blank
+    @__value__: Symbol
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Symbol, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Symbol, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Symbol
     def to_sym: () -> Symbol
   end
 
   # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
-  #
-  # @rbs inherits BlankValue[Rational]
-  class ToR < BlankValue[Rational]
+  class ToR < Blank
+    @__value__: Rational
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Rational, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Rational, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Rational
     def to_r: () -> Rational
   end
 
   # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
-  #
-  # @rbs inherits BlankValue[Complex]
-  class ToC < BlankValue[Complex]
+  class ToC < Blank
+    @__value__: Complex
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Complex, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Complex, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Complex
-    def to_C: () -> Complex
+    def to_c: () -> Complex
   end
 
   # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
-  #
-  # @rbs inherits BlankValue[Float]
-  class ToF < BlankValue[Float]
+  class ToF < Blank
+    @__value__: Float
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Float, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Float, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Float
     def to_f: () -> Float
   end
 
   # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
-  #
-  # @rbs inherits BlankValue[Regexp]
-  class ToRegexp < BlankValue[Regexp]
+  class ToRegexp < Blank
+    @__value__: Regexp
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Regexp
     def to_regexp: () -> Regexp
   end
 
   # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
-  #
-  # @rbs inherits BlankValue[String]
-  class ToPath < BlankValue[String]
+  class ToPath < Blank
+    @__value__: String
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (String, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> String
     def to_path: () -> String
   end
 
   # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
-  #
-  # @rbs inherits BlankValue[IO]
-  class ToIO < BlankValue[IO]
+  class ToIO < Blank
+    @__value__: IO
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (IO, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (IO, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> IO
     def to_io: () -> IO
   end
 
   # A Class which exclusively defines +#to_proc+; it implements RBS's +_ToProc+ interface.
-  #
-  # @rbs inherits BlankValue[Proc]
-  class ToProc < BlankValue[Proc]
+  class ToProc < Blank
+    @__value__: Proc
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (Proc, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (Proc, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
     # : () -> Proc
     def to_proc: () -> Proc
   end
@@ -164,6 +230,8 @@ module Blankity
 
     @exclude_end: bool
 
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
     # @rbs (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
     def initialize: (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
 

data/sig/generated/blankity/to.rbs

@@ -2,87 +2,106 @@
 
 module Blankity
   module To
+    # Convenience method to make {ToI}s from +value.to_i+
+    #
     # @rbs (_ToI, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
     def self?.i: (_ToI, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
 
+    # Convenience method to make {ToInt}s from +value.to_int+
+    #
     # @rbs (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
     def self?.int: (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
 
+    # Convenience method to make {ToS}s from +value.to_s+
+    #
     # @rbs (_ToS, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
     def self?.s: (_ToS, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
 
+    # Convenience method to make {ToStr}s from +value.to_str+
+    #
     # @rbs (string, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
     def self?.str: (string, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
 
-    # Create a type which _only_ responds to `.to_a`. See `to_helper` for details.
+    # Convenience method to make {ToA}s from +elements+
     #
-    # This supports `a(1, 2, 3)` as a convenient shorthand for `a([1, 2, 3])`. To
-    # create a `.to_a` that returns an array containing just an array, just use `a([array])`.
-    #
-    # @rbs [T] (_ToA[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-    #    | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-    def self?.a: [T] (_ToA[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-               | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
+    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
+    def self?.a: [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
 
-    # Create a type which _only_ responds to `.to_ary`. See `to_helper` for details.
-    #
-    # This supports `ary(1, 2, 3)` as a convenient shorthand for `ary([1, 2, 3])`. To
-    # create a `.to_ary` that returns an array containing just an array, use `ary([array])`.
+    # Convenience method to make {ToAry}s from +elements+
     #
-    # @rbs [T] (array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-    #    | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-    def self?.ary: [T] (array[T], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-                 | [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
+    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
+    def self?.ary: [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
 
-    # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
+    # Convenience method to make {ToH}s from +hash+
     #
-    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
-    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
-    # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
+    # This supports passing in key/values directly via +Blankity::To.h('a' => 'b')+ as a convenient
+    # shorthand, but you can't then pass keyword arguments to {ToH}'s constructor. To do so, instead
+    # pass in a Hash as a positional argument (e.g. +Blankity::To.h({ 'a' => 'b' }, ...)+)
     #
     # @rbs [K, V] (_ToH[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
     #    | [K, V] (**V) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
     def self?.h: [K, V] (_ToH[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
                | [K, V] (**V) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
 
-    # Create a type which _only_ responds to `.to_hash`. See `to_helper` for details.
+    # Convenience method to make {ToHash}s from +hash+
     #
-    # This supports passing in key/values directly via `h('a' => 'b')` as a convenient
-    # shorthand for `h({'a' => 'b'})`, but the shorthand version doesn't allow you
-    # to supply keyowrd arguments that `to_helper` expects. Use `h({'a' => 'b'}, ...)` for that.
+    # This supports passing in key/values directly via +Blankity::To.hash('a' => 'b')+ as a convenient
+    # shorthand, but you can't then pass keyword arguments to {ToHash}'s constructor. To do so, instead
+    # pass in a Hash as a positional argument (e.g. +Blankity::To.hash({ 'a' => 'b' }, ...)+)
     #
     # @rbs [K, V] (hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
     #    | [K, V] (**V) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
     def self?.hash: [K, V] (hash[K, V], ?methods: Array[interned], ?hash: bool) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
                   | [K, V] (**V) ?{ () [self: ToHash[K, V]] -> void } -> ToHash[K, V]
 
+    # Convenience method to make {ToSym}s from +value.to_sym+
+    #
     # @rbs (_ToSym, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
     def self?.sym: (_ToSym, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
 
+    # Convenience method to make {ToR}s from +value.to_r+
+    #
     # @rbs (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
     def self?.r: (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
 
+    # Convenience method to make {ToC}s from +value.to_c+
+    #
     # @rbs (_ToC, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
     def self?.c: (_ToC, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
 
+    # Convenience method to make {ToF}s from +value.to_f+
+    #
     # @rbs (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
     def self?.f: (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
 
+    # Convenience method to make {ToRegexp}s from +value.to_regexp+
+    #
     # @rbs (Regexp::_ToRegexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
     def self?.regexp: (Regexp::_ToRegexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
 
+    # Convenience method to make {ToPath}s from +value.to_path+, or +Kernel#String(value)+
+    # if +value+ doesn't define +#to_path+.
+    #
     # @rbs (path, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
     def self?.path: (path, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
 
+    # Convenience method to make {ToIO}s from +value.to_io+
+    #
     # @rbs (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
     def self?.io: (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
 
+    # Convenience method to make {ToProc}s from the supplied block, or +proc+ if no block is given.
+    #
+    # This supports passing blocks in directly via +Blankity::To.proc { ... }+ as a convenient
+    # shorthand, but then you can't pass a block to {ToProc}'s constructor. To so do, instead pass
+    # the block as a positional parameter (eg +Blankity::To.proc(proc { ... }) { ... }+)
+    #
     # @rbs (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+    #    | (?methods: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
     def self?.proc: (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+                  | (?methods: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
 
-    # Create a type which _only_ responds to `.begin`, `.end`, and `.exclude_end?`
-    # (the methods required to be considered a "custom range," eg for `Array#[]`.) See
-    # `to_helper` for details.
+    # Convenience method to make {Range}s from the supplied arguments.
     #
     # @rbs [T] (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
     def self?.range: [T] (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Sam Westerman
@@ -11,7 +11,7 @@ date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   There's a lot of conversion methods in Ruby: to_s, to_a, to_i, etc. This gem provides types
-  which *only* respond to these conversion methods, and nothing else.
+  which only respond to these conversion methods, and nothing else.
 email: mail@sampersand.me
 executables: []
 extensions: []
@@ -58,5 +58,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.0.dev
 specification_version: 4
-summary: Provides "blank" objects which *only* supply conversion methods
+summary: Provides "blank" objects which only supply conversion methods
 test_files: []