blankity 0.10.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6073dd5657ac15bdd561c7438da0dd3fb890e82d50953f479a2b2dceb40dbdbf
-  data.tar.gz: 28ae49ee61fe6d2d6e0b785f95a57a77b1ba35fe0c5aa7d94086ab6510f495f6
+  metadata.gz: 9df0df8fd886ec2a81641d73014b4be0b527a660fcba506edb70678f37414125
+  data.tar.gz: 1d4bc2db327cfae657ea66ac46c713dcc8778a2a5e3e2f82bb2e71aeb706611e
 SHA512:
-  metadata.gz: f5f7213d2521ab96d21139443fdb6e8d634b6dc3564d6e7f04fdc3887149b5fff126ad8cb4fa53d7a2884416614b3f5364cf8086172774ada77eb41a0302532b
-  data.tar.gz: 18b221c650794e50faa44bd9830f561bf3be7402e2f66caac22c9ba3fa998b10ad6950cf380952369804c2397cffd35d9ef5ea7c1b279f79d8ca7db49001f0b4
+  metadata.gz: '09a5c2ed58492f5943bd548726302f90296d392a1f654bc25507ab64fef10b298cd415f1b0063fc121dfeea48998ef5f7728ba39e5878e189a00c8b9403482ec'
+  data.tar.gz: ad5b3b4fafa74d980b7aa145b96accc7ea795fc1111b59c0bb22469d799ecaf6930b04fdd4a0b09600086ff24dfa54e0cbec9661a59066ba0662e6ba592cffba

data/README.md

@@ -53,22 +53,22 @@ puts 'hello'.gsub(/[eo]/, Blankity::To.hash('e' => 'E', 'o' => 'O'))
 #=> hEllO
 ```
 
-The `Blankity::To` module is also a mixin!
+You can include the `Blankity::To` module to get theeh `theo` method!
 ```ruby
 extend Blankity::To
 
-puts 'hello' + str(' world')
-exit int(0)
+puts 'hello' + to.str(' world')
+exit to.int(0)
 
 # Let's get crazy!
 system(
-  hash(
-    str('HELLO', hash: true) => str('WORLD')
+  to.hash(
+    to.str('HELLO', hash: true) => to.str('WORLD')
   ),
-  ary(str('sh'), str('-sh')),
-  str('-c'),
-  str('echo $0 $HELLO $PWD'),
-  chdir: path('/'),
+  to.ary(to.str('sh'), to.str('-sh')),
+  to.str('-c'),
+  to.str('echo $0 $HELLO $PWD'),
+  chdir: to.path('/'),
 )
 ```
 

data/lib/blankity/blank.rb

@@ -20,8 +20,10 @@ module Blankity
     # @rbs!
     #   def __define_singleton_method__: (interned name, Method | UnboundMethod | Proc method) -> Symbol
     #                                  | (interned name) { (?) [self: self] -> untyped } -> Symbol
-    #   def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
     define_method :__define_singleton_method__, ::Kernel.instance_method(:define_singleton_method)
+
+    # @rbs!
+    #   def __instance_exec__: [T] (*untyped, **untyped) { (?) [self: self] -> T } -> T
     alias_method :__instance_exec__, :instance_exec # Use `alias_method` instead of `alias` so rbs-inline won't pick it up
 
     # Remove every other public and protected method that we inherit, except for `__xyz__` methods
@@ -36,6 +38,7 @@ module Blankity
 
     # Creates a new {BlankValue}, and defining singleton methods depending on the parameters
     #
+    # @param vars [Hash[interned, untyped]] an array of instance variables to define on +self+.
     # @param with [Array[interned]] a list of {Object} methods to define on +self+.
     # @param hash [bool] convenience argument, adds +hash+ and +eql?+ to +with+ so the resulting
     #                    type can be used as a key in +Hash+es
@@ -51,8 +54,8 @@ module Blankity
     #   # Define a singleton method
     #   p Blankity::Blank.new{ def cool?(other) = other == 3 }.cool?(3) #=> true
     #
-    # @rbs (?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
-    def initialize(with: [], hash: false, &block)
+    # @rbs (?vars: Hash[interned, untyped], ?with: Array[interned], ?hash: bool) ?{ () [self: instance] -> void } -> void
+    def initialize(vars: {}, with: [], hash: false, &block)
       # If `hash` is supplied, then add `hash` and `eql?` to the list of methods to define
       with |= %i[hash eql?] if hash
 
@@ -61,6 +64,11 @@ module Blankity
         __define_singleton_method__(method, ::Object.instance_method(method).bind(self))
       end
 
+      # Assign all instance variables
+      vars.each do |key, value|
+        ::Kernel.instance_method(:instance_variable_set).bind_call(self, key, value)
+      end
+
       # If a block's provided, then `instance_exec`
       __instance_exec__(&__any__ = block) if block
     end

data/lib/blankity/to.rb

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

data/lib/blankity/value.rb

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

data/lib/blankity/version.rb

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

data/lib/blankity.rb

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

data/sig/generated/blankity/blank.rbs

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