blankity 0.0.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c77ee6b4b3f72c8cfa617313fa1a70f14644c140dae8346fc77e8eeb6a9c7bf
-  data.tar.gz: 6d612fe43c3cd9345f27947986a63fc980b2bb95c4f7f003a654fbd8a21c3bd5
+  metadata.gz: 2ac387131a2ec24c66cc4c22c214addbf73b0ab121350a39d4db6556fa78113c
+  data.tar.gz: 35a28db8ef6f0d040683c16e241897cc96ab4d0f0e754e6399cefd5d384a775f
 SHA512:
-  metadata.gz: e267257370d73d2cd537e2d62da15694574ad00390d4385e487c95d9d4591a6ffd40eb5b14afd93209f222c3afb7356d326bb32988bbaaf9509b43b59ba7bcb2
-  data.tar.gz: 56764266af70a160b088875284cfcfa168be5d8d5b1025f2445cafb4c98990affb137564fdaf4176a8a8819c9029acf934c78df176cdcdb03675233e07628402
+  metadata.gz: 9d189e2a9a0b63d7cd30636d7f0a645341fe8cf5fca106b2c1569f54ab15ef93984884014b69aa6bad0542669cf7c6eb9627a3d4d75a10d9bfa6b243a14179a1
+  data.tar.gz: 815454f7b361da955246a3f7119f8634b0e422563c3a41e5da22ae08c713c910dd7c017ee1879ce33070e4bb144957743da4293aedc8a8601dd3610f0e63c937

data/.yardopts

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

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 SamW
+Copyright (c) 2025 Sam Westerman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "minitest/test_task"
+require 'bundler/gem_tasks'
+require 'minitest/test_task'
 
 Minitest::TestTask.create
 

data/Steepfile

@@ -4,10 +4,7 @@ target :lib do
   signature "sig"
   ignore_signature "sig/test"
 
-  check "lib"                       # Directory name
-  check "path/to/source.rb"         # File name
-  check "app/models/**/*.rb"        # Glob
-  # ignore "lib/templates/*.rb"
+  check 'lib'
 
   # library "pathname"              # Standard libraries
   # library "strong_json"           # Gems
@@ -21,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,44 +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.
+  #
+  # 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
 
-    # A helper method to define some `Kernel`methods on `self`
-    def __with_Object_methods__(*methods)
-      dsm = ::Object.instance_method(:define_singleton_method).bind(self)
+    # 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
 
-      methods.each do |method|
-        dsm.call(method, ::Object.instance_method(method))
-      end
+    # 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
 
-      self
-    end
+      # Define any object methods requested by the end-user
+      __define_Object_methods__(*methods)
 
-    # 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
+      # If a block's provided, then `instance_exec`
+      INSTANCE_EXEC.bind_call(self, &__any__ = block) if block
+    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,162 +2,177 @@
 # rbs_inline: enabled
 
 module Blankity
-  class ValueBase < Blank
-    def initialize(value, 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
-
+  # Superclass of +ToXXX+ types
+  #
+  # @rbs generic T -- type of @__value__
+  class BlankValue < Blank
+    # @rbs @__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(value, ...)
       @__value__ = value
-
-    ::Blankity.blank do
-      # Always define the `to_method`
-      define_singleton_method(:inspect) { to_method.to_s }
-      define_method(to_method) { value }
-
-      # For all the `methods` methods, fetch its definition from `value` and use that as the
-      # definition
-      methods.each do |method|
-        define_method(method, &::Kernel.instance_method(:method).bind_call(value, method))
-      end
-
-      # If a block's given, execute it.
-      class_exec(&block) if block
+      super(...)
     end
   end
 
-  class ToI < Blank
-    #: (Integer) -> void
-    def initialize(value) = @__value__ = value
-
+  # 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
 
-  class ToInt < Blank
-    #: (Integer) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_int+; it implements RBS's +_ToInt+ interface.
+  #
+  # @rbs inherits BlankValue[Integer]
+  class ToInt < BlankValue
     #: () -> Integer
     def to_int = @__value__
   end
 
-  class ToS < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_s+; it implements RBS's +_ToS+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToS < BlankValue
     #: () -> String
     def to_s = @__value__
   end
 
-  class ToStr < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_str+; it implements RBS's +_ToStr+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToStr < BlankValue
     #: () -> 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
-    #: (Array[T]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Array[T]]
+  class ToA < BlankValue
     #: () -> 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
-    #: (Array[T]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Array[T]]
+  class ToAry < BlankValue
     #: () -> 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
-    #: (Hash[K, V]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToH < BlankValue
     #: () -> 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
-    #: (Hash[K, V]) -> void
-    def initialize(value) = @__value__ = value
-
+  # @rbs inherits BlankValue[Hash[K, V]]
+  class ToHash < BlankValue
     #: () -> Hash[K, V]
     def to_hash = @__value__
   end
 
-  class ToSym < Blank
-    #: (Symbol) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_sym+; it implements RBS's +_ToSym+ interface.
+  #
+  # @rbs inherits BlankValue[Symbol]
+  class ToSym < BlankValue
     #: () -> Symbol
     def to_sym = @__value__
   end
 
-  class ToR < Blank
-    #: (Rational) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_r+; it implements RBS's +_ToR+ interface.
+  #
+  # @rbs inherits BlankValue[Rational]
+  class ToR < BlankValue
     #: () -> Rational
     def to_r = @__value__
   end
 
-  class ToC < Blank
-    #: (Complex) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_c+; it implements RBS's +_ToC+ interface.
+  #
+  # @rbs inherits BlankValue[Complex]
+  class ToC < BlankValue
     #: () -> Complex
     def to_C = @__value__
   end
 
-  class ToF < Blank
-    #: (Float) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_f+; it implements RBS's +_ToF+ interface.
+  #
+  # @rbs inherits BlankValue[Float]
+  class ToF < BlankValue
     #: () -> Float
     def to_f = @__value__
   end
 
-  class ToRegexp < Blank
-    #: (Regexp) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_regexp+; it implements RBS's +Regexp::_ToRegexp+ interface.
+  #
+  # @rbs inherits BlankValue[Regexp]
+  class ToRegexp < BlankValue
     #: () -> Regexp
     def to_regexp = @__value__
   end
 
-  class ToPath < Blank
-    #: (String) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_path+; it implements RBS's +_ToPath+ interface.
+  #
+  # @rbs inherits BlankValue[String]
+  class ToPath < BlankValue
     #: () -> String
     def to_path = @__value__
   end
 
-  class ToIO < Blank
-    #: (IO) -> void
-    def initialize(value) = @__value__ = value
-
+  # A Class which exclusively defines +#to_io+; it implements RBS's +_ToIO+ interface.
+  #
+  # @rbs inherits BlankValue[IO]
+  class ToIO < BlankValue
     #: () -> 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
+    #: () -> 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
-    #: (T?, T?, ?bool) -> void
-    def initialize(begin_, end_, exclude_end = false)
+    # @rbs @begin: T?
+    # @rbs @end: T?
+    # @rbs @exclude_end: bool
+
+    # @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
+
+      super(...)
     end
 
     #: () -> T?
@@ -167,6 +182,6 @@ module Blankity
     def end = @__end__
 
     #: () -> bool
-    def exclude_end = @__exclude_end__
+    def exclude_end? = @__exclude_end__
   end
 end

data/lib/blankity/to.rb

@@ -1,77 +1,50 @@
 # frozen_string_literal: true
+# rbs_inline: enabled
 
 module Blankity
   module To
     module_function
 
-    # Helper method to create new `BlankSlate`s. Args:
-    # - `to_method`: The method to use, eg `to_i`
-    # - `value`: What to return when `to_method` is called
-    # - `methods`: Optional list of methods from to define, using `value`'s definition
-    # - `hash`: Helper to also add `hash` and `eql?` to `methods`, so it can be used as a hash key
-    # - `block`: If provided, a block to also run
-    def to_helper(to_method, value, 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
-
-      ::Blankity.blank do
-        # Always define the `to_method`
-        define_singleton_method(:inspect) { to_method.to_s }
-        define_method(to_method) { value }
-
-        # For all the `methods` methods, fetch its definition from `value` and use that as the
-        # definition
-        methods.each do |method|
-          define_method(method, &::Kernel.instance_method(:method).bind_call(value, method))
-        end
-
-        # If a block's given, execute it.
-        class_exec(&block) if block
-      end
-    end
+    # @rbs (_ToI, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToI] -> void } -> ToI
+    def i(value, ...) = ToI.new(value.to_i, ...)
 
-    # Create a type which _only_ responds to `.to_i`. See `to_helper` for details.
-    def i(value, ...)
-      to_helper(:to_i, value.to_i, ...)
-    end
+    # @rbs (int, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToInt] -> void } -> ToInt
+    def int(value, ...) = ToInt.new(value.to_int, ...)
 
-    # Create a type which _only_ responds to `.to_int`. See `to_helper` for details.
-    def int(value, ...)
-      to_helper(:to_int, value.to_int, ...)
-    end
+    # @rbs (_ToS, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToS] -> void } -> ToS
+    def s(value, ...) = ToS.new(value.to_s, ...)
 
-    # Create a type which _only_ responds to `.to_s`. See `to_helper` for details.
-    def s(value, ...)
-      to_helper(:to_s, value.to_s, ...)
-    end
-
-    # Create a type which _only_ responds to `.to_str`. See `to_helper` for details.
-    def str(value, ...)
-      to_helper(:to_str, value.to_str, ...)
-    end
+    # @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
-        to_helper(:to_a, Array(elements[0]), **, &)
-      else
-        to_helper(:to_a, elements, **, &)
+      if elements.length == 1 && defined?(elements[0].to_a)
+        elements = (__any__ = elements[0]).to_a
       end
+
+      ToA.new(elements, **, &)
     end
 
     # 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 ary(*elements, **, &)
-      if elements.length == 1
-        to_helper(:to_ary, Array(elements[0]), **, &)
-      else
-        to_helper(:to_ary, elements, **, &)
+      if elements.length == 1 && defined?(elements[0].to_ary)
+        elements = (__any__ = elements[0]).to_ary
       end
+
+      ToAry.new(elements, **, &)
     end
 
     # Create a type which _only_ responds to `.to_h`. See `to_helper` for details.
@@ -79,11 +52,14 @@ 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
-        to_helper(:to_h, {**}, &)
+        ToH.new({**}, &)
       else
-        to_helper(:to_h, hash.to_h, **, &)
+        ToH.new(hash.to_h, **, &)
       end
     end
 
@@ -92,60 +68,60 @@ 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
-        to_helper(:to_hash, {**}, &)
+        ToHash.new({**}, &)
       else
-        to_helper(:to_hash, hash.to_hash, **, &)
+        ToHash.new((__any__ = hash).to_hash, **, &)
       end
     end
 
-    # Create a type which _only_ responds to `.to_sym`. See `to_helper` for details.
-    def sym(value, ...)
-      to_helper(:to_sym, value.to_sym, ...)
-    end
+    # @rbs (_ToSym, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToSym] -> void } -> ToSym
+    def sym(value, ...) = ToSym.new(value.to_sym, ...)
 
-    # Create a type which _only_ responds to `.to_r`. See `to_helper` for details.
-    def r(value, ...)
-      to_helper(:to_r, value.to_r, ...)
-    end
+    # @rbs (_ToR, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToR] -> void } -> ToR
+    def r(value, ...) = ToR.new(value.to_r, ...)
 
-    # Create a type which _only_ responds to `.to_c`. See `to_helper` for details.
-    def c(value, ...)
-      to_helper(:to_c, value.to_c, ...)
-    end
+    # @rbs (_ToC, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToC] -> void } -> ToC
+    def c(value, ...) = ToC.new(value.to_c, ...)
 
-    # Create a type which _only_ responds to `.to_f`. See `to_helper` for details.
-    def f(value, ...)
-      to_helper(:to_f, value.to_f, ...)
-    end
+    # @rbs (float, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToF] -> void } -> ToF
+    def f(value, ...) = ToF.new(value.to_f, ...)
 
-    # Create a type which _only_ responds to `.to_regexp`. See `to_helper` for details.
-    def regexp(value, ...)
-      to_helper(:to_regexp, value.to_regexp, ...)
-    end
+    # @rbs (Regexp::_ToRegexp, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToRegexp] -> void } -> ToRegexp
+    def regexp(value, ...) = ToRegexp.new(value.to_regexp, ...)
 
-    # Create a type which _only_ responds to `.to_path`. See `to_helper` for details.
+    # @rbs (path, ?methods: Array[interned], ?hash: bool) ?{ () [self: ToPath] -> void } -> ToPath
     def path(value, ...)
-      to_helper(:to_path, defined?(value.to_path) ? value.to_path : String(value), ...)
+      ToPath.new(defined?(value.to_path) ? value.to_path : String(value), ...)
     end
 
-    # Create a type which _only_ responds to `.to_io`. See `to_helper` for details.
-    def io(value, ...)
-      to_helper(:to_io, value.to_io, ...)
+    # @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(__any__ = block, **)
+      else
+        ToProc.new(proc.to_proc, **, &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.
-    def range(begin_, end_, exclude_end = false, &)
-      ::Blankity.blank do
-        define_method(:begin) { begin_ }
-        define_method(:end) { end_ }
-        define_method(:exclude_end?) { exclude_end }
-
-        class_exec(&block) if block
-      end
+    #
+    # @rbs [T] (T?, T?, ?bool, ?methods: Array[interned], ?hash: bool) ?{ () [self: Range[T]] -> void } -> Range[T]
+    def range(begin_, end_, exclude_end = false, ...)
+      __any__ = Range.new(begin_, end_, exclude_end, ...)
     end
   end
 end

data/lib/blankity/top.rb

@@ -0,0 +1,23 @@
+# rbs_inline: enabled
+
+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
+    # We have to disable warnings for just this block, as Ruby warns for `undef`ing some methods
+    previous_warning, $-w = $-w, nil
+
+    (instance_methods + private_instance_methods).each do |name|
+      undef_method(name)
+    end
+
+    # Set warnings to what they used to be
+    $-w = previous_warning
+  end
+end

data/lib/blankity/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Blankity
-  VERSION = '0.0.2'
+  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,20 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: blankity
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.8.0
 platform: ruby
 authors:
-- SamW
+- Sam Westerman
 bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-email:
-- mail@sampersand.me
+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.
+email: mail@sampersand.me
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -23,16 +26,22 @@ files:
 - 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
-homepage: https://github.com/sampersand/blankity/blob/master
+- 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
 metadata:
-  homepage_uri: https://github.com/sampersand/blankity/blob/master
+  homepage_uri: https://github.com/sampersand/blankity
 rdoc_options: []
 require_paths:
 - lib
@@ -40,7 +49,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -49,5 +58,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.0.dev
 specification_version: 4
-summary: Helpers for creating types which _only_ respond to specific conversion methods
+summary: Provides "blank" objects which *only* supply conversion methods
 test_files: []

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