rbs 4.0.0.dev.5 → 4.0.1.dev.1

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
 #
@@ -119,13 +119,13 @@ 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>
@@ -133,7 +133,7 @@ class Struct[Elem]
   # **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)
@@ -483,8 +484,8 @@ 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"

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.
@@ -136,7 +137,7 @@ class Symbol
   #
   # Returns:
   #
-  # *   `self.to_s <=> other.to_s`, if `other` is a symbol.
+  # *   <code>self.to_s <=> other.to_s</code>, if `other` is a symbol.
   # *   `nil`, otherwise.
   #
   # Examples:
@@ -171,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
@@ -185,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?
@@ -196,7 +197,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - capitalize(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.capitalize.to_sym`.
+  # Equivalent to <code>sym.to_s.capitalize.to_sym</code>.
   #
   # See String#capitalize.
   #
@@ -210,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
@@ -276,7 +277,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - downcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.downcase.to_sym`.
+  # Equivalent to <code>sym.to_s.downcase.to_sym</code>.
   #
   # See String#downcase.
   #
@@ -291,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
 
@@ -299,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
 
@@ -307,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
 
@@ -341,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
 
@@ -350,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?
@@ -360,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
   #
@@ -388,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 []
 
@@ -401,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
 
@@ -409,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
   #
@@ -421,7 +422,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - swapcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.swapcase.to_sym`.
+  # Equivalent to <code>sym.to_s.swapcase.to_sym</code>.
   #
   # See String#swapcase.
   #
@@ -470,7 +471,7 @@ class Symbol
   #   rdoc-file=string.c
   #   - upcase(mapping) -> symbol
   # -->
-  # Equivalent to `sym.to_s.upcase.to_sym`.
+  # Equivalent to <code>sym.to_s.upcase.to_sym</code>.
   #
   # See String#upcase.
   #

data/core/thread.rbs

@@ -14,8 +14,8 @@
 #
 #     thr.join #=> "What's the big deal"
 #
-# If we don't call `thr.join` before the main thread terminates, then all other
-# threads including `thr` will be killed.
+# If we don't call <code>thr.join</code> before the main thread terminates, then
+# all other threads including `thr` will be killed.
 #
 # Alternatively, you can use an array for handling multiple threads at once,
 # like in the following example:
@@ -105,8 +105,8 @@
 #       p Thread.current.thread_variable_get(:foo)   # => 2
 #     }.join
 #
-# You can see that the thread-local `:foo` carried over into the fiber and was
-# changed to `2` by the end of the thread.
+# You can see that the thread-local <code>:foo</code> carried over into the
+# fiber and was changed to `2` by the end of the thread.
 #
 # This example makes use of #thread_variable_set to create new thread-locals,
 # and #thread_variable_get to reference them.
@@ -617,13 +617,13 @@ class Thread < Object
   # -->
   # Returns the status of `thr`.
   #
-  # `"sleep"`
+  # <code>"sleep"</code>
   # :   Returned if this thread is sleeping or waiting on I/O
   #
-  # `"run"`
+  # <code>"run"</code>
   # :   When this thread is executing
   #
-  # `"aborting"`
+  # <code>"aborting"</code>
   # :   If this thread is aborting
   #
   # `false`
@@ -769,7 +769,8 @@ class Thread < Object
   # Marks a given thread as eligible for scheduling, however it may still remain
   # blocked on I/O.
   #
-  # **Note:** This does not invoke the scheduler, see #run for more information.
+  # <strong>Note:</strong> This does not invoke the scheduler, see #run for more
+  # information.
   #
   #     c = Thread.new { Thread.stop; puts "hey!" }
   #     sleep 0.1 while c.status!='sleep'
@@ -790,7 +791,8 @@ class Thread < Object
   # When set to `true`, if any thread is aborted by an exception, the raised
   # exception will be re-raised in the main thread.
   #
-  # Can also be specified by the global $DEBUG flag or command line option `-d`.
+  # Can also be specified by the global $DEBUG flag or command line option
+  # <code>-d</code>.
   #
   # See also ::abort_on_exception=.
   #
@@ -872,17 +874,17 @@ class Thread < Object
   # Thread#raise, Thread#kill, signal trap (not supported yet) and main thread
   # termination (if main thread terminates, then all other thread will be killed).
   #
-  # The given `hash` has pairs like `ExceptionClass => :TimingSymbol`. Where the
-  # ExceptionClass is the interrupt handled by the given block. The TimingSymbol
-  # can be one of the following symbols:
+  # The given `hash` has pairs like <code>ExceptionClass => :TimingSymbol</code>.
+  # Where the ExceptionClass is the interrupt handled by the given block. The
+  # TimingSymbol can be one of the following symbols:
   #
-  # `:immediate`
+  # <code>:immediate</code>
   # :   Invoke interrupts immediately.
   #
-  # `:on_blocking`
+  # <code>:on_blocking</code>
   # :   Invoke interrupts while *BlockingOperation*.
   #
-  # `:never`
+  # <code>:never</code>
   # :   Never invoke all interrupts.
   #
   #
@@ -906,8 +908,8 @@ class Thread < Object
   #
   # In this example, we can guard from Thread#raise exceptions.
   #
-  # Using the `:never` TimingSymbol the RuntimeError exception will always be
-  # ignored in the first block of the main thread. In the second
+  # Using the <code>:never</code> TimingSymbol the RuntimeError exception will
+  # always be ignored in the first block of the main thread. In the second
   # ::handle_interrupt block we can purposefully handle RuntimeError exceptions.
   #
   #     th = Thread.new do
@@ -1030,7 +1032,8 @@ class Thread < Object
   # Since Thread::handle_interrupt can be used to defer asynchronous events, this
   # method can be used to determine if there are any deferred events.
   #
-  # If you find this method returns true, then you may finish `:never` blocks.
+  # If you find this method returns true, then you may finish <code>:never</code>
+  # blocks.
   #
   # For example, the following method processes deferred asynchronous events
   # immediately.
@@ -1108,9 +1111,9 @@ class Thread < Object
   #     where it is raised rather then let it kill the Thread.
   # *   If it is guaranteed the Thread will be joined with Thread#join or
   #     Thread#value, then it is safe to disable this report with
-  #     `Thread.current.report_on_exception = false` when starting the Thread.
-  #     However, this might handle the exception much later, or not at all if the
-  #     Thread is never joined due to the parent thread being blocked, etc.
+  #     <code>Thread.current.report_on_exception = false</code> when starting the
+  #     Thread. However, this might handle the exception much later, or not at all
+  #     if the Thread is never joined due to the parent thread being blocked, etc.
   #
   # See also ::report_on_exception=.
   #
@@ -1188,10 +1191,11 @@ class Thread::Backtrace < Object
   #   rdoc-file=vm_backtrace.c
   #   - Thread::Backtrace::limit -> integer
   # -->
-  # Returns maximum backtrace length set by `--backtrace-limit` command-line
-  # option. The default is `-1` which means unlimited backtraces. If the value is
-  # zero or positive, the error backtraces, produced by Exception#full_message,
-  # are abbreviated and the extra lines are replaced by `... 3 levels... `
+  # Returns maximum backtrace length set by <code>--backtrace-limit</code>
+  # command-line option. The default is <code>-1</code> which means unlimited
+  # backtraces. If the value is zero or positive, the error backtraces, produced
+  # by Exception#full_message, are abbreviated and the extra lines are replaced by
+  # <code>... 3 levels... </code>
   #
   #     $ ruby -r net/http -e "p Thread::Backtrace.limit; Net::HTTP.get(URI('http://wrong.address'))"
   #     - 1
@@ -1257,7 +1261,7 @@ end
 #       puts call.to_s
 #     end
 #
-# Running `ruby caller_locations.rb` will produce:
+# Running <code>ruby caller_locations.rb</code> will produce:
 #
 #     caller_locations.rb:2:in `a'
 #     caller_locations.rb:5:in `b'
@@ -1277,7 +1281,7 @@ end
 #       puts call.to_s
 #     end
 #
-# Now run `ruby foo.rb` and you should see:
+# Now run <code>ruby foo.rb</code> and you should see:
 #
 #     init.rb:4:in `initialize'
 #     init.rb:8:in `new'
@@ -1360,7 +1364,8 @@ class Thread::Backtrace::Location
   # -->
   # Returns the line number of this frame.
   #
-  # For example, using `caller_locations.rb` from Thread::Backtrace::Location
+  # For example, using <code>caller_locations.rb</code> from
+  # Thread::Backtrace::Location
   #
   #     loc = c(0..1).first
   #     loc.lineno #=> 2
@@ -1375,7 +1380,8 @@ class Thread::Backtrace::Location
   # unless the frame is in the main script, in which case it will be the script
   # location passed on the command line.
   #
-  # For example, using `caller_locations.rb` from Thread::Backtrace::Location
+  # For example, using <code>caller_locations.rb</code> from
+  # Thread::Backtrace::Location
   #
   #     loc = c(0..1).first
   #     loc.path #=> caller_locations.rb
@@ -1620,16 +1626,16 @@ class Thread::Queue[Elem = untyped] < Object
   #
   # After the call to close completes, the following are true:
   #
-  # *   `closed?` will return true
+  # *   <code>closed?</code> will return true
   #
   # *   `close` will be ignored.
   #
   # *   calling enq/push/<< will raise a `ClosedQueueError`.
   #
-  # *   when `empty?` is false, calling deq/pop/shift will return an object from
-  #     the queue as usual.
-  # *   when `empty?` is true, deq(false) will not suspend the thread and will
-  #     return nil. deq(true) will raise a `ThreadError`.
+  # *   when <code>empty?</code> is false, calling deq/pop/shift will return an
+  #     object from the queue as usual.
+  # *   when <code>empty?</code> is true, deq(false) will not suspend the thread
+  #     and will return nil. deq(true) will raise a `ThreadError`.
   #
   # ClosedQueueError is inherited from StopIteration, so that you can break loop
   # block.