blankity 0.10.1 → 1.0.0

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: 1.0.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
@@ -56,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0.dev
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Provides "blank" objects which only supply conversion methods
 test_files: []

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