blankity 0.10.1 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6073dd5657ac15bdd561c7438da0dd3fb890e82d50953f479a2b2dceb40dbdbf
-  data.tar.gz: 28ae49ee61fe6d2d6e0b785f95a57a77b1ba35fe0c5aa7d94086ab6510f495f6
+  metadata.gz: bb74367673b591a115da493f40ebc58de31795567e08c7b24e7c97c51da256fc
+  data.tar.gz: 8945066e28ec8457e1956ea751c3e0fcc24165c4cca2ac6bce662e66b1221752
 SHA512:
-  metadata.gz: f5f7213d2521ab96d21139443fdb6e8d634b6dc3564d6e7f04fdc3887149b5fff126ad8cb4fa53d7a2884416614b3f5364cf8086172774ada77eb41a0302532b
-  data.tar.gz: 18b221c650794e50faa44bd9830f561bf3be7402e2f66caac22c9ba3fa998b10ad6950cf380952369804c2397cffd35d9ef5ea7c1b279f79d8ca7db49001f0b4
+  metadata.gz: 521bbfc81372ae7f66dcefa14120075b47ad99ed7ad970576f01ed9fcdac07015be9005c755eed357ad54d3fc8332f7287c9f3cc9b76542e1f6a91a8df943c25
+  data.tar.gz: 343abcf8d29f2d4e506e0ff9e4fd44b59057b4aec1654a86f2f8ebd6766a38606343a9f9d008bea2648b22b0730d7c245e14b822c3ed9822fa1b003cde68ac73

data/lib/blankity/blank.rb

@@ -20,8 +20,10 @@ module Blankity
     # @rbs!
     #   def __define_singleton_method__: (interned name, Method | UnboundMethod | Proc method) -> Symbol
     #                                  | (interned name) { (?) [self: self] -> untyped } -> Symbol
-    #   def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
     define_method :__define_singleton_method__, ::Kernel.instance_method(:define_singleton_method)
+
+    # @rbs!
+    #   def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
     alias_method :__instance_exec__, :instance_exec # Use `alias_method` instead of `alias` so rbs-inline won't pick it up
 
     # Remove every other public and protected method that we inherit, except for `__xyz__` methods

data/lib/blankity/to.rb

@@ -4,56 +4,44 @@
 module Blankity
   # Convenience methods for creating new +BlankIty::ToXXX+ instances.
   #
-  # Using +To+ as a mixin (via +extend+ / +include+ / +prepend+) isn't suggested, as {Kernel#proc}
-  # and {Kernel#hash} will be overwritten. Attempting to do so will emit a warning if `$VERBOSE` is
-  # enabled.
+  # This module can be +include+/+extend+ed to define the `to` function, which lets you do things
+  # like +system to.str('ls -al')+. (The module is not mixin-able, as it overwrites {Kernel} methods,
+  # notably +proc+ and +hash+).
   module To
-    # Warn when including +To+
-    def self.included(mod)
-      $VERBOSE and warn 'including Blankity::To overwrites Kernel#proc and Kernel#hash', uplevel: 1
-    end
-
-    # Warn when extending +To+
-    def self.extended(mod)
-      $VERBOSE and warn 'extending Blankity::To overwrites Kernel#proc and Kernel#hash', uplevel: 1
-    end
-
-    # Warn when prepending +To+
-    def self.prepended(mod)
-      $VERBOSE and warn 'prepending Blankity::To overwrites Kernel#proc and Kernel#hash', uplevel: 1
-    end
-
-    module_function
+    # Helper method so you can `include Blankity::To` and then `to.str(...)`.
+    #
+    # @rbs () -> singleton(Blankity::To)
+    module_function def to = ::Blankity::To
 
     # 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, ...)
+    # @rbs (_ToI, ?with: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
+    def self.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, ...)
+    # @rbs (int, ?with: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
+    def self.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, ...)
+    # @rbs (_ToS, ?with: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
+    def self.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, ...)
+    # @rbs (string, ?with: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
+    def self.str(value, ...) = ToStr.new(value.to_str, ...)
 
     # Convenience method to make {ToA}s from +elements+
     #
-    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
-    def a(*elements, **, &) = ToA.new(elements, **, &)
+    # @rbs [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
+    def self.a(*elements, **, &) = ToA.new(elements, **, &)
 
     # Convenience method to make {ToAry}s from +elements+
     #
-    # @rbs [T] (*T, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
-    def ary(*elements, **, &) = ToAry.new(elements, **, &)
+    # @rbs [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
+    def self.ary(*elements, **, &) = ToAry.new(elements, **, &)
 
     # Convenience method to make {ToH}s from +hash+
     #
@@ -61,9 +49,9 @@ module Blankity
     # 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]
+    # @rbs [K, V] (_ToH[K, V], ?with: 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 = nil, **, &)
+    def self.h(hash = nil, **, &)
       if hash
         ToH.new(hash.to_h, **, &)
       else
@@ -77,9 +65,9 @@ module Blankity
     # 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]
+    # @rbs [K, V] (hash[K, V], ?with: 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 = nil, **, &)
+    def self.hash(hash = nil, **, &)
       if hash
         ToHash.new(hash.to_hash, **, &)
       else
@@ -89,39 +77,39 @@ module Blankity
 
     # 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, ...)
+    # @rbs (_ToSym, ?with: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
+    def self.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, ...)
+    # @rbs (_ToR, ?with: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
+    def self.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, ...)
+    # @rbs (_ToC, ?with: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
+    def self.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, ...)
+    # @rbs (float, ?with: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
+    def self.f(value, ...) = ToF.new(value.to_f, ...)
 
     # Convenience method to make {ToRegexp}s from +value.to_regexp+
     #
-    # @rbs (Regexp::_ToRegexp | Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
-    def regexp(value, ...) = ToRegexp.new(Regexp === value ? value : value.to_regexp, ...)
+    # @rbs (Regexp::_ToRegexp | Regexp, ?with: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
+    def self.regexp(value, ...) = ToRegexp.new(Regexp === value ? value : 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), ...)
+    # @rbs (path, ?with: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
+    def self.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, ...)
+    # @rbs (io, ?with: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
+    def self.io(value, ...) = ToIO.new(value.to_io, ...)
 
     # Convenience method to make {ToProc}s from the supplied block, or +proc+ if no block is given.
     #
@@ -129,8 +117,8 @@ module Blankity
     # 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
+    # @rbs (_ToProc, ?with: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+    #    | (?with: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
     def self.proc(proc = nil, **, &block)
       if proc
         ToProc.new(proc.to_proc, **, &block)
@@ -143,10 +131,9 @@ module Blankity
 
     # 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, ...)
+    # @rbs [T] (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
+    def self.range(begin_, end_, exclude_end = false, ...)
       __any__ = Range.new(begin_, end_, exclude_end, ...)
     end
   end
 end
-

data/lib/blankity/value.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Blankity
+  # @rbs generic T
+  class Value < Blank
+    # The underlying value
+    attr_reader :__value__ #: T
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (T, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
+      @__value__ = value
+      super(...)
+    end
+  end
+
+  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
+  #
+  # @rbs inherits Value[Integer]
+  class ToI < Value
+    alias to_i __value__
+  end
+
+  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
+  #
+  # @rbs inherits Value[Integer]
+  class ToInt < Value
+    alias to_int __value__
+  end
+
+  # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToS < Value
+    alias to_s __value__
+  end
+
+  # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToStr < Value
+    alias to_str __value__
+  end
+
+  # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
+  #
+  # @rbs generic unchecked out T -- Type of elements
+  # @rbs inherits Value[Array[T]]
+  class ToA < Value
+    alias to_a __value__
+  end
+
+  # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
+  #
+  # @rbs generic unchecked out T -- Type of elements
+  # @rbs inherits Value[Array[T]]
+  class ToAry < Value
+    alias to_ary __value__
+  end
+
+  # A Class which exclusively defines +#to_h+; it implements RBS's +_ToH[K, V]+ interface.
+  #
+  # @rbs generic unchecked out K -- Type of Key
+  # @rbs generic unchecked out V -- Type of Value
+  # @rbs inherits Value[Hash[K, V]]
+  class ToH < Value
+    alias to_h __value__
+  end
+
+  # A Class which exclusively defines +#to_hash+; it implements RBS's +_ToHash[K, V]+ interface.
+  #
+  # @rbs generic unchecked out K -- Type of Key
+  # @rbs generic unchecked out V -- Type of Value
+  # @rbs inherits Value[Hash[K, V]]
+  class ToHash < Value
+    alias to_hash __value__
+  end
+
+  # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
+  #
+  # @rbs inherits Value[Symbol]
+  class ToSym < Value
+    alias to_sym __value__
+  end
+
+  # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
+  #
+  # @rbs inherits Value[Rational]
+  class ToR < Value
+    alias to_r __value__
+  end
+
+  # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
+  #
+  # @rbs inherits Value[Complex]
+  class ToC < Value
+    alias to_c __value__
+  end
+
+  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
+  #
+  # @rbs inherits Value[Float]
+  class ToF < Value
+    alias to_f __value__
+  end
+
+  # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
+  #
+  # @rbs inherits Value[Regexp]
+  class ToRegexp < Value
+    alias to_regexp __value__
+  end
+
+  # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToPath < Value
+    alias to_path __value__
+  end
+
+  # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
+  #
+  # @rbs inherits Value[IO]
+  class ToIO < Value
+    alias to_io __value__
+  end
+
+  # A Class which exclusively defines +#to_proc+; it implements RBS's +_ToProc+ interface.
+  #
+  # @rbs inherits Value[Proc]
+  class ToProc < Value
+    alias to_proc __value__
+  end
+
+  # A Class which defines `#begin`, `#end`, and `#exclude_end?`. It implements RBS's +_Range[T]+
+  # interface.
+  #
+  # @rbs generic out T -- Type to iterate over
+  class Range < Blank
+    # @rbs @__begin__: T?
+    # @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, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(begin_, end_, exclude_end = false, ...)
+      @__begin__ = begin_
+      @__end__ = end_
+      @__exclude_end__ = exclude_end
+
+      super(...)
+    end
+
+    # @rbs () -> T?
+    def begin = @__begin__
+
+    # @rbs () -> T?
+    def end = @__end__
+
+    # @rbs () -> bool
+    def exclude_end? = @__exclude_end__
+  end
+end

data/lib/blankity/version.rb

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

data/lib/blankity.rb

@@ -11,5 +11,5 @@ end
 require_relative 'blankity/version'
 require_relative 'blankity/top'
 require_relative 'blankity/blank'
-require_relative 'blankity/classes'
+require_relative 'blankity/value'
 require_relative 'blankity/to'

data/sig/generated/blankity/blank.rbs

@@ -11,7 +11,7 @@ module Blankity
   # - Private methods are not undefined, as each one of them is expected to be present (most of them
   #   are hooks, eg +singleton_method_added+), and aren't easily accessible from external classes.
   #
-  # To make using +Blank+ easier, its constructor allows you to pass a +methods:+ keyword argument,
+  # To make using +Blank+ easier, its constructor allows you to pass a +with:+ keyword argument,
   # which will define singleton methods based on {Object}.
   class Blank < BasicObject
     def __define_singleton_method__: (interned name, Method | UnboundMethod | Proc method) -> Symbol
@@ -19,12 +19,13 @@ module Blankity
 
     def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
 
+    # Alias for `new`
     alias self.blank self.new
 
     # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
     #
-    # @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
+    # @param with [Array[interned]] a list of {Object} methods to define on +self+.
+    # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +with+ so the resulting
     #                    type can be used as a key in +Hash+es
     # @yield [] if a block is given, runs it via +__instance_exec__+.
     #
@@ -33,17 +34,12 @@ module Blankity
     #   Blankity::Blank.new
     #
     #   # Include `Object#inspect`, so we can print with `p`
-    #   p Blankity::Blank.new(methods: %i[inspect])
+    #   p Blankity::Blank.new(with: %i[inspect])
     #
     #   # Define a singleton method
     #   p Blankity::Blank.new{ def cool?(other) = other == 3 }.cool?(3) #=> true
     #
-    # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize: (?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    # @rbs (?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
   end
-
-  # Shorthand constructor {Blankity::Blank}.
-  #
-  # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
-  def self.blank: (?methods: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
 end

data/sig/generated/blankity/to.rbs

@@ -3,48 +3,44 @@
 module Blankity
   # Convenience methods for creating new +BlankIty::ToXXX+ instances.
   #
-  # Using +To+ as a mixin (via +extend+ / +include+ / +prepend+) isn't suggested, as {Kernel#proc}
-  # and {Kernel#hash} will be overwritten. Attempting to do so will emit a warning if `$VERBOSE` is
-  # enabled.
+  # This module can be +include+/+extend+ed to define the `to` function, which lets you do things
+  # like +system to.str('ls -al')+. (The module is not mixin-able, as it overwrites {Kernel} methods,
+  # notably +proc+ and +hash+).
   module To
-    # Warn when including +To+
-    def self.included: (untyped mod) -> untyped
-
-    # Warn when extending +To+
-    def self.extended: (untyped mod) -> untyped
-
-    # Warn when prepending +To+
-    def self.prepended: (untyped mod) -> untyped
+    # Helper method so you can `include Blankity::To` and then `to.str(...)`.
+    #
+    # @rbs () -> singleton(Blankity::To)
+    def to: () -> singleton(Blankity::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
+    # @rbs (_ToI, ?with: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
+    def self.i: (_ToI, ?with: 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
+    # @rbs (int, ?with: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
+    def self.int: (int, ?with: 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
+    # @rbs (_ToS, ?with: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
+    def self.s: (_ToS, ?with: 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
+    # @rbs (string, ?with: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
+    def self.str: (string, ?with: Array[interned], ?hash: bool) ?{ () [self: ToStr] -> void } -> ToStr
 
     # Convenience method to make {ToA}s from +elements+
     #
-    # @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]
+    # @rbs [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
+    def self.a: [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToA[T]] -> void } -> ToA[T]
 
     # Convenience method to make {ToAry}s from +elements+
     #
-    # @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]
+    # @rbs [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
+    def self.ary: [T] (*T, ?with: Array[interned], ?hash: bool) ?{ () [self: ToAry[T]] -> void } -> ToAry[T]
 
     # Convenience method to make {ToH}s from +hash+
     #
@@ -52,10 +48,10 @@ module Blankity
     # 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]
+    # @rbs [K, V] (_ToH[K, V], ?with: 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]
+    def self.h: [K, V] (_ToH[K, V], ?with: Array[interned], ?hash: bool) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
+              | [K, V] (**V) ?{ () [self: ToH[K, V]] -> void } -> ToH[K, V]
 
     # Convenience method to make {ToHash}s from +hash+
     #
@@ -63,46 +59,46 @@ module Blankity
     # 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]
+    # @rbs [K, V] (hash[K, V], ?with: 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]
+    def self.hash: [K, V] (hash[K, V], ?with: 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
+    # @rbs (_ToSym, ?with: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
+    def self.sym: (_ToSym, ?with: 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
+    # @rbs (_ToR, ?with: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
+    def self.r: (_ToR, ?with: 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
+    # @rbs (_ToC, ?with: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
+    def self.c: (_ToC, ?with: 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
+    # @rbs (float, ?with: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
+    def self.f: (float, ?with: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
 
     # Convenience method to make {ToRegexp}s from +value.to_regexp+
     #
-    # @rbs (Regexp::_ToRegexp | Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
-    def self?.regexp: (Regexp::_ToRegexp | Regexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
+    # @rbs (Regexp::_ToRegexp | Regexp, ?with: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
+    def self.regexp: (Regexp::_ToRegexp | Regexp, ?with: 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
+    # @rbs (path, ?with: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
+    def self.path: (path, ?with: 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
+    # @rbs (io, ?with: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
+    def self.io: (io, ?with: 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.
     #
@@ -110,14 +106,14 @@ module Blankity
     # 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
+    # @rbs (_ToProc, ?with: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+    #    | (?with: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
+    def self.proc: (_ToProc, ?with: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+                 | (?with: Array[interned], ?hash: bool) { (?) -> untyped } -> ToProc
 
     # 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]
+    # @rbs [T] (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
+    def self.range: [T] (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
   end
 end

data/sig/generated/blankity/value.rbs

@@ -0,0 +1,158 @@
+# Generated from lib/blankity/value.rb with RBS::Inline
+
+module Blankity
+  # @rbs generic T
+  class Value[T] < Blank
+    # The underlying value
+    attr_reader __value__: T
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (T, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (T, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+  end
+
+  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
+  #
+  # @rbs inherits Value[Integer]
+  class ToI < Value[Integer]
+    alias to_i __value__
+  end
+
+  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
+  #
+  # @rbs inherits Value[Integer]
+  class ToInt < Value[Integer]
+    alias to_int __value__
+  end
+
+  # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToS < Value[String]
+    alias to_s __value__
+  end
+
+  # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToStr < Value[String]
+    alias to_str __value__
+  end
+
+  # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
+  #
+  # @rbs generic unchecked out T -- Type of elements
+  # @rbs inherits Value[Array[T]]
+  class ToA[unchecked out T] < Value[Array[T]]
+    alias to_a __value__
+  end
+
+  # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
+  #
+  # @rbs generic unchecked out T -- Type of elements
+  # @rbs inherits Value[Array[T]]
+  class ToAry[unchecked out T] < Value[Array[T]]
+    alias to_ary __value__
+  end
+
+  # A Class which exclusively defines +#to_h+; it implements RBS's +_ToH[K, V]+ interface.
+  #
+  # @rbs generic unchecked out K -- Type of Key
+  # @rbs generic unchecked out V -- Type of Value
+  # @rbs inherits Value[Hash[K, V]]
+  class ToH[unchecked out K, unchecked out V] < Value[Hash[K, V]]
+    alias to_h __value__
+  end
+
+  # A Class which exclusively defines +#to_hash+; it implements RBS's +_ToHash[K, V]+ interface.
+  #
+  # @rbs generic unchecked out K -- Type of Key
+  # @rbs generic unchecked out V -- Type of Value
+  # @rbs inherits Value[Hash[K, V]]
+  class ToHash[unchecked out K, unchecked out V] < Value[Hash[K, V]]
+    alias to_hash __value__
+  end
+
+  # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
+  #
+  # @rbs inherits Value[Symbol]
+  class ToSym < Value[Symbol]
+    alias to_sym __value__
+  end
+
+  # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
+  #
+  # @rbs inherits Value[Rational]
+  class ToR < Value[Rational]
+    alias to_r __value__
+  end
+
+  # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
+  #
+  # @rbs inherits Value[Complex]
+  class ToC < Value[Complex]
+    alias to_c __value__
+  end
+
+  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
+  #
+  # @rbs inherits Value[Float]
+  class ToF < Value[Float]
+    alias to_f __value__
+  end
+
+  # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
+  #
+  # @rbs inherits Value[Regexp]
+  class ToRegexp < Value[Regexp]
+    alias to_regexp __value__
+  end
+
+  # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
+  #
+  # @rbs inherits Value[String]
+  class ToPath < Value[String]
+    alias to_path __value__
+  end
+
+  # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
+  #
+  # @rbs inherits Value[IO]
+  class ToIO < Value[IO]
+    alias to_io __value__
+  end
+
+  # A Class which exclusively defines +#to_proc+; it implements RBS's +_ToProc+ interface.
+  #
+  # @rbs inherits Value[Proc]
+  class ToProc < Value[Proc]
+    alias to_proc __value__
+  end
+
+  # A Class which defines `#begin`, `#end`, and `#exclude_end?`. It implements RBS's +_Range[T]+
+  # interface.
+  #
+  # @rbs generic out T -- Type to iterate over
+  class Range[out T] < Blank
+    @__begin__: T?
+
+    @__end__: T?
+
+    @__exclude_end__: bool
+
+    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
+    #
+    # @rbs (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (T?, T?, ?bool, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+
+    # @rbs () -> T?
+    def begin: () -> T?
+
+    # @rbs () -> T?
+    def end: () -> T?
+
+    # @rbs () -> bool
+    def exclude_end?: () -> bool
+  end
+end

data/sig/generated/blankity.rbs

@@ -1,4 +1,8 @@
 # Generated from lib/blankity.rb with RBS::Inline
 
 module Blankity
+  # Shorthand constructor {Blankity::Blank}.
+  #
+  # @rbs (?with: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
+  def self.blank: (?with: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.10.1
+  version: 0.11.0
 platform: ruby
 authors:
 - Sam Westerman
@@ -24,15 +24,15 @@ files:
 - Steepfile
 - lib/blankity.rb
 - lib/blankity/blank.rb
-- lib/blankity/classes.rb
 - lib/blankity/to.rb
 - lib/blankity/top.rb
+- lib/blankity/value.rb
 - lib/blankity/version.rb
 - sig/generated/blankity.rbs
 - sig/generated/blankity/blank.rbs
-- sig/generated/blankity/classes.rbs
 - sig/generated/blankity/to.rbs
 - sig/generated/blankity/top.rbs
+- sig/generated/blankity/value.rbs
 - sig/generated/blankity/version.rbs
 - sig/test/test/test_blank.rbs
 - sig/test/test/test_helper.rbs

data/lib/blankity/classes.rb

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-# rbs_inline: enabled
-
-module Blankity
-  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
-  class ToI < Blank
-    # @rbs @__value__: Integer
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Integer, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Integer
-    def to_i = @__value__
-  end
-
-  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
-  class ToInt < Blank
-    # @rbs @__value__: Integer
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Integer, ?with: 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.
-  class ToS < Blank
-    # @rbs @__value__: String
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (String, ?with: 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.
-  class ToStr < Blank
-    # @rbs @__value__: String
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (String, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> String
-    def to_str = @__value__
-  end
-
-  # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
-  #
-  # @rbs generic unchecked out T -- Type of elements
-  class ToA < Blank
-    # @rbs @__value__: Array[T]
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Array[T], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Array[T]
-    def to_a = @__value__
-  end
-
-  # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
-  #
-  # @rbs generic unchecked out T -- Type of elements
-  class ToAry < Blank
-    # @rbs @__value__: Array[T]
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Array[T], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Array[T]
-    def to_ary = @__value__
-  end
-
-  # A Class which exclusively defines +#to_h+; it implements RBS's +_ToH[K, V]+ interface.
-  #
-  # @rbs generic unchecked out K -- Type of Key
-  # @rbs generic unchecked out V -- Type of Value
-  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], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Hash[K, V]
-    def to_h = @__value__
-  end
-
-  # A Class which exclusively defines +#to_hash+; it implements RBS's +_ToHash[K, V]+ interface.
-  #
-  # @rbs generic unchecked out K -- Type of Key
-  # @rbs generic unchecked out V -- Type of Value
-  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], ?with: 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.
-  class ToSym < Blank
-    # @rbs @__value__: Symbol
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Symbol, ?with: 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.
-  class ToR < Blank
-    # @rbs @__value__: Rational
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Rational, ?with: 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.
-  class ToC < Blank
-    # @rbs @__value__: Complex
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Complex, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Complex
-    def to_c = @__value__
-  end
-
-  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
-  class ToF < Blank
-    # @rbs @__value__: Float
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Float, ?with: 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.
-  class ToRegexp < Blank
-    # @rbs @__value__: Regexp
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Regexp, ?with: 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.
-  class ToPath < Blank
-    # @rbs @__value__: String
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (String, ?with: 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.
-  class ToIO < Blank
-    # @rbs @__value__: IO
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (IO, ?with: 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.
-  class ToProc < Blank
-    # @rbs @__value__: Proc
-
-    # Creates a new instance; any additional arguments or block are passed to {Blank#initialize}.
-    #
-    # @rbs (Proc, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(value, ...)
-      @__value__ = value
-      super(...)
-    end
-
-    #: () -> Proc
-    def to_proc = @__value__
-  end
-
-  # A Class which defines `#begin`, `#end`, and `#exclude_end?`. It implements RBS's +_Range[T]+
-  # interface.
-  #
-  # @rbs generic out T -- Type to iterate over
-  class Range < Blank
-    # @rbs @begin: T?
-    # @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, ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(begin_, end_, exclude_end = false, ...)
-      @__begin__ = begin_
-      @__end__ = end_
-      @__exclude_end__ = exclude_end
-
-      super(...)
-    end
-
-    #: () -> T?
-    def begin = @__begin__
-
-    #: () -> T?
-    def end = @__end__
-
-    #: () -> bool
-    def exclude_end? = @__exclude_end__
-  end
-end

data/sig/generated/blankity/classes.rbs

@@ -1,247 +0,0 @@
-# Generated from lib/blankity/classes.rb with RBS::Inline
-
-module Blankity
-  # A Class which only defines +#to_i+; it implements RBS's +_ToI+ interface.
-  class ToI < 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_i: () -> Integer
-  end
-
-  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
-  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.
-  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.
-  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
-
-  # A Class which exclusively defines +#to_a+; it implements RBS's +_ToA[T]+ interface.
-  #
-  # @rbs generic unchecked out T -- Type of elements
-  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
-
-  # A Class which exclusively defines +#to_ary+; it implements RBS's +_ToAry[T]+ interface.
-  #
-  # @rbs generic unchecked out T -- Type of elements
-  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
-
-  # A Class which exclusively defines +#to_h+; it implements RBS's +_ToH[K, V]+ interface.
-  #
-  # @rbs generic unchecked out K -- Type of Key
-  # @rbs generic unchecked out V -- Type of Value
-  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
-
-  # A Class which exclusively defines +#to_hash+; it implements RBS's +_ToHash[K, V]+ interface.
-  #
-  # @rbs generic unchecked out K -- Type of Key
-  # @rbs generic unchecked out V -- Type of Value
-  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.
-  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.
-  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.
-  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
-  end
-
-  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
-  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.
-  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.
-  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.
-  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.
-  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
-
-  # A Class which defines `#begin`, `#end`, and `#exclude_end?`. It implements RBS's +_Range[T]+
-  # interface.
-  #
-  # @rbs generic out T -- Type to iterate over
-  class Range[out T] < Blank
-    @begin: T?
-
-    @end: T?
-
-    @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
-
-    # : () -> T?
-    def begin: () -> T?
-
-    # : () -> T?
-    def end: () -> T?
-
-    # : () -> bool
-    def exclude_end?: () -> bool
-  end
-end