persistent-dmnd 1.0.0 → 2.0.0

data/lib/persistent_dmnd/jruby_workaround.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# typed: false
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
 # Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
@@ -31,8 +32,7 @@
 
 module Persistent💎
   module JRubyWorkaround
-    if RUBY_PLATFORM == 'java' # Only supposed to do something on JRuby
-
+    if RUBY_PLATFORM == 'java' && JRUBY_VERSION < "9.2.0.0" # Only supposed to do something on legacy JRuby versions
       BROKEN_ENCODING = "\x00"
       private_constant :BROKEN_ENCODING
 
@@ -58,7 +58,7 @@ module Persistent💎
 
       # Workaround JRuby encoding bug
       # See https://github.com/jruby/jruby/issues/4878
-      # and https://github.com/ivoanjo/persistent-dmnd/issues/5
+      # and https://gitlab.com/ivoanjo/persistent-dmnd/issues/5
       #
       # The trick here is that on JRuby, methods with emojis in the name are defined, but the resulting name is mangled
       # so instead of for instance #to_💎 the result is #to_?\x00. (Or #💎ify will become #?ify\x00.) This behavior is
@@ -83,8 +83,8 @@ module Persistent💎
 
         if JRUBY_VERSION.start_with?('1.7.')
           unless name_string.match(/\?.+/) ||
-            ['a?', 'h?', 's?', 'each?'].include?(name_string) ||
-            ['_?', '_a?', '_h?', '_s?'].any? { |suffix| name_string.end_with?(suffix) }
+                 ['a?', 'h?', 's?', 'each?'].include?(name_string) ||
+                 ['_?', '_a?', '_h?', '_s?'].any? { |suffix| name_string.end_with?(suffix) }
             return
           end
         else

data/lib/persistent_dmnd/ruby_1_9_and_2_0_support.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# typed: true
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
 # Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>

data/lib/persistent_dmnd/self_conversion.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# typed: true
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
 # Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
@@ -39,6 +40,7 @@ module Persistent💎
     def to_💎
       self
     end
+
     alias_method :to_dmnd, :to_💎
   end
 end

data/lib/persistent_dmnd/set.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# typed: true
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
 # Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
@@ -33,6 +34,7 @@ require 'persistent_dmnd/self_conversion'
 require 'persistent_dmnd/is_persistent'
 require 'persistent_dmnd/concurrent_ruby_support'
 require 'persistent_dmnd/jruby_workaround'
+require 'persistent_dmnd/jruby_9_2_set_workaround'
 
 require 'hamster'
 require 'set'
@@ -63,24 +65,35 @@ module Persistent💎
       ::Set.new(self)
     end
 
-    # Default behavior from Kernel#<=>
+    # Note: Behavior changed from Ruby < 3 (returned 0/nil) to match Ruby 3.0 Set#<=> (returns 0/nil/-1/+1);
+    #       see also https://rubyreferences.github.io/rubychanges/3.0.html#standard-library for details
     def <=>(other)
-      self == other ? 0 : nil
+      case size <=> other.size
+      when (-1)
+        (-1) if self < other
+      when (+1)
+        (+1) if self > other
+      else
+        0 if self == other
+      end
     end
 
     def to_a💎
       a💎[*self]
     end
+
     alias_method :to_aDmnd, :to_a💎
 
     def to_h💎
       h💎[self]
     end
+
     alias_method :to_hDmnd, :to_h💎
 
     def to_s💎
       self
     end
+
     alias_method :to_sDmnd, :to_s💎
 
     private

data/lib/persistent_dmnd/version.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# typed: strong
 
 # Persistent-💎: Ruby gem for easily creating immutable data structures
 # Copyright (c) 2017 Ivo Anjo <ivo.anjo@ist.utl.pt>
@@ -30,5 +31,5 @@
 # frozen_string_literal: true
 
 module Persistent💎
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/persistent-dmnd.gemspec

@@ -37,11 +37,11 @@ Gem::Specification.new do |spec|
   spec.name          = 'persistent-dmnd'
   spec.version       = Persistent💎::VERSION
   spec.authors       = 'Ivo Anjo'
-  spec.email         = 'ivo.anjo@ist.utl.pt'
+  spec.email         = 'ivo@ivoanjo.me'
 
   spec.summary       = 'Persistent-💎: Because Immutable Data Is Forever'
   spec.description   = 'A tiny ruby gem that gives you a beautiful short-hand syntax for creating immutable arrays, hashes and sets'
-  spec.homepage      = 'https://github.com/ivoanjo/persistent-dmnd/'
+  spec.homepage      = 'https://gitlab.com/ivoanjo/persistent-dmnd/'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -51,13 +51,15 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9.3'
 
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'rake', '~> 12.2'
-  spec.add_development_dependency 'rspec', '~> 3.7'
-  spec.add_development_dependency 'concurrent-ruby', '~> 1.0'
-  spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'pry-byebug' unless RUBY_PLATFORM == 'java' || RUBY_VERSION.start_with?('1.9.')
-  spec.add_development_dependency 'pry-debugger-jruby' if RUBY_PLATFORM == 'java' && !JRUBY_VERSION.start_with?('1.7.')
+  spec.add_development_dependency 'bundler', '~> 1.16' if RUBY_VERSION < '2.7'
+  spec.add_development_dependency 'rake', '~> 12.2' # Note: Rake 12.2 is the last that supports Ruby 1.9
+  spec.add_development_dependency 'rspec', '~> 3.8'
+  spec.add_development_dependency 'concurrent-ruby', '~> 1.1'
+  spec.add_development_dependency 'rufo', '~> 0.7' if RUBY_VERSION >= '2.4.5'
+  spec.add_development_dependency 'pry' if RUBY_VERSION >= '2.0.0'
+  spec.add_development_dependency 'pry-byebug' if RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '2.4'
+  spec.add_development_dependency 'pry-debugger-jruby' if RUBY_ENGINE == 'jruby' && !JRUBY_VERSION.start_with?('1.7.')
+  spec.add_development_dependency 'sorbet' if RUBY_VERSION < '2.7'
 
   spec.add_dependency 'hamster', '~> 3.0'
 end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/concurrent-ruby.rbi

@@ -0,0 +1,1587 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/concurrent-ruby/all/concurrent-ruby.rbi
+#
+# concurrent-ruby-1.1.5
+module Concurrent
+  def abort_transaction; end
+  def atomically; end
+  def call_dataflow(method, executor, *inputs, &block); end
+  def dataflow!(*inputs, &block); end
+  def dataflow(*inputs, &block); end
+  def dataflow_with!(executor, *inputs, &block); end
+  def dataflow_with(executor, *inputs, &block); end
+  def leave_transaction; end
+  def monotonic_time; end
+  def self.abort_transaction; end
+  def self.atomically; end
+  def self.call_dataflow(method, executor, *inputs, &block); end
+  def self.create_simple_logger(level = nil, output = nil); end
+  def self.create_stdlib_logger(level = nil, output = nil); end
+  def self.dataflow!(*inputs, &block); end
+  def self.dataflow(*inputs, &block); end
+  def self.dataflow_with!(executor, *inputs, &block); end
+  def self.dataflow_with(executor, *inputs, &block); end
+  def self.disable_at_exit_handlers!; end
+  def self.executor(executor_identifier); end
+  def self.global_fast_executor; end
+  def self.global_immediate_executor; end
+  def self.global_io_executor; end
+  def self.global_logger; end
+  def self.global_logger=(value); end
+  def self.global_timer_set; end
+  def self.leave_transaction; end
+  def self.monotonic_time; end
+  def self.new_fast_executor(opts = nil); end
+  def self.new_io_executor(opts = nil); end
+  def self.physical_processor_count; end
+  def self.processor_count; end
+  def self.processor_counter; end
+  def self.use_simple_logger(level = nil, output = nil); end
+  def self.use_stdlib_logger(level = nil, output = nil); end
+  extend Concurrent::Concern::Logging
+  extend Concurrent::Utility::EngineDetector
+  extend Concurrent::Utility::NativeExtensionLoader
+end
+module Concurrent::Utility
+end
+module Concurrent::Utility::EngineDetector
+  def on_cruby?; end
+  def on_jruby?; end
+  def on_jruby_9000?; end
+  def on_linux?; end
+  def on_osx?; end
+  def on_rbx?; end
+  def on_truffleruby?; end
+  def on_windows?; end
+  def ruby_engine; end
+  def ruby_version(version = nil, comparison, major, minor, patch); end
+end
+module Concurrent::Synchronization
+end
+class Concurrent::Synchronization::AbstractObject
+  def full_memory_barrier; end
+  def initialize; end
+  def self.attr_volatile(*names); end
+end
+module Concurrent::Utility::NativeExtensionLoader
+  def allow_c_extensions?; end
+  def c_extensions_loaded?; end
+  def java_extensions_loaded?; end
+  def load_error_path(error); end
+  def load_native_extensions; end
+  def set_c_extensions_loaded; end
+  def set_java_extensions_loaded; end
+  def try_load_c_extension(path); end
+end
+module Concurrent::Synchronization::MriAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::MriAttrVolatile
+end
+module Concurrent::Synchronization::RbxAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::RbxAttrVolatile
+end
+module Concurrent::Synchronization::TruffleRubyAttrVolatile
+  def full_memory_barrier; end
+  def self.included(base); end
+end
+module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
+  def attr_volatile(*names); end
+end
+class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject
+  def initialize; end
+  extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
+  include Concurrent::Synchronization::TruffleRubyAttrVolatile
+end
+class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject
+  def __initialize_atomic_fields__; end
+  def initialize; end
+  def self.atomic_attribute?(name); end
+  def self.atomic_attributes(inherited = nil); end
+  def self.attr_atomic(*names); end
+  def self.define_initialize_atomic_fields; end
+  def self.ensure_safe_initialization_when_final_fields_are_present; end
+  def self.safe_initialization!; end
+  def self.safe_initialization?; end
+end
+class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def synchronize; end
+end
+module Concurrent::Synchronization::ConditionSignalling
+  def ns_broadcast; end
+  def ns_signal; end
+end
+class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize; end
+  include Concurrent::Synchronization::ConditionSignalling
+end
+class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize; end
+  include Concurrent::Synchronization::ConditionSignalling
+end
+class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject
+  def initialize(*defaults); end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def self.new(*args, &block); end
+  def synchronize(&block); end
+end
+class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject
+  def new_condition; end
+end
+class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject
+  def broadcast; end
+  def initialize(lock); end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def self.new(*args, &block); end
+  def self.private_new(*args, &block); end
+  def signal; end
+  def wait(timeout = nil); end
+  def wait_until(timeout = nil, &condition); end
+end
+class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject
+  def broadcast; end
+  def ns_broadcast; end
+  def ns_signal; end
+  def ns_wait(timeout = nil); end
+  def ns_wait_until(timeout = nil, &condition); end
+  def signal; end
+  def synchronize; end
+  def wait(timeout = nil); end
+  def wait_until(timeout = nil, &condition); end
+end
+module Concurrent::AtomicNumericCompareAndSetWrapper
+  def compare_and_set(old_value, new_value); end
+end
+class Concurrent::MutexAtomicReference < Concurrent::Synchronization::LockableObject
+  def _compare_and_set(old_value, new_value); end
+  def compare_and_swap(old_value, new_value); end
+  def get; end
+  def get_and_set(new_value); end
+  def initialize(value = nil); end
+  def ns_initialize(value); end
+  def set(new_value); end
+  def swap(new_value); end
+  def value; end
+  def value=(new_value); end
+  include Concurrent::AtomicDirectUpdate
+  include Concurrent::AtomicNumericCompareAndSetWrapper
+end
+module Concurrent::AtomicDirectUpdate
+  def try_update!; end
+  def try_update; end
+  def update; end
+end
+class Concurrent::ConcurrentUpdateError < ThreadError
+end
+class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
+  def inspect; end
+  def to_s; end
+end
+class Concurrent::MutexAtomicBoolean < Concurrent::Synchronization::LockableObject
+  def false?; end
+  def initialize(initial = nil); end
+  def make_false; end
+  def make_true; end
+  def ns_initialize(initial); end
+  def ns_make_value(value); end
+  def true?; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::AtomicBoolean < Concurrent::MutexAtomicBoolean
+  def inspect; end
+  def to_s; end
+end
+module Concurrent::Utility::NativeInteger
+  def ensure_integer(value); end
+  def ensure_integer_and_bounds(value); end
+  def ensure_lower_bound(value); end
+  def ensure_positive(value); end
+  def ensure_positive_and_no_zero(value); end
+  def ensure_upper_bound(value); end
+  extend Concurrent::Utility::NativeInteger
+end
+class Concurrent::MutexAtomicFixnum < Concurrent::Synchronization::LockableObject
+  def compare_and_set(expect, update); end
+  def decrement(delta = nil); end
+  def down(delta = nil); end
+  def increment(delta = nil); end
+  def initialize(initial = nil); end
+  def ns_initialize(initial); end
+  def ns_set(value); end
+  def up(delta = nil); end
+  def update; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::AtomicFixnum < Concurrent::MutexAtomicFixnum
+  def inspect; end
+  def to_s; end
+end
+class Concurrent::CyclicBarrier < Concurrent::Synchronization::LockableObject
+  def broken?; end
+  def initialize(parties, &block); end
+  def ns_generation_done(generation, status, continue = nil); end
+  def ns_initialize(parties, &block); end
+  def ns_next_generation; end
+  def number_waiting; end
+  def parties; end
+  def reset; end
+  def wait(timeout = nil); end
+end
+class Concurrent::CyclicBarrier::Generation < Struct
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def status; end
+  def status=(_); end
+end
+class Concurrent::MutexCountDownLatch < Concurrent::Synchronization::LockableObject
+  def count; end
+  def count_down; end
+  def initialize(count = nil); end
+  def ns_initialize(count); end
+  def wait(timeout = nil); end
+end
+class Concurrent::CountDownLatch < Concurrent::MutexCountDownLatch
+end
+class Concurrent::Event < Concurrent::Synchronization::LockableObject
+  def initialize; end
+  def ns_initialize; end
+  def ns_set; end
+  def reset; end
+  def set; end
+  def set?; end
+  def try?; end
+  def wait(timeout = nil); end
+end
+class Concurrent::Error < StandardError
+end
+class Concurrent::ConfigurationError < Concurrent::Error
+end
+class Concurrent::CancelledOperationError < Concurrent::Error
+end
+class Concurrent::LifecycleError < Concurrent::Error
+end
+class Concurrent::ImmutabilityError < Concurrent::Error
+end
+class Concurrent::IllegalOperationError < Concurrent::Error
+end
+class Concurrent::InitializationError < Concurrent::Error
+end
+class Concurrent::MaxRestartFrequencyError < Concurrent::Error
+end
+class Concurrent::MultipleAssignmentError < Concurrent::Error
+  def initialize(message = nil, inspection_data = nil); end
+  def inspect; end
+  def inspection_data; end
+end
+class Concurrent::RejectedExecutionError < Concurrent::Error
+end
+class Concurrent::ResourceLimitError < Concurrent::Error
+end
+class Concurrent::TimeoutError < Concurrent::Error
+end
+class Concurrent::MultipleErrors < Concurrent::Error
+  def errors; end
+  def initialize(errors, message = nil); end
+end
+class Concurrent::ReadWriteLock < Concurrent::Synchronization::Object
+  def acquire_read_lock; end
+  def acquire_write_lock; end
+  def has_waiters?; end
+  def initialize; end
+  def max_readers?(c = nil); end
+  def max_writers?(c = nil); end
+  def release_read_lock; end
+  def release_write_lock; end
+  def running_readers(c = nil); end
+  def running_readers?(c = nil); end
+  def running_writer?(c = nil); end
+  def self.new(*args, &block); end
+  def waiting_writer?(c = nil); end
+  def waiting_writers(c = nil); end
+  def with_read_lock; end
+  def with_write_lock; end
+  def write_locked?; end
+end
+class Concurrent::AbstractThreadLocalVar
+  def allocate_storage; end
+  def bind(value, &block); end
+  def default; end
+  def initialize(default = nil, &default_block); end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::RubyThreadLocalVar < Concurrent::AbstractThreadLocalVar
+  def allocate_storage; end
+  def default_for(thread); end
+  def get_threadlocal_array(thread = nil); end
+  def self.thread_finalizer(array); end
+  def self.threadlocal_finalizer(index); end
+  def set_threadlocal_array(array, thread = nil); end
+  def value; end
+  def value=(value); end
+  def value_for(thread); end
+end
+class Concurrent::ThreadLocalVar < Concurrent::RubyThreadLocalVar
+end
+class Concurrent::ReentrantReadWriteLock < Concurrent::Synchronization::Object
+  def acquire_read_lock; end
+  def acquire_write_lock; end
+  def initialize; end
+  def max_readers?(c = nil); end
+  def max_writers?(c = nil); end
+  def release_read_lock; end
+  def release_write_lock; end
+  def running_readers(c = nil); end
+  def running_readers?(c = nil); end
+  def running_writer?(c = nil); end
+  def self.new(*args, &block); end
+  def try_read_lock; end
+  def try_write_lock; end
+  def waiting_or_running_writer?(c = nil); end
+  def waiting_writers(c = nil); end
+  def with_read_lock; end
+  def with_write_lock; end
+end
+class Concurrent::MutexSemaphore < Concurrent::Synchronization::LockableObject
+  def acquire(permits = nil); end
+  def available_permits; end
+  def drain_permits; end
+  def initialize(count); end
+  def ns_initialize(count); end
+  def reduce_permits(reduction); end
+  def release(permits = nil); end
+  def try_acquire(permits = nil, timeout = nil); end
+  def try_acquire_now(permits); end
+  def try_acquire_timed(permits, timeout); end
+end
+class Concurrent::Semaphore < Concurrent::MutexSemaphore
+end
+module Concurrent::Concern
+end
+module Concurrent::Concern::Dereferenceable
+  def apply_deref_options(value); end
+  def deref; end
+  def ns_set_deref_options(opts); end
+  def set_deref_options(opts = nil); end
+  def value; end
+  def value=(value); end
+end
+module Concurrent::Concern::Obligation
+  def compare_and_set_state(next_state, *expected_current); end
+  def complete?; end
+  def event; end
+  def exception(*args); end
+  def fulfilled?; end
+  def get_arguments_from(opts = nil); end
+  def if_state(*expected_states); end
+  def incomplete?; end
+  def init_obligation; end
+  def no_error!(timeout = nil); end
+  def ns_check_state?(expected); end
+  def ns_set_state(value); end
+  def pending?; end
+  def realized?; end
+  def reason; end
+  def rejected?; end
+  def set_state(success, value, reason); end
+  def state; end
+  def state=(value); end
+  def unscheduled?; end
+  def value!(timeout = nil); end
+  def value(timeout = nil); end
+  def wait!(timeout = nil); end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Dereferenceable
+end
+module Concurrent::Concern::Logging
+  def log(level, progname, message = nil, &block); end
+  include Logger::Severity
+end
+module Concurrent::ExecutorService
+  def <<(task); end
+  def can_overflow?; end
+  def post(*args, &task); end
+  def serialized?; end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::AtExitImplementation < Concurrent::Synchronization::LockableObject
+  def add(handler_id = nil, &handler); end
+  def delete(handler_id); end
+  def enabled=(value); end
+  def enabled?; end
+  def handler?(handler_id); end
+  def handlers; end
+  def initialize(*args); end
+  def install; end
+  def ns_initialize(enabled = nil); end
+  def run; end
+  def runner; end
+  include Logger::Severity
+end
+class Concurrent::AbstractExecutorService < Concurrent::Synchronization::LockableObject
+  def auto_terminate=(value); end
+  def auto_terminate?; end
+  def fallback_policy; end
+  def handle_fallback(*args); end
+  def initialize(*args, &block); end
+  def kill; end
+  def ns_auto_terminate=(value); end
+  def ns_auto_terminate?; end
+  def ns_execute(*args, &task); end
+  def ns_kill_execution; end
+  def ns_shutdown_execution; end
+  def running?; end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def terminate_at_exit; end
+  def wait_for_termination(timeout = nil); end
+  include Concurrent::ExecutorService
+end
+module Concurrent::SerialExecutorService
+  def serialized?; end
+  include Concurrent::ExecutorService
+end
+class Concurrent::ImmediateExecutor < Concurrent::AbstractExecutorService
+  def <<(task); end
+  def initialize; end
+  def kill; end
+  def post(*args, &task); end
+  def running?; end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def wait_for_termination(timeout = nil); end
+  include Concurrent::SerialExecutorService
+end
+class Concurrent::Delay < Concurrent::Synchronization::LockableObject
+  def execute_task_once; end
+  def initialize(opts = nil, &block); end
+  def ns_initialize(opts, &block); end
+  def reconfigure(&block); end
+  def value!(timeout = nil); end
+  def value(timeout = nil); end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Obligation
+end
+class Concurrent::RubyExecutorService < Concurrent::AbstractExecutorService
+  def initialize(*args, &block); end
+  def kill; end
+  def ns_running?; end
+  def ns_shutdown?; end
+  def ns_shutdown_execution; end
+  def ns_shuttingdown?; end
+  def post(*args, &task); end
+  def shutdown; end
+  def stop_event; end
+  def stopped_event; end
+  def wait_for_termination(timeout = nil); end
+end
+class Concurrent::RubyThreadPoolExecutor < Concurrent::RubyExecutorService
+  def can_overflow?; end
+  def completed_task_count; end
+  def idletime; end
+  def initialize(opts = nil); end
+  def largest_length; end
+  def length; end
+  def max_length; end
+  def max_queue; end
+  def min_length; end
+  def ns_add_busy_worker; end
+  def ns_assign_worker(*args, &task); end
+  def ns_enqueue(*args, &task); end
+  def ns_execute(*args, &task); end
+  def ns_initialize(opts); end
+  def ns_kill_execution; end
+  def ns_limited_queue?; end
+  def ns_prune_pool; end
+  def ns_ready_worker(worker, success = nil); end
+  def ns_remove_busy_worker(worker); end
+  def ns_reset_if_forked; end
+  def ns_shutdown_execution; end
+  def ns_worker_died(worker); end
+  def ns_worker_not_old_enough(worker); end
+  def queue_length; end
+  def ready_worker(worker); end
+  def remaining_capacity; end
+  def remove_busy_worker(worker); end
+  def scheduled_task_count; end
+  def worker_died(worker); end
+  def worker_not_old_enough(worker); end
+  def worker_task_completed; end
+end
+class Concurrent::RubyThreadPoolExecutor::Worker
+  def <<(message); end
+  def create_worker(queue, pool, idletime); end
+  def initialize(pool); end
+  def kill; end
+  def run_task(pool, task, args); end
+  def stop; end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::ThreadPoolExecutor < Concurrent::RubyThreadPoolExecutor
+end
+class Concurrent::CachedThreadPool < Concurrent::ThreadPoolExecutor
+  def initialize(opts = nil); end
+  def ns_initialize(opts); end
+end
+class Concurrent::Utility::ProcessorCounter
+  def compute_physical_processor_count; end
+  def compute_processor_count; end
+  def initialize; end
+  def physical_processor_count; end
+  def processor_count; end
+end
+class Concurrent::FixedThreadPool < Concurrent::ThreadPoolExecutor
+  def initialize(num_threads, opts = nil); end
+end
+class Concurrent::SimpleExecutorService < Concurrent::RubyExecutorService
+  def <<(task); end
+  def kill; end
+  def ns_initialize; end
+  def post(*args, &task); end
+  def running?; end
+  def self.<<(task); end
+  def self.post(*args); end
+  def shutdown; end
+  def shutdown?; end
+  def shuttingdown?; end
+  def wait_for_termination(timeout = nil); end
+end
+class Concurrent::IndirectImmediateExecutor < Concurrent::ImmediateExecutor
+  def initialize; end
+  def post(*args, &task); end
+end
+class Concurrent::RubySingleThreadExecutor < Concurrent::RubyThreadPoolExecutor
+  def initialize(opts = nil); end
+end
+class Concurrent::SafeTaskExecutor < Concurrent::Synchronization::LockableObject
+  def execute(*args); end
+  def initialize(task, opts = nil); end
+end
+class Concurrent::SerializedExecution < Concurrent::Synchronization::LockableObject
+  def call_job(job); end
+  def initialize; end
+  def ns_initialize; end
+  def post(executor, *args, &task); end
+  def posts(posts); end
+  def work(job); end
+  include Concurrent::Concern::Logging
+end
+class Concurrent::SerializedExecution::Job < Struct
+  def args; end
+  def args=(_); end
+  def block; end
+  def block=(_); end
+  def call; end
+  def executor; end
+  def executor=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Concurrent::SerializedExecutionDelegator < SimpleDelegator
+  def initialize(executor); end
+  def post(*args, &task); end
+  include Concurrent::SerialExecutorService
+end
+class Concurrent::SingleThreadExecutor < Concurrent::RubySingleThreadExecutor
+end
+module Concurrent::Collection
+end
+class Concurrent::Collection::CopyOnWriteObserverSet < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def clear_observers_and_return_old; end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def initialize; end
+  def notify_and_delete_observers(*args, &block); end
+  def notify_observers(*args, &block); end
+  def notify_to(observers, *args); end
+  def ns_initialize; end
+  def observers; end
+  def observers=(new_set); end
+end
+class Concurrent::Collection::CopyOnNotifyObserverSet < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def duplicate_and_clear_observers; end
+  def duplicate_observers; end
+  def initialize; end
+  def notify_and_delete_observers(*args, &block); end
+  def notify_observers(*args, &block); end
+  def notify_to(observers, *args); end
+  def ns_initialize; end
+end
+module Concurrent::Concern::Observable
+  def add_observer(observer = nil, func = nil, &block); end
+  def count_observers; end
+  def delete_observer(observer); end
+  def delete_observers; end
+  def observers; end
+  def observers=(arg0); end
+  def with_observer(observer = nil, func = nil, &block); end
+end
+class Concurrent::IVar < Concurrent::Synchronization::LockableObject
+  def add_observer(observer = nil, func = nil, &block); end
+  def check_for_block_or_value!(block_given, value); end
+  def complete(success, value, reason); end
+  def complete_without_notification(success, value, reason); end
+  def fail(reason = nil); end
+  def initialize(value = nil, opts = nil, &block); end
+  def notify_observers(value, reason); end
+  def ns_complete_without_notification(success, value, reason); end
+  def ns_initialize(value, opts); end
+  def safe_execute(task, args = nil); end
+  def set(value = nil); end
+  def try_set(value = nil, &block); end
+  include Concurrent::Concern::Obligation
+  include Concurrent::Concern::Observable
+end
+module Concurrent::Options
+  def self.executor(executor_identifier); end
+  def self.executor_from_options(opts = nil); end
+end
+class Concurrent::ScheduledTask < Concurrent::IVar
+  def <=>(other); end
+  def cancel; end
+  def cancelled?; end
+  def execute; end
+  def executor; end
+  def fail(reason = nil); end
+  def initial_delay; end
+  def initialize(delay, opts = nil, &task); end
+  def ns_reschedule(delay); end
+  def ns_schedule(delay); end
+  def process_task; end
+  def processing?; end
+  def reschedule(delay); end
+  def reset; end
+  def schedule_time; end
+  def self.execute(delay, opts = nil, &task); end
+  def set(value = nil); end
+  def try_set(value = nil, &block); end
+  include Comparable
+end
+class Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  def <<(item); end
+  def clear; end
+  def delete(item); end
+  def deq; end
+  def empty?; end
+  def enq(item); end
+  def has_priority?(item); end
+  def include?(item); end
+  def initialize(opts = nil); end
+  def length; end
+  def ordered?(x, y); end
+  def peek; end
+  def pop; end
+  def push(item); end
+  def self.from_list(list, opts = nil); end
+  def shift; end
+  def sink(k); end
+  def size; end
+  def swap(x, y); end
+  def swim(k); end
+end
+class Concurrent::Collection::NonConcurrentPriorityQueue < Concurrent::Collection::RubyNonConcurrentPriorityQueue
+  def <<(item); end
+  def deq; end
+  def enq(item); end
+  def has_priority?(item); end
+  def shift; end
+  def size; end
+end
+class Concurrent::TimerSet < Concurrent::RubyExecutorService
+  def <<(task); end
+  def initialize(opts = nil); end
+  def kill; end
+  def ns_initialize(opts); end
+  def ns_post_task(task); end
+  def ns_reset_if_forked; end
+  def ns_shutdown_execution; end
+  def post(delay, *args, &task); end
+  def post_task(task); end
+  def process_tasks; end
+  def remove_task(task); end
+end
+class Concurrent::AtomicMarkableReference < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
+  def compare_and_set_reference(expected, value); end
+  def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
+  def get; end
+  def immutable_array(*args); end
+  def initialize(value = nil, mark = nil); end
+  def mark; end
+  def marked?; end
+  def reference; end
+  def reference=(value); end
+  def self.new(*args, &block); end
+  def set(new_val, new_mark); end
+  def swap_reference(value); end
+  def try_update!; end
+  def try_update; end
+  def update; end
+  def update_reference(&block); end
+  def value; end
+end
+class Concurrent::Agent < Concurrent::Synchronization::LockableObject
+  def <<(action); end
+  def await; end
+  def await_for!(timeout); end
+  def await_for(timeout); end
+  def deref; end
+  def enqueue_action_job(action, args, executor); end
+  def enqueue_await_job(latch); end
+  def error; end
+  def error_mode; end
+  def execute_next_job; end
+  def failed?; end
+  def handle_error(error); end
+  def initialize(initial, opts = nil); end
+  def ns_enqueue_job(job, index = nil); end
+  def ns_find_last_job_for_thread; end
+  def ns_initialize(initial, opts); end
+  def ns_post_next_job; end
+  def ns_validate(value); end
+  def post(*args, &action); end
+  def reason; end
+  def restart(new_value, opts = nil); end
+  def self.await(*agents); end
+  def self.await_for!(timeout, *agents); end
+  def self.await_for(timeout, *agents); end
+  def send!(*args, &action); end
+  def send(*args, &action); end
+  def send_off!(*args, &action); end
+  def send_off(*args, &action); end
+  def send_via!(executor, *args, &action); end
+  def send_via(executor, *args, &action); end
+  def stopped?; end
+  def value; end
+  def wait(timeout = nil); end
+  include Concurrent::Concern::Observable
+end
+class Concurrent::Agent::Job < Struct
+  def action; end
+  def action=(_); end
+  def args; end
+  def args=(_); end
+  def caller; end
+  def caller=(_); end
+  def executor; end
+  def executor=(_); end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+end
+class Concurrent::Agent::Error < StandardError
+  def initialize(message = nil); end
+end
+class Concurrent::Agent::ValidationError < Concurrent::Agent::Error
+  def initialize(message = nil); end
+end
+class Concurrent::Atom < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set(old_value, new_value); end
+  def compare_and_set_value(expected, value); end
+  def deref; end
+  def initialize(value, opts = nil); end
+  def reset(new_value); end
+  def self.new(*args, &block); end
+  def swap(*args); end
+  def swap_value(value); end
+  def update_value(&block); end
+  def valid?(new_value); end
+  def value; end
+  def value=(value); end
+  include Concurrent::Concern::Observable
+end
+module Concurrent::ThreadSafe
+end
+module Concurrent::ThreadSafe::Util
+end
+class Concurrent::Array < Array
+end
+class Concurrent::Hash < Hash
+end
+class Concurrent::Set < Set
+end
+class Concurrent::Collection::NonConcurrentMapBackend
+  def [](key); end
+  def []=(key, value); end
+  def _get(key); end
+  def _set(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def dupped_backend; end
+  def each_pair; end
+  def get_and_set(key, value); end
+  def get_or_default(key, default_value); end
+  def initialize(options = nil); end
+  def initialize_copy(other); end
+  def key?(key); end
+  def merge_pair(key, value); end
+  def pair?(key, expected_value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+  def size; end
+  def store_computed_value(key, new_value); end
+end
+class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend
+  def []=(key, value); end
+  def clear; end
+  def compute(key); end
+  def compute_if_absent(key); end
+  def compute_if_present(key); end
+  def delete(key); end
+  def delete_pair(key, value); end
+  def get_and_set(key, value); end
+  def initialize(options = nil); end
+  def merge_pair(key, value); end
+  def replace_if_exists(key, new_value); end
+  def replace_pair(key, old_value, new_value); end
+end
+class Concurrent::Map < Concurrent::Collection::MriMapBackend
+  def [](key); end
+  def each; end
+  def each_key; end
+  def each_pair; end
+  def each_value; end
+  def empty?; end
+  def fetch(key, default_value = nil); end
+  def fetch_or_store(key, default_value = nil); end
+  def get(key); end
+  def initialize(options = nil, &block); end
+  def initialize_copy(other); end
+  def inspect; end
+  def key(value); end
+  def keys; end
+  def marshal_dump; end
+  def marshal_load(hash); end
+  def populate_from(hash); end
+  def put(key, value); end
+  def put_if_absent(key, value); end
+  def raise_fetch_no_key; end
+  def validate_options_hash!(options); end
+  def value?(value); end
+  def values; end
+end
+class Concurrent::Tuple
+  def cas(i, old_value, new_value); end
+  def compare_and_set(i, old_value, new_value); end
+  def each; end
+  def get(i); end
+  def initialize(size); end
+  def set(i, value); end
+  def size; end
+  def volatile_get(i); end
+  def volatile_set(i, value); end
+  include Enumerable
+end
+module Concurrent::Async
+  def async; end
+  def await; end
+  def call; end
+  def cast; end
+  def init_synchronization; end
+  def self.included(base); end
+  def self.validate_argc(obj, method, *args); end
+end
+module Concurrent::Async::ClassMethods
+  def new(*args, &block); end
+end
+class Concurrent::Async::AsyncDelegator < Concurrent::Synchronization::LockableObject
+  def initialize(delegate); end
+  def method_missing(method, *args, &block); end
+  def perform; end
+  def respond_to_missing?(method, include_private = nil); end
+end
+class Concurrent::Async::AwaitDelegator
+  def initialize(delegate); end
+  def method_missing(method, *args, &block); end
+  def respond_to_missing?(method, include_private = nil); end
+end
+class Concurrent::Future < Concurrent::IVar
+  def cancel; end
+  def cancelled?; end
+  def execute; end
+  def initialize(opts = nil, &block); end
+  def ns_initialize(value, opts); end
+  def self.execute(opts = nil, &block); end
+  def set(value = nil, &block); end
+  def wait_or_cancel(timeout); end
+end
+class Concurrent::DependencyCounter
+  def initialize(count, &block); end
+  def update(time, value, reason); end
+end
+class Concurrent::Maybe < Concurrent::Synchronization::Object
+  def <=>(other); end
+  def fulfilled?; end
+  def initialize(just, nothing); end
+  def just; end
+  def just?; end
+  def nothing; end
+  def nothing?; end
+  def or(other); end
+  def reason; end
+  def rejected?; end
+  def self.from(*args); end
+  def self.just(value); end
+  def self.new(*args, &block); end
+  def self.nothing(error = nil); end
+  def value; end
+  include Comparable
+end
+class Concurrent::AbstractExchanger < Concurrent::Synchronization::Object
+  def do_exchange(value, timeout); end
+  def exchange!(value, timeout = nil); end
+  def exchange(value, timeout = nil); end
+  def initialize; end
+  def try_exchange(value, timeout = nil); end
+end
+class Concurrent::RubyExchanger < Concurrent::AbstractExchanger
+  def __initialize_atomic_fields__; end
+  def compare_and_set_slot(expected, value); end
+  def do_exchange(value, timeout); end
+  def initialize; end
+  def self.new(*args, &block); end
+  def slot; end
+  def slot=(value); end
+  def swap_slot(value); end
+  def update_slot(&block); end
+end
+class Concurrent::RubyExchanger::Node < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def compare_and_set_value(expected, value); end
+  def initialize(item); end
+  def item; end
+  def latch; end
+  def self.new(*args, &block); end
+  def swap_value(value); end
+  def update_value(&block); end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::Exchanger < Concurrent::RubyExchanger
+end
+module Concurrent::Synchronization::AbstractStruct
+  def initialize(*values); end
+  def length; end
+  def members; end
+  def ns_each; end
+  def ns_each_pair; end
+  def ns_equality(other); end
+  def ns_get(member); end
+  def ns_inspect; end
+  def ns_merge(other, &block); end
+  def ns_select; end
+  def ns_to_h; end
+  def ns_values; end
+  def ns_values_at(indexes); end
+  def pr_underscore(clazz); end
+  def self.define_struct_class(parent, base, name, members, &block); end
+  def size; end
+end
+module Concurrent::ImmutableStruct
+  def ==(other); end
+  def [](member); end
+  def each(&block); end
+  def each_pair(&block); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.included(base); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+module Concurrent::MutableStruct
+  def ==(other); end
+  def [](member); end
+  def []=(member, value); end
+  def each(&block); end
+  def each_pair(&block); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+class Concurrent::MVar < Concurrent::Synchronization::Object
+  def borrow(timeout = nil); end
+  def empty?; end
+  def full?; end
+  def initialize(value = nil, opts = nil); end
+  def modify!; end
+  def modify(timeout = nil); end
+  def put(value, timeout = nil); end
+  def self.new(*args, &block); end
+  def set!(value); end
+  def synchronize(&block); end
+  def take(timeout = nil); end
+  def try_put!(value); end
+  def try_take!; end
+  def unlocked_empty?; end
+  def unlocked_full?; end
+  def wait_for_empty(timeout); end
+  def wait_for_full(timeout); end
+  def wait_while(condition, timeout); end
+  include Concurrent::Concern::Dereferenceable
+end
+class Concurrent::PromiseExecutionError < StandardError
+end
+class Concurrent::Promise < Concurrent::IVar
+  def catch(&block); end
+  def complete(success, value, reason); end
+  def execute; end
+  def fail(reason = nil); end
+  def flat_map(&block); end
+  def initialize(opts = nil, &block); end
+  def notify_child(child); end
+  def ns_initialize(value, opts); end
+  def on_error(&block); end
+  def on_fulfill(result); end
+  def on_reject(reason); end
+  def on_success(&block); end
+  def realize(task); end
+  def rescue(&block); end
+  def root?; end
+  def self.aggregate(method, *promises); end
+  def self.all?(*promises); end
+  def self.any?(*promises); end
+  def self.execute(opts = nil, &block); end
+  def self.fulfill(value, opts = nil); end
+  def self.reject(reason, opts = nil); end
+  def self.zip(*promises); end
+  def set(value = nil, &block); end
+  def set_pending; end
+  def set_state!(success, value, reason); end
+  def synchronized_set_state!(success, value, reason); end
+  def then(*args, &block); end
+  def zip(*others); end
+end
+module Concurrent::SettableStruct
+  def ==(other); end
+  def [](member); end
+  def []=(member, value); end
+  def each(&block); end
+  def each_pair(&block); end
+  def inspect; end
+  def merge(other, &block); end
+  def select(&block); end
+  def self.new(*args, &block); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def values; end
+  def values_at(*indexes); end
+  include Concurrent::Synchronization::AbstractStruct
+end
+class Concurrent::TimerTask < Concurrent::RubyExecutorService
+  def <<(task); end
+  def execute; end
+  def execute_task(completion); end
+  def execution_interval; end
+  def execution_interval=(value); end
+  def initialize(opts = nil, &task); end
+  def ns_initialize(opts, &task); end
+  def ns_kill_execution; end
+  def ns_shutdown_execution; end
+  def post(*args, &task); end
+  def running?; end
+  def schedule_next_task(interval = nil); end
+  def self.execute(opts = nil, &task); end
+  def timeout_interval; end
+  def timeout_interval=(value); end
+  def timeout_task(completion); end
+  include Concurrent::Concern::Dereferenceable
+  include Concurrent::Concern::Observable
+end
+class Concurrent::TVar < Concurrent::Synchronization::Object
+  def initialize(value); end
+  def self.new(*args, &block); end
+  def unsafe_increment_version; end
+  def unsafe_lock; end
+  def unsafe_value; end
+  def unsafe_value=(value); end
+  def unsafe_version; end
+  def value; end
+  def value=(value); end
+end
+class Concurrent::Transaction
+  def abort; end
+  def commit; end
+  def initialize; end
+  def read(tvar); end
+  def self.current; end
+  def self.current=(transaction); end
+  def unlock; end
+  def valid?; end
+  def write(tvar, value); end
+end
+class Concurrent::Transaction::ReadLogEntry < Struct
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def tvar; end
+  def tvar=(_); end
+  def version; end
+  def version=(_); end
+end
+class Concurrent::Transaction::AbortError < StandardError
+end
+class Concurrent::Transaction::LeaveError < StandardError
+end
+class Concurrent::LockFreeStack < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def clear; end
+  def clear_each(&block); end
+  def clear_if(head); end
+  def compare_and_clear(head); end
+  def compare_and_pop(head); end
+  def compare_and_push(head, value); end
+  def compare_and_set_head(expected, value); end
+  def each(head = nil); end
+  def empty?(head = nil); end
+  def head; end
+  def head=(value); end
+  def initialize(head = nil); end
+  def inspect; end
+  def peek; end
+  def pop; end
+  def push(value); end
+  def replace_if(head, new_head); end
+  def self.new(*args, &block); end
+  def self.of1(value); end
+  def self.of2(value1, value2); end
+  def swap_head(value); end
+  def to_s; end
+  def update_head(&block); end
+  include Enumerable
+end
+class Concurrent::LockFreeStack::Node
+  def initialize(value, next_node); end
+  def next_node; end
+  def self.[](*arg0); end
+  def value; end
+  def value=(arg0); end
+end
+module Concurrent::ReInclude
+  def extended(base); end
+  def include(*modules); end
+  def included(base); end
+end
+module Concurrent::Promises
+  extend Concurrent::Promises::FactoryMethods
+end
+module Concurrent::Promises::FactoryMethods
+  def any(*futures_and_or_events); end
+  def any_event(*futures_and_or_events); end
+  def any_event_on(default_executor, *futures_and_or_events); end
+  def any_fulfilled_future(*futures_and_or_events); end
+  def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
+  def any_resolved_future(*futures_and_or_events); end
+  def any_resolved_future_on(default_executor, *futures_and_or_events); end
+  def delay(*args, &task); end
+  def delay_on(default_executor, *args, &task); end
+  def fulfilled_future(value, default_executor = nil); end
+  def future(*args, &task); end
+  def future_on(default_executor, *args, &task); end
+  def make_future(argument = nil, default_executor = nil); end
+  def rejected_future(reason, default_executor = nil); end
+  def resolvable_event; end
+  def resolvable_event_on(default_executor = nil); end
+  def resolvable_future; end
+  def resolvable_future_on(default_executor = nil); end
+  def resolved_event(default_executor = nil); end
+  def resolved_future(fulfilled, value, reason, default_executor = nil); end
+  def schedule(intended_time, *args, &task); end
+  def schedule_on(default_executor, intended_time, *args, &task); end
+  def zip(*futures_and_or_events); end
+  def zip_events(*futures_and_or_events); end
+  def zip_events_on(default_executor, *futures_and_or_events); end
+  def zip_futures(*futures_and_or_events); end
+  def zip_futures_on(default_executor, *futures_and_or_events); end
+  extend Concurrent::Promises::FactoryMethods
+  extend Concurrent::Promises::FactoryMethods::Configuration
+  extend Concurrent::ReInclude
+  include Concurrent::Promises::FactoryMethods::Configuration
+end
+module Concurrent::Promises::FactoryMethods::Configuration
+  def default_executor; end
+end
+module Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::InternalStates::State
+  def resolved?; end
+  def to_sym; end
+end
+class Concurrent::Promises::InternalStates::Pending < Concurrent::Promises::InternalStates::State
+  def resolved?; end
+  def to_sym; end
+end
+class Concurrent::Promises::InternalStates::Reserved < Concurrent::Promises::InternalStates::Pending
+end
+class Concurrent::Promises::InternalStates::ResolvedWithResult < Concurrent::Promises::InternalStates::State
+  def apply; end
+  def fulfilled?; end
+  def reason; end
+  def resolved?; end
+  def result; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::Fulfilled < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(value); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::FulfilledArray < Concurrent::Promises::InternalStates::Fulfilled
+  def apply(args, block); end
+end
+class Concurrent::Promises::InternalStates::Rejected < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(reason); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::InternalStates::PartiallyRejected < Concurrent::Promises::InternalStates::ResolvedWithResult
+  def apply(args, block); end
+  def fulfilled?; end
+  def initialize(value, reason); end
+  def reason; end
+  def to_sym; end
+  def value; end
+end
+class Concurrent::Promises::AbstractEventFuture < Concurrent::Synchronization::Object
+  def __initialize_atomic_fields__; end
+  def add_callback(method, *args); end
+  def add_callback_clear_delayed_node(node); end
+  def add_callback_notify_blocked(promise, index); end
+  def async_callback_on_resolution(state, executor, args, callback); end
+  def blocks; end
+  def call_callback(method, state, args); end
+  def call_callbacks(state); end
+  def callback_clear_delayed_node(state, node); end
+  def callback_notify_blocked(state, promise, index); end
+  def callbacks; end
+  def chain(*args, &task); end
+  def chain_on(executor, *args, &task); end
+  def chain_resolvable(resolvable); end
+  def compare_and_set_internal_state(expected, value); end
+  def default_executor; end
+  def initialize(promise, default_executor); end
+  def inspect; end
+  def internal_state; end
+  def internal_state=(value); end
+  def on_resolution!(*args, &callback); end
+  def on_resolution(*args, &callback); end
+  def on_resolution_using(executor, *args, &callback); end
+  def pending?; end
+  def promise; end
+  def resolve_with(state, raise_on_reassign = nil, reserved = nil); end
+  def resolved?; end
+  def self.new(*args, &block); end
+  def state; end
+  def swap_internal_state(value); end
+  def tangle(resolvable); end
+  def to_s; end
+  def touch; end
+  def touched?; end
+  def update_internal_state(&block); end
+  def wait(timeout = nil); end
+  def wait_until_resolved(timeout); end
+  def waiting_threads; end
+  def with_async(executor, *args, &block); end
+  def with_default_executor(executor); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::Event < Concurrent::Promises::AbstractEventFuture
+  def &(other); end
+  def any(event_or_future); end
+  def callback_on_resolution(state, args, callback); end
+  def delay; end
+  def rejected_resolution(raise_on_reassign, state); end
+  def schedule(intended_time); end
+  def then(*args, &task); end
+  def to_event; end
+  def to_future; end
+  def with_default_executor(executor); end
+  def zip(other); end
+  def |(event_or_future); end
+end
+class Concurrent::Promises::Future < Concurrent::Promises::AbstractEventFuture
+  def &(other); end
+  def any(event_or_future); end
+  def apply(args, block); end
+  def async_callback_on_fulfillment(state, executor, args, callback); end
+  def async_callback_on_rejection(state, executor, args, callback); end
+  def callback_on_fulfillment(state, args, callback); end
+  def callback_on_rejection(state, args, callback); end
+  def callback_on_resolution(state, args, callback); end
+  def delay; end
+  def exception(*args); end
+  def flat(level = nil); end
+  def flat_event; end
+  def flat_future(level = nil); end
+  def fulfilled?; end
+  def inspect; end
+  def on_fulfillment!(*args, &callback); end
+  def on_fulfillment(*args, &callback); end
+  def on_fulfillment_using(executor, *args, &callback); end
+  def on_rejection!(*args, &callback); end
+  def on_rejection(*args, &callback); end
+  def on_rejection_using(executor, *args, &callback); end
+  def reason(timeout = nil, timeout_value = nil); end
+  def rejected?; end
+  def rejected_resolution(raise_on_reassign, state); end
+  def rescue(*args, &task); end
+  def rescue_on(executor, *args, &task); end
+  def result(timeout = nil); end
+  def run(run_test = nil); end
+  def run_test(v); end
+  def schedule(intended_time); end
+  def then(*args, &task); end
+  def then_on(executor, *args, &task); end
+  def to_event; end
+  def to_future; end
+  def to_s; end
+  def value!(timeout = nil, timeout_value = nil); end
+  def value(timeout = nil, timeout_value = nil); end
+  def wait!(timeout = nil); end
+  def wait_until_resolved!(timeout = nil); end
+  def with_default_executor(executor); end
+  def zip(other); end
+  def |(event_or_future); end
+end
+module Concurrent::Promises::Resolvable
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::ResolvableEvent < Concurrent::Promises::Event
+  def resolve(raise_on_reassign = nil, reserved = nil); end
+  def wait(timeout = nil, resolve_on_timeout = nil); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::Resolvable
+end
+class Concurrent::Promises::ResolvableFuture < Concurrent::Promises::Future
+  def evaluate_to!(*args, &block); end
+  def evaluate_to(*args, &block); end
+  def fulfill(value, raise_on_reassign = nil, reserved = nil); end
+  def reason(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def reject(reason, raise_on_reassign = nil, reserved = nil); end
+  def resolve(fulfilled = nil, value = nil, reason = nil, raise_on_reassign = nil, reserved = nil); end
+  def result(timeout = nil, resolve_on_timeout = nil); end
+  def value!(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def value(timeout = nil, timeout_value = nil, resolve_on_timeout = nil); end
+  def wait!(timeout = nil, resolve_on_timeout = nil); end
+  def wait(timeout = nil, resolve_on_timeout = nil); end
+  def with_hidden_resolvable; end
+  include Concurrent::Promises::Resolvable
+end
+class Concurrent::Promises::AbstractPromise < Concurrent::Synchronization::Object
+  def default_executor; end
+  def delayed_because; end
+  def evaluate_to(*args, block); end
+  def event; end
+  def future; end
+  def initialize(future); end
+  def inspect; end
+  def resolve_with(new_state, raise_on_reassign = nil); end
+  def self.new(*args, &block); end
+  def state; end
+  def to_s; end
+  def touch; end
+  include Concurrent::Promises::InternalStates
+end
+class Concurrent::Promises::ResolvableEventPromise < Concurrent::Promises::AbstractPromise
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::ResolvableFuturePromise < Concurrent::Promises::AbstractPromise
+  def evaluate_to(*args, block); end
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::InnerPromise < Concurrent::Promises::AbstractPromise
+end
+class Concurrent::Promises::BlockedPromise < Concurrent::Promises::InnerPromise
+  def blocked_by; end
+  def clear_and_propagate_touch(stack_or_element = nil); end
+  def delayed_because; end
+  def initialize(delayed, blockers_count, future); end
+  def on_blocker_resolution(future, index); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+  def resolvable?(countdown, future, index); end
+  def self.add_delayed(delayed1, delayed2); end
+  def self.new(*args, &block); end
+  def self.new_blocked_by(blockers, *args, &block); end
+  def self.new_blocked_by1(blocker, *args, &block); end
+  def self.new_blocked_by2(blocker1, blocker2, *args, &block); end
+  def touch; end
+end
+class Concurrent::Promises::BlockedTaskPromise < Concurrent::Promises::BlockedPromise
+  def executor; end
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+end
+class Concurrent::Promises::ThenPromise < Concurrent::Promises::BlockedTaskPromise
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::RescuePromise < Concurrent::Promises::BlockedTaskPromise
+  def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ChainPromise < Concurrent::Promises::BlockedTaskPromise
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ImmediateEventPromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor); end
+end
+class Concurrent::Promises::ImmediateFuturePromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor, fulfilled, value, reason); end
+end
+class Concurrent::Promises::AbstractFlatPromise < Concurrent::Promises::BlockedPromise
+  def add_delayed_of(future); end
+  def initialize(delayed_because, blockers_count, event_or_future); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+  def touch; end
+  def touched?; end
+end
+class Concurrent::Promises::FlatEventPromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::FlatFuturePromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, levels, default_executor); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::RunFuturePromise < Concurrent::Promises::AbstractFlatPromise
+  def initialize(delayed, blockers_count, default_executor, run_test); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::ZipEventEventPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ZipFutureEventPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::EventWrapperPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::FutureWrapperPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::ZipFuturesPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def process_on_blocker_resolution(future, index); end
+end
+class Concurrent::Promises::ZipEventsPromise < Concurrent::Promises::BlockedPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+end
+class Concurrent::Promises::AbstractAnyPromise < Concurrent::Promises::BlockedPromise
+end
+class Concurrent::Promises::AnyResolvedEventPromise < Concurrent::Promises::AbstractAnyPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::AnyResolvedFuturePromise < Concurrent::Promises::AbstractAnyPromise
+  def initialize(delayed, blockers_count, default_executor); end
+  def on_resolvable(resolved_future, index); end
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::AnyFulfilledFuturePromise < Concurrent::Promises::AnyResolvedFuturePromise
+  def resolvable?(countdown, future, index); end
+end
+class Concurrent::Promises::DelayPromise < Concurrent::Promises::InnerPromise
+  def delayed_because; end
+  def initialize(default_executor); end
+  def touch; end
+end
+class Concurrent::Promises::ScheduledPromise < Concurrent::Promises::InnerPromise
+  def initialize(default_executor, intended_time); end
+  def inspect; end
+  def intended_time; end
+end
+class Concurrent::SynchronizedDelegator < SimpleDelegator
+  def initialize(obj); end
+  def method_missing(method, *args, &block); end
+  def setup; end
+  def teardown; end
+end