rbs 3.3.2 → 3.4.0.pre.1

data/stdlib/logger/0/logger.rbs

@@ -245,8 +245,7 @@
 #     logger.error! # => 3
 #     logger.fatal! # => 4
 #
-# You can retrieve the log level with method
-# [level](Logger.html#attribute-i-level):
+# You can retrieve the log level with method #level.
 #
 #     logger.level = Logger::ERROR
 #     logger.level # => 3
@@ -619,7 +618,10 @@ class Logger
   #
   def info?: () -> bool
 
-  # <!-- rdoc-file=lib/logger.rb -->
+  # <!--
+  #   rdoc-file=lib/logger.rb
+  #   - level()
+  # -->
   # Logging severity threshold (e.g. `Logger::INFO`).
   #
   def level: () -> Integer
@@ -689,8 +691,10 @@ class Logger
   def reopen: () -> self
             | (logdev?) -> self
 
-  # <!-- rdoc-file=lib/logger.rb -->
-  # Logging severity threshold (e.g. `Logger::INFO`).
+  # <!--
+  #   rdoc-file=lib/logger.rb
+  #   - sev_threshold()
+  # -->
   #
   alias sev_threshold level
 

data/stdlib/monitor/0/monitor.rbs

@@ -109,6 +109,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