rbs 2.8.4 → 3.8.1

data/stdlib/monitor/0/monitor.rbs

@@ -10,19 +10,19 @@
 #     end
 #
 class Monitor
-  public
-
   # <!--
   #   rdoc-file=ext/monitor/monitor.c
-  #   - enter()
+  #   - enter -> nil
   # -->
+  # Enters exclusive section.
   #
   def enter: () -> nil
 
   # <!--
   #   rdoc-file=ext/monitor/monitor.c
-  #   - exit()
+  #   - exit -> nil
   # -->
+  # Leaves exclusive section.
   #
   def exit: () -> nil
 
@@ -79,20 +79,25 @@ class Monitor
   #   rdoc-file=ext/monitor/lib/monitor.rb
   #   - new_cond()
   # -->
+  # Creates a new MonitorMixin::ConditionVariable associated with the Monitor
+  # object.
   #
   def new_cond: () -> ::MonitorMixin::ConditionVariable
 
   # <!--
   #   rdoc-file=ext/monitor/monitor.c
-  #   - synchronize()
+  #   - synchronize { } -> result of the block
   # -->
+  # Enters exclusive section and executes the block.  Leaves the exclusive section
+  # automatically when the block exits.  See example under `MonitorMixin`.
   #
   def synchronize: [T] () { () -> T } -> T
 
   # <!--
   #   rdoc-file=ext/monitor/monitor.c
-  #   - try_enter()
+  #   - try_enter -> true or false
   # -->
+  # Attempts to enter exclusive section.  Returns `false` if lock fails.
   #
   def try_enter: () -> bool
 
@@ -109,6 +114,84 @@ class Monitor
   def wait_for_cond: (::MonitorMixin::ConditionVariable, Numeric? timeout) -> untyped
 end
 
+# <!-- rdoc-file=ext/monitor/lib/monitor.rb -->
+# In concurrent programming, a monitor is an object or module intended to be
+# used safely by more than one thread. The defining characteristic of a monitor
+# is that its methods are executed with mutual exclusion. That is, at each point
+# in time, at most one thread may be executing any of its methods. This mutual
+# exclusion greatly simplifies reasoning about the implementation of monitors
+# compared to reasoning about parallel code that updates a data structure.
+#
+# You can read more about the general principles on the Wikipedia page for
+# [Monitors](https://en.wikipedia.org/wiki/Monitor_%28synchronization%29).
+#
+# ## Examples
+#
+# ### Simple object.extend
+#
+#     require 'monitor.rb'
+#
+#     buf = []
+#     buf.extend(MonitorMixin)
+#     empty_cond = buf.new_cond
+#
+#     # consumer
+#     Thread.start do
+#       loop do
+#         buf.synchronize do
+#           empty_cond.wait_while { buf.empty? }
+#           print buf.shift
+#         end
+#       end
+#     end
+#
+#     # producer
+#     while line = ARGF.gets
+#       buf.synchronize do
+#         buf.push(line)
+#         empty_cond.signal
+#       end
+#     end
+#
+# The consumer thread waits for the producer thread to push a line to buf while
+# `buf.empty?`. The producer thread (main thread) reads a line from ARGF and
+# pushes it into buf then calls `empty_cond.signal` to notify the consumer
+# thread of new data.
+#
+# ### Simple Class include
+#
+#     require 'monitor'
+#
+#     class SynchronizedArray < Array
+#
+#       include MonitorMixin
+#
+#       def initialize(*args)
+#         super(*args)
+#       end
+#
+#       alias :old_shift :shift
+#       alias :old_unshift :unshift
+#
+#       def shift(n=1)
+#         self.synchronize do
+#           self.old_shift(n)
+#         end
+#       end
+#
+#       def unshift(item)
+#         self.synchronize do
+#           self.old_unshift(item)
+#         end
+#       end
+#
+#       # other methods ...
+#     end
+#
+# `SynchronizedArray` implements an Array with synchronized access to items.
+# This Class is implemented as subclass of Array which includes the MonitorMixin
+# module.
+#
 module MonitorMixin
   # <!--
   #   rdoc-file=ext/monitor/lib/monitor.rb
@@ -117,8 +200,6 @@ module MonitorMixin
   #
   def self.extend_object: (untyped obj) -> untyped
 
-  public
-
   # <!--
   #   rdoc-file=ext/monitor/lib/monitor.rb
   #   - mon_enter()
@@ -205,6 +286,8 @@ module MonitorMixin
   #   rdoc-file=ext/monitor/lib/monitor.rb
   #   - mon_check_owner()
   # -->
+  # Ensures that the MonitorMixin is owned by the current thread, otherwise raises
+  # an exception.
   #
   def mon_check_owner: () -> nil
 
@@ -225,8 +308,6 @@ end
 # calls while_wait and signal, this class should be documented.
 #
 class MonitorMixin::ConditionVariable
-  public
-
   # <!--
   #   rdoc-file=ext/monitor/lib/monitor.rb
   #   - broadcast()

data/stdlib/mutex_m/0/mutex_m.rbs

@@ -34,8 +34,6 @@ module Mutex_m
 
   def self.extend_object: (Object obj) -> untyped
 
-  public
-
   def mu_extended: () -> untyped
 
   # <!--

data/stdlib/net-http/0/manifest.yaml

@@ -1,3 +1,3 @@
 dependencies:
+  - name: net-protocol
   - name: uri
-  - name: timeout