# Constree

Recursively show the structure of constants in a module

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'constree'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install constree

## Example: find distinct module/class under a module

```ruby
[1] pry(main)> require "concurrent-ruby"
=> true
[2] pry(main)> require "constree"
=> true
[3] pry(main)> Constree.uniq(Concurrent)
=> #<Set:
 {Concurrent,
  Concurrent::AtomicDirectUpdate,
  Concurrent::AtomicNumericCompareAndSetWrapper,
  Concurrent::CyclicBarrier,
  Concurrent::Synchronization::Volatile::ClassMethods,
  Concurrent::Promises,
  Concurrent::Promises::FactoryMethods,
  Concurrent::Promises::FactoryMethods::Configuration,
  Concurrent::Promises::Resolvable,
  Concurrent::Promises::InternalStates::State,
  Concurrent::Promises::InternalStates::Pending,
  Concurrent::Promises::InternalStates::Reserved,
  Concurrent::Promises::InternalStates::ResolvedWithResult,
  Concurrent::Promises::InternalStates::Fulfilled,
  Concurrent::Promises::InternalStates::FulfilledArray,
  ...
```

## Example: output tree to html

```ruby
File.open('somewhere', 'w') do |f|
  f.puts Constree.html_of SomeConstant
end
```

## Example: check constants in concurrent-ruby, in irb console

```ruby
irb(main):001:0> require "concurrent-ruby"
=> true
irb(main):002:0> Constree.p Concurrent
Concurrent {:kla=>Module}
├─AbstractExchanger {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:kla=>Module}
├─AbstractExecutorService {:kla=>Class, :aft=>[Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:kla=>Integer}
│ ├─ERROR {:kla=>Integer}
│ ├─FALLBACK_POLICIES {:kla=>Array}
│ ├─FATAL {:kla=>Integer}
│ ├─INFO {:kla=>Integer}
│ ├─UNKNOWN {:kla=>Integer}
│ └─WARN {:kla=>Integer}
├─AbstractThreadLocalVar {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
├─Agent {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
│ └─ValidationError {:kla=>Class, :aft=>[Concurrent::Agent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─Array {:kla=>Class, :aft=>[Array, Enumerable, Object, Kernel, BasicObject]}
├─Async {:kla=>Module}
├─Atom {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─AtomicBoolean {:kla=>Class, :aft=>[Concurrent::MutexAtomicBoolean, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─AtomicDirectUpdate {:kla=>Module}
├─AtomicFixnum {:kla=>Class, :aft=>[Concurrent::MutexAtomicFixnum, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─AtomicMarkableReference {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─AtomicNumericCompareAndSetWrapper {:kla=>Module}
├─AtomicReference {:kla=>Class, :aft=>[Concurrent::MutexAtomicReference, Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─CRubySet {:kla=>Class, :aft=>[Set, Enumerable, Object, Kernel, BasicObject]}
│ └─InspectKey {:kla=>Symbol}
├─CachedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:kla=>Integer}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:kla=>FalseClass}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:kla=>Integer}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─CancelledOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─Collection {:kla=>Module}
│ ├─CopyOnNotifyObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─CopyOnWriteObserverSet {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MapImplementation {:kla=>Class, :aft=>[Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
│ ├─MriMapBackend {:ref=>"Concurrent::Collection::MapImplementation"}
│ ├─NonConcurrentMapBackend {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
│ ├─NonConcurrentPriorityQueue {:kla=>Class, :aft=>[Concurrent::Collection::RubyNonConcurrentPriorityQueue, Object, Kernel, BasicObject]}
│ └─RubyNonConcurrentPriorityQueue {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
├─Concern {:kla=>Module}
│ ├─Deprecation {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
│ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
│ ├─Dereferenceable {:kla=>Module}
│ ├─Logging {:kla=>Module, :aft=>[Logger::Severity]}
│ │ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ │ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ │ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ │ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ │ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ │ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
│ ├─Obligation {:kla=>Module, :aft=>[Concurrent::Concern::Dereferenceable]}
│ └─Observable {:kla=>Module}
├─ConcurrentUpdateError {:kla=>Class, :aft=>[ThreadError, StandardError, Exception, Object, Kernel, BasicObject]}
│ └─CONC_UP_ERR_BACKTRACE {:kla=>Array}
├─ConfigurationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─CountDownLatch {:kla=>Class, :aft=>[Concurrent::MutexCountDownLatch, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─CyclicBarrier {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─Delay {:kla=>Class, :aft=>[Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─DependencyCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
├─Error {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
├─Event {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─Exchanger {:kla=>Class, :aft=>[Concurrent::RubyExchanger, Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─ExecutorService {:kla=>Module, :aft=>[Concurrent::Concern::Logging, Logger::Severity]}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─FixedThreadPool {:kla=>Class, :aft=>[Concurrent::ThreadPoolExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─Future {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─Hash {:kla=>Class, :aft=>[Hash, Enumerable, Object, Kernel, BasicObject]}
├─IVar {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─IllegalOperationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─ImmediateExecutor {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─ImmutabilityError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─ImmutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
├─IndirectImmediateExecutor {:kla=>Class, :aft=>[Concurrent::ImmediateExecutor, Concurrent::SerialExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─InitializationError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─LifecycleError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─LockFreeStack {:kla=>Class, :aft=>[Enumerable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─EMPTY {:kla=>Concurrent::LockFreeStack::Node}
│ └─Node {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
├─MVar {:kla=>Class, :aft=>[Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─EMPTY {:kla=>Object}
│ └─TIMEOUT {:kla=>Object}
├─Map {:kla=>Class, :aft=>[Concurrent::Collection::MriMapBackend, Concurrent::Collection::NonConcurrentMapBackend, Object, Kernel, BasicObject]}
├─MaxRestartFrequencyError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─Maybe {:kla=>Class, :aft=>[Comparable, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ └─NONE {:kla=>Object}
├─MultipleAssignmentError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─MultipleErrors {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─MutableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
├─MutexAtomicBoolean {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─MutexAtomicFixnum {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─MutexAtomicReference {:kla=>Class, :aft=>[Concurrent::AtomicNumericCompareAndSetWrapper, Concurrent::AtomicDirectUpdate, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─MutexCountDownLatch {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─MutexSemaphore {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─NULL {:kla=>Object}
├─NULL_LOGGER {:kla=>Proc}
├─Options {:kla=>Module}
├─Promise {:kla=>Class, :aft=>[Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─PromiseExecutionError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
├─Promises {:kla=>Module}
│ ├─AbstractEventFuture {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ │ ├─Fulfilled {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─FulfilledArray {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Fulfilled, Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─PENDING {:kla=>Concurrent::Promises::InternalStates::Pending}
│ │ ├─PartiallyRejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─Pending {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─RESERVED {:kla=>Concurrent::Promises::InternalStates::Reserved}
│ │ ├─RESOLVED {:kla=>Concurrent::Promises::InternalStates::Fulfilled}
│ │ ├─Rejected {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::ResolvedWithResult, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─Reserved {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::Pending, Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ ├─ResolvedWithResult {:kla=>Class, :aft=>[Concurrent::Promises::InternalStates::State, Object, Kernel, BasicObject]}
│ │ └─State {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
│ ├─Event {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
│ ├─FactoryMethods {:kla=>Module, :aft=>[Concurrent::Promises::FactoryMethods::Configuration]}
│ │ └─Configuration {:kla=>Module}
│ ├─Future {:kla=>Class, :aft=>[Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
│ ├─Resolvable {:kla=>Module, :aft=>[Concurrent::Promises::InternalStates]}
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
│ ├─ResolvableEvent {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Event, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ │ ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
│ │ ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
│ │ ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
│ │ ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
│ │ ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
│ │ ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
│ │ ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
│ │ ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
│ │ ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
│ │ ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
│ │ └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
│ └─ResolvableFuture {:kla=>Class, :aft=>[Concurrent::Promises::Resolvable, Concurrent::Promises::Future, Concurrent::Promises::AbstractEventFuture, Concurrent::Promises::InternalStates, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│   ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│   ├─Fulfilled {:ref=>"Concurrent::Promises::AbstractEventFuture::Fulfilled"}
│   ├─FulfilledArray {:ref=>"Concurrent::Promises::AbstractEventFuture::FulfilledArray"}
│   ├─PENDING {:ref=>"Concurrent::Promises::AbstractEventFuture::PENDING"}
│   ├─PartiallyRejected {:ref=>"Concurrent::Promises::AbstractEventFuture::PartiallyRejected"}
│   ├─Pending {:ref=>"Concurrent::Promises::AbstractEventFuture::Pending"}
│   ├─RESERVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESERVED"}
│   ├─RESOLVED {:ref=>"Concurrent::Promises::AbstractEventFuture::RESOLVED"}
│   ├─Rejected {:ref=>"Concurrent::Promises::AbstractEventFuture::Rejected"}
│   ├─Reserved {:ref=>"Concurrent::Promises::AbstractEventFuture::Reserved"}
│   ├─ResolvedWithResult {:ref=>"Concurrent::Promises::AbstractEventFuture::ResolvedWithResult"}
│   └─State {:ref=>"Concurrent::Promises::AbstractEventFuture::State"}
├─ReInclude {:kla=>Module}
├─ReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MAX_READERS {:kla=>Integer}
│ ├─MAX_WRITERS {:kla=>Integer}
│ ├─RUNNING_WRITER {:kla=>Integer}
│ └─WAITING_WRITER {:kla=>Integer}
├─ReentrantReadWriteLock {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MAX_READERS {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
│ ├─MAX_WRITERS {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
│ ├─READER_BITS {:kla=>Integer}
│ ├─READ_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_READERS"}
│ ├─RUNNING_WRITER {:ref=>"Concurrent::ReadWriteLock::RUNNING_WRITER"}
│ ├─WAITING_WRITER {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
│ ├─WRITER_BITS {:kla=>Integer}
│ ├─WRITE_LOCK_HELD {:ref=>"Concurrent::ReadWriteLock::WAITING_WRITER"}
│ └─WRITE_LOCK_MASK {:ref=>"Concurrent::ReadWriteLock::MAX_WRITERS"}
├─RejectedExecutionError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─ResourceLimitError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─RubyExchanger {:kla=>Class, :aft=>[Concurrent::AbstractExchanger, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─RubyExecutorService {:kla=>Class, :aft=>[Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─RubySingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─RubyThreadLocalVar {:kla=>Class, :aft=>[Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
├─RubyThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─SafeTaskExecutor {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─ScheduledTask {:kla=>Class, :aft=>[Comparable, Concurrent::IVar, Concurrent::Concern::Observable, Concurrent::Concern::Obligation, Concurrent::Concern::Dereferenceable, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─Semaphore {:kla=>Class, :aft=>[Concurrent::MutexSemaphore, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─SerialExecutorService {:kla=>Module, :aft=>[Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity]}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─SerializedExecution {:kla=>Class, :aft=>[Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─Job {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
│ │ ├─Group {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
│ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
│ │ │ ├─Passwd {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
│ │ │ │ ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
│ │ │ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
│ │ │ │ └─Tms {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
│ │ │ │   ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
│ │ │ │   ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
│ │ │ │   └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
│ │ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
│ │ ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
│ │ └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─SerializedExecutionDelegator {:kla=>Class, :aft=>[Concurrent::SerialExecutorService, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
│ ├─BasicObject {:kla=>Class}
│ │ └─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─RUBYGEMS_ACTIVATION_MONITOR {:kla=>Monitor}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─Set {:kla=>Class, :aft=>[Concurrent::CRubySet, Set, Enumerable, Object, Kernel, BasicObject]}
│ └─InspectKey {:ref=>"Concurrent::CRubySet::InspectKey"}
├─SettableStruct {:kla=>Module, :aft=>[Concurrent::Synchronization::AbstractStruct]}
├─SimpleExecutorService {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─SingleThreadExecutor {:kla=>Class, :aft=>[Concurrent::RubySingleThreadExecutor, Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─Synchronization {:kla=>Module}
│ ├─AbstractLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─AbstractObject {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
│ ├─AbstractStruct {:kla=>Module}
│ ├─Condition {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─ConditionSignalling {:kla=>Module}
│ ├─Lock {:kla=>Class, :aft=>[Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─LockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MonitorLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MriAttrVolatile {:kla=>Module}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MriObject {:kla=>Class, :aft=>[Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─MutexLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─Object {:kla=>Class, :aft=>[Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─RbxAttrVolatile {:kla=>Module}
│ │ └─ClassMethods {:kla=>Module}
│ ├─RbxLockableObject {:kla=>Class, :aft=>[Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─RbxObject {:kla=>Class, :aft=>[Concurrent::Synchronization::RbxAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::RbxAttrVolatile::ClassMethods"}
│ ├─TruffleRubyAttrVolatile {:kla=>Module}
│ │ └─ClassMethods {:kla=>Module}
│ ├─TruffleRubyObject {:kla=>Class, :aft=>[Concurrent::Synchronization::TruffleRubyAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ │ └─ClassMethods {:ref=>"Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods"}
│ └─Volatile {:ref=>"Concurrent::Synchronization::MriAttrVolatile"}
├─SynchronizedDelegator {:kla=>Class, :aft=>[SimpleDelegator, Delegator, #<Module:0x00005574e9d301b8>, BasicObject]}
│ ├─BasicObject {:ref=>"Concurrent::SerializedExecutionDelegator::BasicObject"}
│ └─RUBYGEMS_ACTIVATION_MONITOR {:ref=>"Concurrent::SerializedExecutionDelegator::RUBYGEMS_ACTIVATION_MONITOR"}
├─TVar {:kla=>Class, :aft=>[Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ └─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
├─ThreadLocalVar {:kla=>Class, :aft=>[Concurrent::RubyThreadLocalVar, Concurrent::AbstractThreadLocalVar, Object, Kernel, BasicObject]}
├─ThreadPoolExecutor {:kla=>Class, :aft=>[Concurrent::RubyThreadPoolExecutor, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MAX_POOL_SIZE {:ref=>"Concurrent::CachedThreadPool::DEFAULT_MAX_POOL_SIZE"}
│ ├─DEFAULT_MAX_QUEUE_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_MIN_POOL_SIZE {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─DEFAULT_SYNCHRONOUS {:ref=>"Concurrent::CachedThreadPool::DEFAULT_SYNCHRONOUS"}
│ ├─DEFAULT_THREAD_IDLETIMEOUT {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─ThreadSafe {:kla=>Module}
│ └─Util {:kla=>Module}
│   ├─CPU_COUNT {:kla=>Integer}
│   ├─FIXNUM_BIT_SIZE {:kla=>Integer}
│   └─MAX_INT {:kla=>Integer}
├─TimeoutError {:kla=>Class, :aft=>[Concurrent::Error, StandardError, Exception, Object, Kernel, BasicObject]}
├─TimerSet {:kla=>Class, :aft=>[Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─TimerTask {:kla=>Class, :aft=>[Concurrent::Concern::Observable, Concurrent::Concern::Dereferenceable, Concurrent::RubyExecutorService, Concurrent::AbstractExecutorService, Concurrent::Concern::Deprecation, Concurrent::ExecutorService, Concurrent::Concern::Logging, Logger::Severity, Concurrent::Synchronization::LockableObject, Concurrent::Synchronization::MutexLockableObject, Concurrent::Synchronization::ConditionSignalling, Concurrent::Synchronization::AbstractLockableObject, Concurrent::Synchronization::Object, Concurrent::Synchronization::MriObject, Concurrent::Synchronization::MriAttrVolatile, Concurrent::Synchronization::AbstractObject, Object, Kernel, BasicObject]}
│ ├─ClassMethods {:ref=>"Concurrent::AbstractExchanger::ClassMethods"}
│ ├─DEBUG {:ref=>"Concurrent::AbstractExecutorService::DEBUG"}
│ ├─ERROR {:ref=>"Concurrent::AbstractExecutorService::ERROR"}
│ ├─EXECUTION_INTERVAL {:ref=>"Concurrent::CachedThreadPool::DEFAULT_THREAD_IDLETIMEOUT"}
│ ├─FALLBACK_POLICIES {:ref=>"Concurrent::AbstractExecutorService::FALLBACK_POLICIES"}
│ ├─FATAL {:ref=>"Concurrent::AbstractExecutorService::FATAL"}
│ ├─INFO {:ref=>"Concurrent::AbstractExecutorService::INFO"}
│ ├─TIMEOUT_INTERVAL {:kla=>Integer}
│ ├─UNKNOWN {:ref=>"Concurrent::AbstractExecutorService::UNKNOWN"}
│ └─WARN {:ref=>"Concurrent::AbstractExecutorService::WARN"}
├─Transaction {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
│ ├─ABORTED {:kla=>Object}
│ ├─AbortError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
│ ├─LeaveError {:kla=>Class, :aft=>[StandardError, Exception, Object, Kernel, BasicObject]}
│ └─OpenEntry {:kla=>Class, :aft=>[Struct, Enumerable, Object, Kernel, BasicObject]}
│   ├─Group {:ref=>"Concurrent::SerializedExecution::Job::Group"}
│   ├─Passwd {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd"}
│   └─Tms {:ref=>"Concurrent::SerializedExecution::Job::Group::Passwd::Tms"}
├─Tuple {:kla=>Class, :aft=>[Enumerable, Object, Kernel, BasicObject]}
├─Utility {:kla=>Module}
│ ├─EngineDetector {:kla=>Module}
│ ├─NativeExtensionLoader {:kla=>Module}
│ ├─NativeInteger {:kla=>Module}
│ │ ├─MAX_VALUE {:ref=>"Concurrent::ThreadSafe::Util::MAX_INT"}
│ │ └─MIN_VALUE {:kla=>Integer}
│ └─ProcessorCounter {:kla=>Class, :aft=>[Object, Kernel, BasicObject]}
└─VERSION {:kla=>String}
=> nil
```