rbs 4.0.0.dev.4 → 4.1.0.pre.2

data/core/struct.rbs

@@ -2,9 +2,9 @@
 # Class Struct provides a convenient way to create a simple class that can store
 # and fetch values.
 #
-# This example creates a subclass of `Struct`, `Struct::Customer`; the first
-# argument, a string, is the name of the subclass; the other arguments, symbols,
-# determine the *members* of the new subclass.
+# This example creates a subclass of `Struct`, <code>Struct::Customer</code>;
+# the first argument, a string, is the name of the subclass; the other
+# arguments, symbols, determine the *members* of the new subclass.
 #
 #     Customer = Struct.new('Customer', :name, :address, :zip)
 #     Customer.name       # => "Struct::Customer"
@@ -18,7 +18,7 @@
 #     methods # => [:zip, :address=, :zip=, :address, :name, :name=]
 #
 # An instance of the subclass may be created, and its members assigned values,
-# via method `::new`:
+# via method <code>::new</code>:
 #
 #     joe = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
 #     joe # => #<struct Struct::Customer name="Joe Smith", address="123 Maple, Anytown NC", zip=12345>
@@ -71,10 +71,10 @@
 #
 # ### Methods for Comparing
 #
-# *   #==: Returns whether a given object is equal to `self`, using `==` to
-#     compare member values.
-# *   #eql?: Returns whether a given object is equal to `self`, using `eql?` to
-#     compare member values.
+# *   #==: Returns whether a given object is equal to `self`, using
+#     <code>==</code> to compare member values.
+# *   #eql?: Returns whether a given object is equal to `self`, using
+#     <code>eql?</code> to compare member values.
 #
 # ### Methods for Fetching
 #
@@ -104,8 +104,8 @@
 # *   #inspect (aliased as #to_s): Returns a string representation of `self`.
 # *   #to_h: Returns a hash of the member name/value pairs in `self`.
 #
-class Struct[Elem]
-  include Enumerable[Elem]
+class Struct[E]
+  include Enumerable[E]
 
   # The types that can be used when "indexing" into a `Struct` via `[]`, `[]=`, `dig`, and
   # `deconstruct_keys`.
@@ -119,21 +119,21 @@ class Struct[Elem]
   #   - Struct_subclass.new(*member_names) -> Struct_subclass_instance
   #   - Struct_subclass.new(**member_names) -> Struct_subclass_instance
   # -->
-  # `Struct.new` returns a new subclass of `Struct`.  The new subclass:
+  # <code>Struct.new</code> returns a new subclass of `Struct`.  The new subclass:
   #
   # *   May be anonymous, or may have the name given by `class_name`.
   # *   May have members as given by `member_names`.
   # *   May have initialization via ordinary arguments, or via keyword arguments
   #
-  # The new subclass has its own method `::new`; thus:
+  # The new subclass has its own method <code>::new</code>; thus:
   #
   #     Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
   #     f = Foo.new(0, 1)                   # => #<struct Struct::Foo foo=0, bar=1>
   #
-  # **\Class Name**
+  # **Class Name**
   #
   # With string argument `class_name`, returns a new subclass of `Struct` named
-  # `Struct::*class_name`*:
+  # <code>Struct::<em>class_name</em></code>:
   #
   #     Foo = Struct.new('Foo', :foo, :bar) # => Struct::Foo
   #     Foo.name                            # => "Struct::Foo"
@@ -158,7 +158,7 @@ class Struct[Elem]
   #     dave # =>     #<struct Struct::Customer name="Dave", address="123 Main">
   #     dave.greeting # => "Hello Dave at 123 Main"
   #
-  # Output, from `Struct.new`:
+  # Output, from <code>Struct.new</code>:
   #
   #     "The new subclass is Struct::Customer"
   #
@@ -184,7 +184,7 @@ class Struct[Elem]
   #
   # A subclass returned by Struct.new has these singleton methods:
   #
-  # *   Method `::new ` creates an instance of the subclass:
+  # *   Method <code>::new </code> creates an instance of the subclass:
   #
   #         Foo.new          # => #<struct Struct::Foo foo=nil, bar=nil>
   #         Foo.new(0)       # => #<struct Struct::Foo foo=0, bar=nil>
@@ -197,12 +197,13 @@ class Struct[Elem]
   #         Foo.new(foo: 0, bar: 1, baz: 2)
   #         # Raises ArgumentError: unknown keywords: baz
   #
-  # *   Method `:inspect` returns a string representation of the subclass:
+  # *   Method <code>:inspect</code> returns a string representation of the
+  #     subclass:
   #
   #         Foo.inspect
   #         # => "Struct::Foo"
   #
-  # *   Method `::members` returns an array of the member names:
+  # *   Method <code>::members</code> returns an array of the member names:
   #
   #         Foo.members # => [:foo, :bar]
   #
@@ -211,8 +212,8 @@ class Struct[Elem]
   # By default, the arguments for initializing an instance of the new subclass can
   # be both positional and keyword arguments.
   #
-  # Optional keyword argument `keyword_init:` allows to force only one type of
-  # arguments to be accepted:
+  # Optional keyword argument <code>keyword_init:</code> allows to force only one
+  # type of arguments to be accepted:
   #
   #     KeywordsOnly = Struct.new(:foo, :bar, keyword_init: true)
   #     KeywordsOnly.new(bar: 1, foo: 0)
@@ -252,8 +253,8 @@ class Struct[Elem]
   #   rdoc-file=struct.c
   #   - StructClass::keyword_init? -> true or falsy value
   # -->
-  # Returns `true` if the class was initialized with `keyword_init: true`.
-  # Otherwise returns `nil` or `false`.
+  # Returns `true` if the class was initialized with <code>keyword_init:
+  # true</code>. Otherwise returns `nil` or `false`.
   #
   # Examples:
   #     Foo = Struct.new(:a)
@@ -272,8 +273,8 @@ class Struct[Elem]
   # Returns  `true` if and only if the following are true; otherwise returns
   # `false`:
   #
-  # *   `other.class == self.class`.
-  # *   For each member name `name`, `other.name == self.name`.
+  # *   <code>other.class == self.class</code>.
+  # *   For each member name `name`, <code>other.name == self.name</code>.
   #
   # Examples:
   #
@@ -294,8 +295,8 @@ class Struct[Elem]
   # Returns `true` if and only if the following are true; otherwise returns
   # `false`:
   #
-  # *   `other.class == self.class`.
-  # *   For each member name `name`, `other.name.eql?(self.name)`.
+  # *   <code>other.class == self.class</code>.
+  # *   For each member name `name`, <code>other.name.eql?(self.name)</code>.
   #
   #         Customer = Struct.new(:name, :address, :zip)
   #         joe    = Customer.new("Joe Smith", "123 Maple, Anytown NC", 12345)
@@ -361,7 +362,7 @@ class Struct[Elem]
   #
   # Related: #members.
   #
-  def to_a: () -> Array[Elem]
+  def to_a: () -> Array[E]
 
   # <!--
   #   rdoc-file=struct.c
@@ -384,8 +385,8 @@ class Struct[Elem]
   #
   # Raises ArgumentError if the block returns an inappropriate value.
   #
-  def to_h: () -> Hash[Symbol, Elem]
-          | [K, V] () { (Symbol key, Elem value) -> [K, V] } -> Hash[K, V]
+  def to_h: () -> Hash[Symbol, E]
+          | [K, V] () { (Symbol key, E value) -> [K, V] } -> Hash[K, V]
 
   # <!-- rdoc-file=struct.c -->
   # Returns the values in `self` as an array:
@@ -440,8 +441,8 @@ class Struct[Elem]
   #
   # Related: #each_pair.
   #
-  def each: () -> Enumerator[Elem, self]
-          | () { (Elem value) -> void } -> self
+  def each: () -> Enumerator[E, self]
+          | () { (E value) -> void } -> self
 
   # <!--
   #   rdoc-file=struct.c
@@ -464,8 +465,8 @@ class Struct[Elem]
   #
   # Related: #each.
   #
-  def each_pair: () -> Enumerator[[Symbol, Elem], self]
-               | () { ([Symbol, Elem] key_value) -> void } -> self
+  def each_pair: () -> Enumerator[[Symbol, E], self]
+               | () { ([Symbol, E] key_value) -> void } -> self
 
   # <!--
   #   rdoc-file=struct.c
@@ -483,15 +484,15 @@ class Struct[Elem]
   #
   # Raises NameError if `name` is not the name of a member.
   #
-  # With integer argument `n` given, returns `self.values[n]` if `n` is in range;
-  # see Array@Array+Indexes:
+  # With integer argument `n` given, returns <code>self.values[n]</code> if `n` is
+  # in range; see Array@Array+Indexes:
   #
   #     joe[2]  # => 12345
   #     joe[-2] # => "123 Maple, Anytown NC"
   #
   # Raises IndexError if `n` is out of range.
   #
-  def []: (index name_or_position) -> Elem
+  def []: (index name_or_position) -> E
 
   # <!--
   #   rdoc-file=struct.c
@@ -520,7 +521,7 @@ class Struct[Elem]
   #
   # Raises IndexError if `n` is out of range.
   #
-  def []=: (index name_or_position, Elem value) -> Elem
+  def []=: (index name_or_position, E value) -> E
 
   # <!--
   #   rdoc-file=struct.c
@@ -539,8 +540,8 @@ class Struct[Elem]
   #
   # With no block given, returns an Enumerator.
   #
-  def select: () -> Enumerator[Elem, Array[Elem]]
-            | () { (Elem value) -> boolish } -> Array[Elem]
+  def select: () -> Enumerator[E, Array[E]]
+            | () { (E value) -> boolish } -> Array[E]
 
   # <!-- rdoc-file=struct.c -->
   # With a block given, returns an array of values from `self` for which the block
@@ -590,7 +591,7 @@ class Struct[Elem]
   # Raises RangeError if any element of the range is negative and out of range;
   # see Array@Array+Indexes.
   #
-  def values_at: (*int | range[int?] positions) -> Array[Elem]
+  def values_at: (*int | range[int?] positions) -> Array[E]
 
   # <!--
   #   rdoc-file=struct.c
@@ -633,7 +634,7 @@ class Struct[Elem]
   #     f.dig(0, 0, :b, 0) # => 1
   #     f.dig(:b, 0) # => nil
   #
-  def dig: (index name_or_position) -> Elem
+  def dig: (index name_or_position) -> E
          | (index name_or_position, untyped, *untyped) -> untyped
 
   # <!-- rdoc-file=struct.c -->
@@ -663,5 +664,5 @@ class Struct[Elem]
   #     h = joe.deconstruct_keys(nil)
   #     h # => {:name=>"Joseph Smith, Jr.", :address=>"123 Maple, Anytown NC", :zip=>12345}
   #
-  def deconstruct_keys: (Array[index & Hash::_Key]? indices) -> Hash[index & Hash::_Key, Elem]
+  def deconstruct_keys: (Array[index & Hash::_Key]? indices) -> Hash[index & Hash::_Key, E]
 end

data/core/symbol.rbs

@@ -8,8 +8,8 @@
 # The same `Symbol` object will be created for a given name or string for the
 # duration of a program's execution, regardless of the context or meaning of
 # that name. Thus if `Fred` is a constant in one context, a method in another,
-# and a class in a third, the `Symbol` `:Fred` will be the same object in all
-# three contexts.
+# and a class in a third, the `Symbol` <code>:Fred</code> will be the same
+# object in all three contexts.
 #
 #     module One
 #       class Fred
@@ -75,7 +75,8 @@
 #     given Regexp or other object; returns `nil` if no match is found.
 # *   #[], #slice : Returns a substring of symbol determined by a given index,
 #     start/length, or range, or string.
-# *   #empty?: Returns `true` if `self.length` is zero; `false` otherwise.
+# *   #empty?: Returns `true` if <code>self.length</code> is zero; `false`
+#     otherwise.
 # *   #encoding: Returns the Encoding object that represents the encoding of
 #     symbol.
 # *   #end_with?: Returns `true` if symbol ends with any of the given strings.
@@ -130,19 +131,25 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - symbol <=> object -> -1, 0, +1, or nil
+  #   - self <=> other -> -1, 0, 1, or nil
   # -->
-  # If `object` is a symbol, returns the equivalent of `symbol.to_s <=>
-  # object.to_s`:
+  # Compares `self` and `other`, using String#<=>.
+  #
+  # Returns:
   #
-  #     :bar <=> :foo # => -1
-  #     :foo <=> :foo # => 0
-  #     :foo <=> :bar # => 1
+  # *   <code>self.to_s <=> other.to_s</code>, if `other` is a symbol.
+  # *   `nil`, otherwise.
   #
-  # Otherwise, returns `nil`:
+  # Examples:
   #
+  #     :bar <=> :foo  # => -1
+  #     :foo <=> :foo  # => 0
+  #     :foo <=> :bar  # => 1
   #     :foo <=> 'bar' # => nil
   #
+  # Class Symbol includes module Comparable, each of whose methods uses Symbol#<=>
+  # for comparison.
+  #
   # Related: String#<=>.
   #
   def <=>: (Symbol object) -> (-1 | 0 | 1)
@@ -165,8 +172,8 @@ class Symbol
   #   rdoc-file=string.c
   #   - symbol =~ object -> integer or nil
   # -->
-  # Equivalent to `symbol.to_s =~ object`, including possible updates to global
-  # variables; see String#=~.
+  # Equivalent to <code>symbol.to_s =~ object</code>, including possible updates
+  # to global variables; see String#=~.
   #
   def =~: (Regexp regex) -> Integer?
         | [T] (String::_MatchAgainst[String, T] object) -> T
@@ -179,7 +186,7 @@ class Symbol
   #   - symbol[regexp, capture = 0] -> string or nil
   #   - symbol[substring] -> string or nil
   # -->
-  # Equivalent to `symbol.to_s[]`; see String#[].
+  # Equivalent to <code>symbol.to_s[]</code>; see String#[].
   #
   def []: (int start, ?int length) -> String?
         | (range[int?] range) -> String?
@@ -188,9 +195,9 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - capitalize(*options) -> symbol
+  #   - capitalize(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.capitalize.to_sym`.
+  # Equivalent to <code>sym.to_s.capitalize.to_sym</code>.
   #
   # See String#capitalize.
   #
@@ -204,7 +211,7 @@ class Symbol
   #   - casecmp(object) -> -1, 0, 1, or nil
   # -->
   # Like Symbol#<=>, but case-insensitive; equivalent to
-  # `self.to_s.casecmp(object.to_s)`:
+  # <code>self.to_s.casecmp(object.to_s)</code>:
   #
   #     lower = :abc
   #     upper = :ABC
@@ -268,9 +275,9 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - downcase(*options) -> symbol
+  #   - downcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.downcase.to_sym`.
+  # Equivalent to <code>sym.to_s.downcase.to_sym</code>.
   #
   # See String#downcase.
   #
@@ -285,7 +292,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - empty? -> true or false
   # -->
-  # Returns `true` if `self` is `:''`, `false` otherwise.
+  # Returns `true` if `self` is <code>:''</code>, `false` otherwise.
   #
   def empty?: () -> bool
 
@@ -293,7 +300,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - encoding -> encoding
   # -->
-  # Equivalent to `self.to_s.encoding`; see String#encoding.
+  # Equivalent to <code>self.to_s.encoding</code>; see String#encoding.
   #
   def encoding: () -> Encoding
 
@@ -301,7 +308,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - end_with?(*strings) -> true or false
   # -->
-  # Equivalent to `self.to_s.end_with?`; see String#end_with?.
+  # Equivalent to <code>self.to_s.end_with?</code>; see String#end_with?.
   #
   def end_with?: (*string suffixes) -> bool
 
@@ -335,7 +342,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - length -> integer
   # -->
-  # Equivalent to `self.to_s.length`; see String#length.
+  # Equivalent to <code>self.to_s.length</code>; see String#length.
   #
   def length: () -> Integer
 
@@ -344,8 +351,8 @@ class Symbol
   #   - match(pattern, offset = 0) -> matchdata or nil
   #   - match(pattern, offset = 0) {|matchdata| } -> object
   # -->
-  # Equivalent to `self.to_s.match`, including possible updates to global
-  # variables; see String#match.
+  # Equivalent to <code>self.to_s.match</code>, including possible updates to
+  # global variables; see String#match.
   #
   def match: (Regexp | string pattern, ?int offset) -> MatchData?
            | [T] (Regexp | string pattern, ?int offset) { (MatchData matchdata) -> T } -> T?
@@ -354,12 +361,12 @@ class Symbol
   #   rdoc-file=string.c
   #   - match?(pattern, offset) -> true or false
   # -->
-  # Equivalent to `sym.to_s.match?`; see String#match.
+  # Equivalent to <code>sym.to_s.match?</code>; see String#match.
   #
   def match?: (Regexp | string pattern, ?int offset) -> bool
 
   # <!-- rdoc-file=string.c -->
-  # Equivalent to `self.to_s.succ.to_sym`:
+  # Equivalent to <code>self.to_s.succ.to_sym</code>:
   #
   #     :foo.succ # => :fop
   #
@@ -382,12 +389,12 @@ class Symbol
   def name: () -> String
 
   # <!-- rdoc-file=string.c -->
-  # Equivalent to `self.to_s.length`; see String#length.
+  # Equivalent to <code>self.to_s.length</code>; see String#length.
   #
   alias size length
 
   # <!-- rdoc-file=string.c -->
-  # Equivalent to `symbol.to_s[]`; see String#[].
+  # Equivalent to <code>symbol.to_s[]</code>; see String#[].
   #
   alias slice []
 
@@ -395,7 +402,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - start_with?(*string_or_regexp) -> true or false
   # -->
-  # Equivalent to `self.to_s.start_with?`; see String#start_with?.
+  # Equivalent to <code>self.to_s.start_with?</code>; see String#start_with?.
   #
   def start_with?: (*Regexp | string prefixes) -> bool
 
@@ -403,7 +410,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - succ
   # -->
-  # Equivalent to `self.to_s.succ.to_sym`:
+  # Equivalent to <code>self.to_s.succ.to_sym</code>:
   #
   #     :foo.succ # => :fop
   #
@@ -413,9 +420,9 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - swapcase(*options) -> symbol
+  #   - swapcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.swapcase.to_sym`.
+  # Equivalent to <code>sym.to_s.swapcase.to_sym</code>.
   #
   # See String#swapcase.
   #
@@ -462,9 +469,9 @@ class Symbol
 
   # <!--
   #   rdoc-file=string.c
-  #   - upcase(*options) -> symbol
+  #   - upcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.upcase.to_sym`.
+  # Equivalent to <code>sym.to_s.upcase.to_sym</code>.
   #
   # See String#upcase.
   #