blankity 0.1.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34a522794c85b7f50a815a2a17e455685e5fff40512134a8652d52705fd96946
-  data.tar.gz: 44fe6ca43f7a274e076b00c83fee4da89617102769007615a56f9e8ba8345876
+  metadata.gz: 2ac387131a2ec24c66cc4c22c214addbf73b0ab121350a39d4db6556fa78113c
+  data.tar.gz: 35a28db8ef6f0d040683c16e241897cc96ab4d0f0e754e6399cefd5d384a775f
 SHA512:
-  metadata.gz: 2679a4fc2901543f1df080226bcd8d41cde7fff84ffadf084a5a3b54509bc150e5e70ed9cc138624d3a9d9d0ba09f792b11ae7253894b9d35adab64a736c4eb3
-  data.tar.gz: 9102b667417681d9e6c52a83d3e2742513d0ff9a95efaa5925f913c9017c0a841c14ea1d414b36846797d885568547f99feffb729de7e13d012bab88508301df
+  metadata.gz: 9d189e2a9a0b63d7cd30636d7f0a645341fe8cf5fca106b2c1569f54ab15ef93984884014b69aa6bad0542669cf7c6eb9627a3d4d75a10d9bfa6b243a14179a1
+  data.tar.gz: 815454f7b361da955246a3f7119f8634b0e422563c3a41e5da22ae08c713c910dd7c017ee1879ce33070e4bb144957743da4293aedc8a8601dd3610f0e63c937

data/.yardopts

@@ -0,0 +1 @@
+--type-tag rbs --hide-tag rbs

data/Steepfile

@@ -18,12 +18,11 @@ target :lib do
   # end
 end
 
-# target :test do
+target :test do
 #   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
 #   signature "sig/test"              # Put RBS files for tests under `sig/test`
-#   check "test"                      # Type check Ruby scripts under `test`
-
-#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+  check "test"                      # Type check Ruby scripts under `test`
+  configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+  gem 'rake'
+end
 
-#   # library "pathname"              # Standard libraries
-# end

data/lib/blankity/blank.rb

@@ -2,54 +2,86 @@
 # rbs_inline: enabled
 
 module Blankity
-  # A "blank slate" class which removes _all_ methods (from `BasicObject`) other than the "required"
-  # ones of `__send__` and `__id__`.
+  # An "emptier" class than {BasicObject}, which +undef+ines nearly all instance methods.
   #
-  # Notably, it does not remove private instance methods, as Ruby actually requires some of them to
-  # function properly (e.g. {BasicObject#singleton_method_added}.)
+  # Not _all_ methods are undefined (see {AboslutelyBlank} 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__+
+  #   and +__id__+
+  # - 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,
+  # which will define singleton methods based on {Object}.
   class Blank < BasicObject
-    # Remove every method except for `__send__` and `__id__`
+    # Remove every public and protected method that we inherit, except for `__xyz__` methods
     instance_methods.each do |name|
-      undef_method(name) unless name == :__send__ || name == :__id__
+      undef_method(name) unless name.match?(/\A__.*__\z/)
     end
 
-    # Helper method to create a new instance
-    #
-    # @rbs: () ?{ (Blank) -> void } -> singleton(Blank)
-    def self.blank(&block)
-      ::Class.new(self, &block).new
-    end
+    # Declare these as constants so we don't constantly look them up.
+    DEFINE_SINGLETON_METHOD = ::Object.instance_method(:define_singleton_method) #: UnboundMethod
+    INSTANCE_EXEC = ::Object.instance_method(:instance_exec) #: UnboundMethod
+    private_constant :DEFINE_SINGLETON_METHOD, :INSTANCE_EXEC
 
-    # A helper method to define some `Kernel`methods on `self`
-    def __with_Object_methods__(*methods)
-      dsm = ::Object.instance_method(:define_singleton_method).bind(self)
+    # 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
+    #                    type can be used as a key in +Hash+es
+    # @yield [] if a block is given, runs it via +instance_exec+.
+    #
+    # === Example
+    #   # Make a empty instance
+    #   Blankity::Blank.new
+    #
+    #   # Include `Object#inspect`, so we can print with `p`
+    #   p Blankity::Blank.new(methods: %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: [], hash: false, &block)
+      # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
+      methods |= %i[hash eql?] if hash
 
-      methods.each do |method|
-        dsm.call(method, ::Object.instance_method(method))
-      end
+      # Define any object methods requested by the end-user
+      __define_Object_methods__(*methods)
 
-      self
+      # If a block's provided, then `instance_exec`
+      INSTANCE_EXEC.bind_call(self, &__any__ = block) if block
     end
 
-    # Same as `__with_Object_methods__`, but adds them to subclasses. This shouldn't
-    # be called on `Blankity::Blank` directly, as that affects subclasses
-    def self.__with_Object_methods__(*methods)
-      if ::Blankity::Blank.equal?(self)
-        raise ArgumentError, 'Cannot call `__with_Object_methods__` on Blank, as that will affect all blank slates'
-      end
-
+    # A helper method to define {Object} instance methods on +self+
+    #
+    # @param methods [*interned] The list of instance methods from {Object} to define
+    # @return [self]
+    #
+    # === Example
+    #   # Make an empty instance
+    #   blank = Blankity::Blank.blank
+    #
+    #   # Make sure it's printable
+    #   blank.__define_Object_methods__(:inspect, :==)
+    #
+    #   # Now you can use them!
+    #   fail unless blank == blank
+    #   p blank
+    #
+    # @rbs (*interned) -> self
+    def __define_Object_methods__(*methods)
       methods.each do |method|
-        define_method(method, ::Kernel.instance_method(method))
+        DEFINE_SINGLETON_METHOD.bind_call(self, method, ::Object.instance_method(method).bind(self))
       end
 
       self
     end
-
-    # Helper method to create a new `Blank` with a block
-    def self.blank(&block)
-      ::Class.new(self, &block).new
-    end
   end
 
-  def self.blank(...) = Blank.blank(...)
+  # Shorthand constructor {Blankity::Blank}.
+  #
+  # @rbs (?methods: Array[interned], ?hash: bool) ?{ () [self: Blank] -> void } -> Blank
+  def self.blank(...) = Blank.new(...)
 end

data/lib/blankity/classes.rb

@@ -2,39 +2,24 @@
 # rbs_inline: enabled
 
 module Blankity
-  # BlankValue is a superclass of the +ToXXX+ classes, which consolidates their initialization
-  # into one convenient place
+  # Superclass of +ToXXX+ types
   #
   # @rbs generic T -- type of @__value__
   class BlankValue < Blank
     # @rbs @__value__: T
 
-    DEFINE_SINGLETON_METHOD = ::Kernel.instance_method(:define_singleton_method)
-    private_constant :DEFINE_SINGLETON_METHOD
-
     # 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 methods to define on +self+ that will just forward
-    #                                  everything to +value.<method>+
+    # @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+.
     #
-    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: self] -> void } -> void
-    def initialize(value, methods: [], hash: false, &block)
+    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(value, ...)
       @__value__ = value
-
-      # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
-      methods |= %i[hash eql?] if hash
-
-      methods.each do |method|
-        # We can use `.method` instead of querying `Kernel` because all types that are used here
-        # inherit from `Object`.
-        DEFINE_SINGLETON_METHOD.bind_call(self, method, &@__value__.method(method))
-      end
-
-      instance_exec(&block) if block
+      super(...)
     end
   end
 
@@ -181,23 +166,13 @@ module Blankity
     # @rbs @end: T?
     # @rbs @exclude_end: bool
 
-    #: (T?, T?, ?bool) -> void
-    def initialize(begin_, end_, exclude_end = false, methods: [], hash: false, &block)
+    # @rbs (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(begin_, end_, exclude_end = false, ...)
       @__begin__ = begin_
       @__end__ = end_
       @__exclude_end__ = exclude_end
 
-      # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
-      methods |= %i[hash eql?] if hash
-
-      methods.each do |method|
-        p method
-        # We can use `.method` instead of querying `Kernel` because all types that are used here
-        # inherit from `Object`.
-        DEFINE_SINGLETON_METHOD.bind_call(self, method, &@__value__.method(method))
-      end
-
-      instance_exec(&block) if block
+      super(...)
     end
 
     #: () -> T?

data/lib/blankity/to.rb

@@ -1,21 +1,32 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Blankity
   module To
     module_function
 
+    # @rbs (_ToI, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
     def i(value, ...) = ToI.new(value.to_i, ...)
+
+    # @rbs (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
     def int(value, ...) = ToInt.new(value.to_int, ...)
+
+    # @rbs (_ToS, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
     def s(value, ...) = ToS.new(value.to_s, ...)
+
+    # @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])`.
+    #
+    # @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 = elements[0].to_a
+        elements = (__any__ = elements[0]).to_a
       end
 
       ToA.new(elements, **, &)
@@ -25,9 +36,12 @@ module Blankity
     #
     # 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])`.
+    #
+    # @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 = elements[0].to_ary
+        elements = (__any__ = elements[0]).to_ary
       end
 
       ToAry.new(elements, **, &)
@@ -38,6 +52,9 @@ module Blankity
     # 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.
+    #
+    # @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({**}, &)
@@ -51,32 +68,48 @@ module Blankity
     # 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.
+    #
+    # @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({**}, &)
       else
-        ToHash.new(hash.to_hash, **, &)
+        ToHash.new((__any__ = hash).to_hash, **, &)
       end
     end
 
+    # @rbs (_ToSym, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
     def sym(value, ...) = ToSym.new(value.to_sym, ...)
+
+    # @rbs (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
     def r(value, ...) = ToR.new(value.to_r, ...)
+
+    # @rbs (_ToC, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
     def c(value, ...) = ToC.new(value.to_c, ...)
+
+    # @rbs (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
     def f(value, ...) = ToF.new(value.to_f, ...)
+
+    # @rbs (Regexp::_ToRegexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
     def regexp(value, ...) = ToRegexp.new(value.to_regexp, ...)
 
+    # @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
 
+    # @rbs (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
     def io(value, ...) = ToIO.new(value.to_io, ...)
+
+    # @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(block, **)
+        ToProc.new(__any__ = block, **)
       else
         ToProc.new(proc.to_proc, **, &block)
       end
@@ -85,8 +118,10 @@ module Blankity
     # 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.
+    #
+    # @rbs [T] (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
     def range(begin_, end_, exclude_end = false, ...)
-      Range.new(begin_, end_, exclude_end, ...)
+      __any__ = Range.new(begin_, end_, exclude_end, ...)
     end
   end
 end

data/lib/blankity/{absolutely_blank.rb → top.rb}

@@ -1,3 +1,5 @@
+# rbs_inline: enabled
+
 module Blankity
   # A Class that has _no_ instance methods on it whatsoever.
   #
@@ -6,8 +8,8 @@ module Blankity
   # builtin functionality. (For example, without +singleton_method_defined+, you can't actually
   # define singleton methods _at all_.)
   #
-  # @see Blank for a type which doesn't undefine these critical builtin methods
-  class AbsolutelyBlank < BasicObject
+  # @see Blank
+  class Top < BasicObject
     # We have to disable warnings for just this block, as Ruby warns for `undef`ing some methods
     previous_warning, $-w = $-w, nil
 

data/lib/blankity/version.rb

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

data/lib/blankity.rb

@@ -4,6 +4,7 @@
 module Blankity; end
 
 require_relative 'blankity/version'
+require_relative 'blankity/top'
 require_relative 'blankity/blank'
 require_relative 'blankity/classes'
 require_relative 'blankity/to'

data/sig/generated/blankity/blank.rbs

@@ -1,19 +1,66 @@
 # Generated from lib/blankity/blank.rb with RBS::Inline
 
 module Blankity
-  # A "blank slate" class which removes _all_ methods (from `BasicObject`) other than the "required"
-  # ones of `__send__` and `__id__`.
+  # An "emptier" class than {BasicObject}, which +undef+ines nearly all instance methods.
+  #
+  # Not _all_ methods are undefined (see {AboslutelyBlank} 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__+
+  #   and +__id__+
+  # - 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,
+  # which will define singleton methods based on {Object}.
   class Blank < BasicObject
-    # A helper method to define some `Kernel`methods on `self`
-    def __with_Object_methods__: (*untyped methods) -> untyped
+    # Declare these as constants so we don't constantly look them up.
+    DEFINE_SINGLETON_METHOD: UnboundMethod
 
-    # Same as `__with_Object_methods__`, but adds them to subclasses. This shouldn't
-    # be called on `Blankity::Blank` directly, as that affects subclasses
-    def self.__with_Object_methods__: (*untyped methods) -> untyped
+    INSTANCE_EXEC: UnboundMethod
 
-    # Helper method to create a new `Blank` with a block
-    def self.blank: () ?{ (?) -> untyped } -> untyped
+    # 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
+    #                    type can be used as a key in +Hash+es
+    # @yield [] if a block is given, runs it via +instance_exec+.
+    #
+    # === Example
+    #   # Make a empty instance
+    #   Blankity::Blank.new
+    #
+    #   # Include `Object#inspect`, so we can print with `p`
+    #   p Blankity::Blank.new(methods: %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
+
+    # A helper method to define {Object} instance methods on +self+
+    #
+    # @param methods [*interned] The list of instance methods from {Object} to define
+    # @return [self]
+    #
+    # === Example
+    #   # Make an empty instance
+    #   blank = Blankity::Blank.blank
+    #
+    #   # Make sure it's printable
+    #   blank.__define_Object_methods__(:inspect, :==)
+    #
+    #   # Now you can use them!
+    #   fail unless blank == blank
+    #   p blank
+    #
+    # @rbs (*interned) -> self
+    def __define_Object_methods__: (*interned) -> self
   end
 
-  def self.blank: () -> untyped
+  # 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/classes.rbs

@@ -0,0 +1,179 @@
+# 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
+
+    # 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+.
+    #
+    # @rbs (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize: (T, ?methods: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+  end
+
+  # 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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
+  # @rbs inherits BlankValue[Array[T]]
+  class ToA[unchecked out T] < BlankValue[Array[T]]
+    # : () -> 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
+  # @rbs inherits BlankValue[Array[T]]
+  class ToAry[unchecked out T] < BlankValue[Array[T]]
+    # : () -> 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
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToH[unchecked out K, unchecked out V] < BlankValue[Hash[K, V]]
+    # : () -> 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
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToHash[unchecked out K, unchecked out V] < BlankValue[Hash[K, V]]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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]
+    # : () -> 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
+
+    # @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

data/sig/generated/blankity/to.rbs

@@ -0,0 +1,90 @@
+# Generated from lib/blankity/to.rb with RBS::Inline
+
+module Blankity
+  module To
+    # @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 (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
+    def self?.int: (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
+
+    # @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 (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.
+    #
+    # 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]
+
+    # 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])`.
+    #
+    # @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]
+
+    # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
+    #
+    # 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.
+    #
+    # @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.
+    #
+    # 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.
+    #
+    # @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]
+
+    # @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 (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
+    def self?.r: (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
+
+    # @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 (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
+    def self?.f: (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
+
+    # @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
+
+    # @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 (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
+    def self?.io: (io, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToIO] -> void } -> ToIO
+
+    # @rbs (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> ToProc
+    def self?.proc: (_ToProc, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToProc] -> void } -> 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.
+    #
+    # @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]
+  end
+end

data/sig/generated/blankity/top.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/blankity/top.rb with RBS::Inline
+
+module Blankity
+  # A Class that has _no_ instance methods on it whatsoever.
+  #
+  # This is actually pretty difficult to use properly, as some methods (e.g. +initialize+
+  # and +singleton_method_defined+) are expected by Ruby to always exist, and restrict a lot of
+  # builtin functionality. (For example, without +singleton_method_defined+, you can't actually
+  # define singleton methods _at all_.)
+  #
+  # @see Blank
+  class Top < BasicObject
+  end
+end

data/sig/test/test/test_blank.rbs

@@ -0,0 +1,21 @@
+class TestBlankity_Top < Minitest::Test
+  def test_that_it_doesnt_undef_private_methods: () -> untyped
+
+  def test_that_it_only_has_underscore_methods: () -> untyped
+
+  def assert_singleton_methods: (untyped methods, untyped instance) -> untyped
+
+  def test_initialize_with_argouments: () -> untyped
+
+  def test_initialize_with_methods: () -> untyped
+
+  def test_initialize_with_hash: () -> untyped
+
+  def test_initialize_with_methods_and_hash: () -> untyped
+
+  def test_initialize_with_block: () -> untyped
+
+  def test_initialize_with_block_is_run_after_methods: () -> untyped
+
+  def test___define_Object_methods__: () -> untyped
+end

data/sig/test/test/test_top.rbs

@@ -0,0 +1,3 @@
+class TestBlankity_Top < Minitest::Test
+  def test_it_has_no_instance_methods: () -> untyped
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Sam Westerman
@@ -17,20 +17,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE.txt
 - README.md
 - Rakefile
 - Steepfile
 - lib/blankity.rb
-- lib/blankity/absolutely_blank.rb
 - lib/blankity/blank.rb
 - lib/blankity/classes.rb
 - lib/blankity/to.rb
+- lib/blankity/top.rb
 - lib/blankity/version.rb
 - sig/generated/blankity.rbs
 - sig/generated/blankity/blank.rbs
-- sig/generated/blankity/tos.rbs
+- sig/generated/blankity/classes.rbs
+- sig/generated/blankity/to.rbs
+- sig/generated/blankity/top.rbs
 - sig/generated/blankity/version.rbs
+- sig/test/test/test_blank.rbs
+- sig/test/test/test_helper.rbs
+- sig/test/test/test_top.rbs
 homepage: https://github.com/sampersand/blankity
 licenses:
 - MIT

data/sig/generated/blankity/tos.rbs

@@ -1,44 +0,0 @@
-# Generated from lib/blankity/tos.rb with RBS::Inline
-
-module Blankity
-  class ToI < Blank
-    # : (Integer) -> void
-    def initialize: (Integer) -> void
-
-    # : () -> Integer
-    def to_i: () -> Integer
-  end
-
-  class ToInt < Blank
-    # : (Integer) -> void
-    def initialize: (Integer) -> void
-
-    # : () -> Integer
-    def to_int: () -> Integer
-  end
-
-  class ToS < Blank
-    # : (String) -> void
-    def initialize: (String) -> void
-
-    # : () -> String
-    def to_s: () -> String
-  end
-
-  class ToStr < Blank
-    # : (String) -> void
-    def initialize: (String) -> void
-
-    # : () -> String
-    def to_str: () -> String
-  end
-
-  # @rbs generic unchecked out T -- Type of elements
-  class ToA[unchecked out T] < Blank
-    # : (Array[T]) -> void
-    def initialize: (Array[T]) -> void
-
-    # : () -> String
-    def to_a: () -> String
-  end
-end