diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d101fe..1e66e77 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.1.0] - 2024-04-13
+
+- Implement basic primitive arbitraries
+- Implement composite arbitraries
+- Support shrinking
+- Support multiple concurrency methods
+    - Ractor
+    - Process
+    - Thread
+    - None (Run tests sequentially)
+- Documentation
+    - Add better examples
+    - Arbitrary usage
+    - Configuration
+ 
 ## [0.0.1] - 2024-01-27
 
-- Initial release
+- Initial release (Proof of concept)
diff --git a/README.md b/README.md
index da8f281..fff594b 100644
--- a/README.md
+++ b/README.md
@@ -1,22 +1,48 @@
 # Property-Based Testing in Ruby
 
-⚠️ This gem is currently in the proof of concept phase. It's experimental and not production quality for now!
+[![Gem Version](https://badge.fury.io/rb/pbt.svg)](https://rubygems.org/gems/pbt)
+[![Build Status](https://github.com/ohbarye/pbt/actions/workflows/main.yml/badge.svg)](https://github.com/ohbarye/pbt/actions/workflows/main.yml)
+[![RubyDoc](https://img.shields.io/badge/%F0%9F%93%9ARubyDoc-documentation-informational.svg)](https://www.rubydoc.info/gems/pbt)
 
-A property-based testing tool for Ruby, utilizing Ractor for parallelizing test cases.
+An experimental property-based testing tool for Ruby that allows you to run test cases in parallel.
+
+PBT stands for Property-Based Testing.
+
+## What's Property-Based Testing?
+
+Property-Based Testing is a testing methodology that focuses on the properties a system should always satisfy, rather than checking individual examples. Instead of writing tests for predefined inputs and outputs, PBT allows you to specify the general characteristics that your code should adhere to and then automatically generates a wide range of inputs to verify these properties.
+
+The key benefits of property-based testing include the ability to cover more edge cases and the potential to discover bugs that traditional example-based tests might miss. It's particularly useful for identifying unexpected behaviors in your code by testing it against a vast set of inputs, including those you might not have considered.
+
+For a more in-depth understanding of Property-Based Testing, please refer to external resources.
+
+- Original ideas
+  - [Property-based testing of privileged programs](https://ieeexplore.ieee.org/document/367311) (1994)
+  - [Property-based testing: a new approach to testing for assurance](https://dl.acm.org/doi/abs/10.1145/263244.263267) (1997)
+  - [QuickCheck: a lightweight tool for random testing of Haskell programs](https://dl.acm.org/doi/10.1145/351240.351266) (2000)
+- Rather new introductory resources
+  - Fred Hebert's book [Property-Based Testing With PropEr, Erlang and Elixir](https://propertesting.com/).
+  - [fast-check - Why Property-Based?](https://fast-check.dev/docs/introduction/why-property-based/)
 
 ## Installation
 
-```shell
-$ gem install pbt
+Add this line to your application's Gemfile and run `bundle install`.
+
+```ruby
+gem 'pbt'
 ```
 
-If you want to use concurrency methods other than Ractor (`process`, `thread`), you need to install [parallel](https://github.com/grosser/parallel) gem as well.
+If you want to use multi-processes or multi-threads (other than Ractor) as workers to run tests, install the [parallel](https://github.com/grosser/parallel) gem.
 
-```shell
-$ gem install parallel
+```ruby
+gem 'parallel'
 ```
 
-## Usage
+Off course you can install with `gem intstall pbt`.
+
+## Basic Usage
+
+### Simple property
 
 ```ruby
 # Let's say you have a method that returns just a multiplicative inverse.
@@ -24,77 +50,201 @@ def multiplicative_inverse(number)
   Rational(1, number)
 end
 
-RSpec.describe Pbt do
-  it "works" do
-    Pbt.assert do
-      # The given block is executed 100 times with different random numbers.
-      # Besides, the block runs in parallel by Ractor.
-      Pbt.property(Pbt.integer) do |number|
-        result = multiplicative_inverse(number)
-        raise "Result should be the multiplicative inverse of the number" if result * number != 1
-      end
-    end
-    
-    # If the function has a bug, the test fails with a counterexample.
-    # For example, the multiplicative_inverse method doesn't work for 0 regardless of the behavior is intended or not.
-    #
-    # Pbt::PropertyFailure:
-    #   Property failed after 23 test(s)
-    #   { seed: 11001296583699917659214176011685741769 }
-    #   Counterexample: 0
-    #   Shrunk 3 time(s)
-    #   Got ZeroDivisionError: divided by 0
+Pbt.assert do
+  # The given block is executed 100 times with different random numbers.
+  # Besides, the block runs in parallel by Ractor.
+  Pbt.property(Pbt.integer) do |number|
+    result = multiplicative_inverse(number)
+    raise "Result should be the multiplicative inverse of the number" if result * number != 1
   end
 end
+
+# If the function has a bug, the test fails with a counterexample.
+# For example, the multiplicative_inverse method doesn't work for 0 regardless of the behavior is intended or not.
+#
+# Pbt::PropertyFailure:
+#   Property failed after 23 test(s)
+#   { seed: 11001296583699917659214176011685741769 }
+#   Counterexample: 0
+#   Shrunk 3 time(s)
+#   Got ZeroDivisionError: divided by 0
 ```
 
+### Explain The Snippet
+
+The above snippet is very simple but contains the basic components.
+
+#### Runner
+
+`Pbt.assert` is the runner. The runner interprets and executes the given property. `Pbt.assert` takes a property and runs it multiple times. If the property fails, it tries to shrink the input that caused the failure.
+
+#### Property
+
+The snippet above declared a property by calling `Pbt.property`. The property describes the following:
+
+1. What the user wants to evaluate. This corresponds to the block (let's call this `predicate`) enclosed by `do` `end`
+2. How to generate inputs for the predicate — using `Arbitrary`
+
+The `predicate` block is a function that directly asserts, taking values generated by `Arbitrary` as input.
+
+#### Arbitrary
+
+Arbitrary generates random values. It is also responsible for shrinking those values if asked to shrink a failed value as input.
+
+Here, we used only one type of arbitrary, `Pbt.integer`. There are many other built-in arbitraries, and you can create a variety of inputs by combining existing ones.
+
+#### Shrink
+
+In PBT, If a test fails, it attempts to shrink the case that caused the failure into a form that is easier for humans to understand.
+In other words, instead of stopping the test itself the first time it fails and reporting the failed value, it tries to find the minimal value that causes the error.
+
+When there is a test that fails when given an even number, a counterexample of `2` is simpler and easier to understand than `432743417662`.
+
 ### Arbitrary
 
-TBA
+There are many built-in arbitraries in `Pbt`. You can use them to generate random values for your tests. Here are some representative arbitraries.
+
+#### Primitives
+
+```ruby
+rng = Random.new(
 
-### Configuration
+Pbt.integer.generate(rng) # => 42
+Pbt.integer(min: -1, max: 8).generate(rng) # => Integer between -1 and 8
 
-TBA
+Pbt.symbol.generate(rng) # => :atq
 
-### Concurrent methods
+Pbt.ascii_char.generate(rng) # => "a"
+Pbt.ascii_string.generate(rng) # => "aagjZfao"
 
-Pbt supports 3 concurrency methods and 1 sequential one. You can choose one of them by setting the `concurrency_method` option.
+Pbt.boolean.generate(rng) # => true or false
+Pbt.constant(42).generate(rng) # => 42 always
+```
 
-#### Ractor
+#### Composites
 
 ```ruby
-Pbt.assert(params: { concurrency_method: :ractor }) do
-  Pbt.property(Pbt.integer) do |number|
+rng = Random.new
+
+Pbt.array(Pbt.integer).generate(rng) # => [121, -13141, 9825]
+Pbt.array(Pbt.integer, max: 1, empty: true).generate(rng) # => [] or [42] etc.
+
+Pbt.tuple(Pbt.symbol, Pbt.integer).generate(rng) # => [:atq, 42]
+
+Pbt.fixed_hash(x: Pbt.symbol, y: Pbt.integer).generate(rng) # => {x: :atq, y: 42}
+Pbt.hash(Pbt.symbol, Pbt.integer).generate(rng) # => {atq: 121, ygab: -1142}
+
+Pbt.one_of(:a, 1, 0.1).generate(rng) # => :a or 1 or 0.1
+````
+
+See [ArbitraryMethods](https://github.com/ohbarye/pbt/blob/main/lib/pbt/arbitrary/arbitrary_methods.rb) module for more details.
+
+## Configuration
+
+You can configure `Pbt` by calling `Pbt.configure` before running tests.
+
+```ruby
+Pbt.configure do |config|
+  # Whether to print verbose output. Default is `false`.
+  config.verbose = 100
+
+  # The concurrency method to use. :ractor`, `:thread`, `:process` and `:none` are supported. Default is `:ractor`.
+  config.worker = :ractor
+
+  # The number of runs to perform. Default is `100`.
+  config.num_runs = 100
+
+  # The seed to use for random number generation.
+  # It's useful to reproduce failed test with the seed you'd pick up from failure messages. Default is a random seed.
+  config.seed = 42
+
+  # Whether to report exceptions in threads.
+  # It's useful to suppress error logs on Ractor that reports many errors. Default is `false`.
+  config.thread_report_on_exception = false
+end
+```
+
+Or, you can pass the configuration to `Pbt.assert` as an argument.
+
+```ruby
+Pbt.assert(num_runs: 100, seed: 42) do
+  # ...
+end
+```
+
+## Concurrent methods
+
+One of the key features of `Pbt` is its ability to rapidly execute test cases in parallel or concurrently, using a large number of values (by default, `100`) generated by `Arbitrary`.
+
+For concurrent processing, you can specify any of the three workers—`:ractor`, `:process`, or `:thread`—using the `worker` option. Alternatively, choose `:none` for serial execution.
+
+`Pbt` supports 3 concurrency methods and 1 sequential one. You can choose one of them by setting the `worker` option.
+
+### Ractor
+
+```ruby
+Pbt.assert(worker: :ractor) do
+  Pbt.property(Pbt.integer) do |n|
     # ...
   end
 end
 ```
 
-#### Process
+#### Limitation
+
+Please note that Ractor support is an experimental feature of this gem. Due to Ractor's limitations, you may encounter some issues when using it.
+
+For example, you cannot access anything out of block.
 
 ```ruby
-Pbt.assert(params: { concurrency_method: :process }) do
-  Pbt.property(Pbt.integer) do |number|
+a = 1
+
+Pbt.assert(worker: :ractor) do
+  Pbt.property(Pbt.integer) do |n|
+    # You cannot access `a` here because this block is executed in a Ractor and it doesn't allow implicit sharing of objects.
+    a + n # => Ractor::RemoteError (can not share object between ractors)
+  end
+end
+```
+
+You cannot use any methods provided by test frameworks like `expect` or `assert` because they are not available in a Ractor.
+
+```ruby
+it do
+  Pbt.assert(worker: :ractor) do
+    Pbt.property(Pbt.integer) do |n|
+      # This is not possible because `self` if a Ractor here.
+      expect(n).to be_an(Integer) # => Ractor::RemoteError (cause by NoMethodError for `expect` or `be_an`)
+    end
+  end
+end
+```
+
+### Process
+
+```ruby
+Pbt.assert(worker: :process) do
+  Pbt.property(Pbt.integer) do |n|
     # ...
   end
 end
 ```
 
-#### Thread
+### Thread
 
 ```ruby
-Pbt.assert(params: { concurrency_method: :thread }) do
-  Pbt.property(Pbt.integer) do |number|
+Pbt.assert(worker: :thread) do
+  Pbt.property(Pbt.integer) do |n|
     # ...
   end
 end
 ```
 
-#### None
+### None
 
 ```ruby
-Pbt.assert(params: { concurrency_method: :none }) do
-  Pbt.property(Pbt.integer) do |number|
+Pbt.assert(worker: :none) do
+  Pbt.property(Pbt.integer) do |n|
     # ...
   end
 end
@@ -102,29 +252,40 @@ end
 
 ## TODOs
 
-- [x] Enable to combine arbitraries (e.g. `Pbt.array(Pbt.integer)`)
+Once this project finishes the following, we will release v1.0.0.
+
+- [x] Implement basic primitive arbitraries
+- [x] Implement composite arbitraries
 - [x] Support shrinking
-- [x] Implement basic arbitraries
-  - https://proper-testing.github.io/apidocs/
-  - https://fast-check.dev/docs/core-blocks/arbitraries/
 - [x] Support multiple concurrency methods
   - [x] Ractor
   - [x] Process
   - [x] Thread
   - [x] None (Run tests sequentially)
+- [x] Documentation
+  - [x] Add better examples
+  - [x] Arbitrary usage
+  - [x] Configuration
 - [ ] Rich report like verbose mode
-- [ ] Allow to use assertions provided by RSpec etc. if possible
-  - It'd be so hard to pass assertions like `expect`, `assert` to a Ractor. But it's worth trying at least for `process`, `thread` concurrency methods.
-- [ ] Documentation
-  - [ ] Add better examples
-  - [ ] Arbitrary usage
-  - [ ] Configuration
+- [ ] Allow to use expectations and matchers provided by test framework in Ractor if possible.
+  - It'd be so hard to pass assertions like `expect`, `assert` to a Ractor.
+- [ ] Benchmark
+- [ ] More parallelism or faster execution if possible
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+### Setup
+
+```shell
+bin/setup
+bundle exec rake # Run tests and lint at once
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+### Test
+
+```shell
+bundle exec rspec
+```
 
 ### Lint
 
@@ -134,12 +295,24 @@ bundle exec rake standard:fix
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ohbarye/pbt. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/pbt/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/ohbarye/pbt. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/ohbarye/pbt/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
+## Credits
+
+This project draws a lot of inspiration from other testing tools, namely
+
+- [fast-check](https://fast-check.dev/)
+- [Loupe](https://github.com/vinistock/loupe)
+- [RSpec](https://github.com/rspec/rspec)
+- [Minitest](https://github.com/seattlerb/minitest)
+- [Parallel](https://github.com/grosser/parallel)
+- [PropCheck for Ruby](https://github.com/Qqwy/ruby-prop_check)
+- [PropCheck for Elixir](https://github.com/alfert/propcheck)
+
 ## Code of Conduct
 
 Everyone interacting in the Pbt project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/ohbarye/pbt/blob/master/CODE_OF_CONDUCT.md).
diff --git a/lib/pbt.rb b/lib/pbt.rb
index 0c61533..aacbef6 100644
--- a/lib/pbt.rb
+++ b/lib/pbt.rb
@@ -7,16 +7,37 @@
 require_relative "pbt/check/configuration"
 
 module Pbt
+  # Represents a property-based test failure.
   class PropertyFailure < StandardError; end
 
+  # Represents an invalid configuration.
   class InvalidConfiguration < StandardError; end
 
   extend Arbitrary::ArbitraryMethods
   extend Check::RunnerMethods
   extend Check::ConfigurationMethods
 
-  # @param args [Array<Pbt::Arbitrary>]
-  # @param kwargs [Hash<Symbol->Pbt::Arbitrary>]
+  # Create a property-based test with arbitraries. To run the test, pass the returned value to `Pbt.assert` method.
+  # Be aware that using both positional and keyword arguments is not supported.
+  #
+  # @example Basic usage
+  #   Pbt.property(Pbt.integer) do |n|
+  #     # your test code here
+  #   end
+  #
+  # @example Use multiple arbitraries
+  #   Pbt.property(Pbt.string, Pbt.symbol) do |str, sym|
+  #     # your test code here
+  #   end
+  #
+  # @example Use hash arbitraries
+  #   Pbt.property(x: Pbt.integer, y: Pbt.integer) do |x, y|
+  #     # your test code here
+  #   end
+  #
+  # @param args [Array<Arbitrary>] Arbitraries to generate values. You can pass one or more arbitraries.
+  # @param kwargs [Hash<Symbol,Arbitrary>] Arbitraries to generate values. You can pass arbitraries with keyword arguments.
+  # @param predicate [Proc] Test code that receives generated values and runs the test.
   # @return [Property]
   def self.property(*args, **kwargs, &predicate)
     arb = to_arbitrary(args, kwargs)
@@ -30,6 +51,11 @@ class << self
     # If multiple arguments are given, wrap them by tuple arbitrary.
     # If keyword arguments are given, wrap them by fixed hash arbitrary.
     # Else, return the single arbitrary.
+    #
+    # @param args [Array<Arbitrary>]
+    # @param kwargs [Hash<Symbol,Arbitrary>]
+    # @return [Arbitrary]
+    # @raise [ArgumentError] When both positional and keyword arguments are given
     def to_arbitrary(args, kwargs)
       if args == [] && kwargs != {}
         fixed_hash(kwargs)
diff --git a/lib/pbt/arbitrary/arbitrary.rb b/lib/pbt/arbitrary/arbitrary.rb
index fec10bd..93bd367 100644
--- a/lib/pbt/arbitrary/arbitrary.rb
+++ b/lib/pbt/arbitrary/arbitrary.rb
@@ -2,29 +2,54 @@
 
 module Pbt
   module Arbitrary
+    # Abstract class for generating random values on type `T`.
+    #
     # @abstract
     class Arbitrary
+      # Generate a value of type `T`, based on the provided random number generator.
+      #
       # @abstract
-      # @param rng [Random]
-      # @return [Object]
+      # @param rng [Random] Random number generator.
+      # @return [Object] Random value of type `T`.
       def generate(rng)
         raise NotImplementedError
       end
 
+      # Shrink a value of type `T`.
+      # Must never be called with possibly invalid values.
+      #
       # @abstract
       # @param current [Object]
-      # @return [Enumerator]
+      # @return [Enumerator<Object>]
       def shrink(current)
         raise NotImplementedError
       end
 
-      # @param mapper [Proc] a function to map the generated value. it's mainly used for #generate.
-      # @param unmapper [Proc] a function to unmap the generated value. it's used for #shrink.
+      # Create another arbitrary by applying `mapper` value by value.
+      #
+      # @example
+      #   integer_generator = Pbt.integer
+      #   num_str_generator = integer_arb.map(->(n){ n.to_s }, ->(s) {s.to_i})
+      #
+      # @param mapper [Proc] Proc to map generated values. Mainly used for generation.
+      # @param unmapper [Proc] Proc to unmap generated values. Used for shrinking.
+      # @return [MapArbitrary] New arbitrary with mapped elements
       def map(mapper, unmapper)
         MapArbitrary.new(self, mapper, unmapper)
       end
 
-      # @param refinement [Proc] a function to filter the generated value and shrunken values.
+      # Create another arbitrary by filtering values against `refinement`.
+      # All the values produced by the resulting arbitrary satisfy `!!refinement(value) == true`.
+      #
+      # Be aware that using `filter` may reduce possible valid values and may impact the time required to generate a valid value.
+      #
+      # @example
+      #   integer_generator = Pbt.integer
+      #   even_integer_generator = integer_arb.filter { |x| x.even? }
+      #   # or `integer_arb.filter(&:even?)`
+      #
+      # @param refinement [Proc] Predicate proc to test each produced element. Return true to keep the element, false otherwise.
+      # @return [FilterArbitrary] New arbitrary filtered using `refinement`.
       def filter(&refinement)
         FilterArbitrary.new(self, &refinement)
       end
diff --git a/lib/pbt/arbitrary/arbitrary_methods.rb b/lib/pbt/arbitrary/arbitrary_methods.rb
index c863f7e..25ef3f4 100644
--- a/lib/pbt/arbitrary/arbitrary_methods.rb
+++ b/lib/pbt/arbitrary/arbitrary_methods.rb
@@ -15,105 +15,201 @@
 module Pbt
   module Arbitrary
     module ArbitraryMethods
-      # @param min [Integer]
-      # @param max [Integer]
-      def integer(min: nil, max: nil)
+      # For integers between min (included) and max (included).
+      #
+      # @param min [Integer] Lower limit for the generated integers (included).
+      # @param max [Integer] Upper limit for the generated integers (included).
+      # @return [Arbitrary<Integer>]
+      def integer(min: -1000000, max: 1000000)
         IntegerArbitrary.new(min, max)
       end
 
-      # @param max [Integer]
+      # For natural numbers (non-negative integers) between 0 (included) and max (included).
+      #
+      # @param max [Integer] Upper limit for the generated integers (included).
+      # @return [Arbitrary<Integer>]
       def nat(max: nil)
         integer(min: 0, max: max)
       end
 
-      # @param arbitrary [Arbitrary]
-      # @param min [Integer]
-      # @param max [Integer]
-      # @param empty [Boolean]
-      def array(arbitrary, min: 0, max: 10, empty: true)
+      # For arrays of values generated by `arb`.
+      #
+      # @param arb [Arbitrary<T>] Arbitrary used to generate the values of the array.
+      # @param min [Integer] Lower limit of the generated array size.
+      # @param max [Integer] Upper limit of the generated array size.
+      # @param empty [Boolean] Whether the array can be empty or not.
+      # @return [Arbitrary<T>]
+      def array(arb, min: 0, max: 10, empty: true)
         raise ArgumentError if min < 0
         min = 1 if min.zero? && !empty
-        ArrayArbitrary.new(arbitrary, min, max)
+
+        ArrayArbitrary.new(arb, min, max)
       end
 
-      # @param arbs [Array<Pbt::Arbitrary>
+      # For tuples of values generated by `arbs`.
+      #
+      # @param arbs [Array<Arbitrary<...T>>] Arbitraries used to generate the values of the tuple.
+      # @return [Arbitrary<Array<...T>>]
       def tuple(*arbs)
         TupleArbitrary.new(*arbs)
       end
 
-      # @param hash [Hash<Symbol->Pbt::Arbitrary>]
+      # For fixed hashes of values generated by `hash`.
+      #
+      # @example
+      #   arb = Pbt.fixed_hash(x: Pbt.integer, y: Pbt.integer)
+      #   arb.generate(Random.new) # => {x: -450108, y: 42}
+      #
+      # @param hash [Hash<Object, Arbitrary<T>>] Hash with any keys and arbitraries as values.
+      # @return [Arbitrary<Hash<Object, T>>]
       def fixed_hash(hash)
         FixedHashArbitrary.new(hash)
       end
 
-      # @param range [Range<Integer>]
+      # Picks a random integer in the given range.
+      #
+      # @see Pbt.one_of
+      # @param range [Range<Integer>] Range of integers to choose from.
+      # @return [Arbitrary<Integer>]
       def choose(range)
         ChooseArbitrary.new(range)
       end
 
-      # @param choices [Array]
+      # Picks a random element from the given choices.
+      # The choices can be of any type.
+      #
+      # @see Pbt.one_of
+      # @param choices [Array<Object>] Array of choices.
+      # @return [Arbitrary<Object>]
       def one_of(*choices)
         OneOfArbitrary.new(choices)
       end
 
-      # One lowercase hexadecimal character
+      # For a lowercase hexadecimal character.
+      #
+      # @return [Arbitrary<String>]
       def hexa
         one_of(*HEXA_CHARS)
       end
 
+      # For lowercase hexadecimal stings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
       def hexa_string(**kwargs)
         array(hexa, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
-      # Generates a single unicode character (including printable and non-printable).
+      # For a single unicode character (including printable and non-printable).
+      #
+      # @return [Arbitrary<String>]
       def char
         choose(CHAR_RANGE).map(CHAR_MAPPER, CHAR_UNMAPPER)
       end
 
+      # For an alphanumeric character.
+      #
+      # @return [Arbitrary<String>]
       def alphanumeric_char
         one_of(*ALPHANUMERIC_CHARS)
       end
 
+      # For alphanumeric strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
       def alphanumeric_string(**kwargs)
         array(alphanumeric_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
+      # For an ascii character.
+      #
+      # @return [Arbitrary<String>]
       def ascii_char
         one_of(*ASCII_CHARS)
       end
 
+      # For ascii strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
       def ascii_string(**kwargs)
         array(ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
+      # For a printable ascii character.
+      #
+      # @return [Arbitrary<String>]
       def printable_ascii_char
         one_of(*PRINTABLE_ASCII_CHARS)
       end
 
+      # For printable ascii strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
       def printable_ascii_string(**kwargs)
         array(printable_ascii_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
+      # For a printable character.
+      #
+      # @return [Arbitrary<String>]
       def printable_char
         one_of(*PRINTABLE_CHARS)
       end
 
+      # For printable strings.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<String>]
       def printable_string(**kwargs)
         array(printable_char, **kwargs).map(STRING_MAPPER, STRING_UNMAPPER)
       end
 
+      # For symbols.
+      #
+      # @see Pbt.array
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<Symbol>]
       def symbol(**kwargs)
         array(one_of(*SYMBOL_SAFE_CHARS), empty: false, **kwargs).map(SYMBOL_MAPPER, SYMBOL_UNMAPPER)
       end
 
+      # For floats.
+      #
+      # @return [Arbitrary<Float>]
       def float
         tuple(integer, integer).map(FLOAT_MAPPER, FLOAT_UNMAPPER)
       end
 
-      def set(arbitrary, min: 0, max: nil, empty: true)
-        array(arbitrary, min: min, max: max, empty: empty).map(SET_MAPPER, SET_UNMAPPER)
+      # For symbols.
+      #
+      # @param arb [Arbitrary<T>] Arbitrary used to generate the values of the array.
+      # @param min [Integer] Lower limit of the generated set size.
+      # @param max [Integer] Upper limit of the generated set size.
+      # @param empty [Boolean] Whether the array can be empty or not.
+      # @return [Arbitrary<T>]
+      def set(arb, min: 0, max: 10, empty: true)
+        array(arb, min: min, max: max, empty: empty).map(SET_MAPPER, SET_UNMAPPER)
       end
 
+      # For hashes of any keys and values.
+      # If you want to call `Object#hash` for `Pbt`, call this method without arguments.
+      #
+      # @example
+      #   hash_generator = Pbt.hash(Pbt.symbol, Pbt.integer)
+      #   hash_generator.generate(Random.new) # => {:buo=>466214, :cwftzvglq=>331431, :wweccnzg=>-848867}
+      #
+      # @see Pbt.array
+      # @param args [Array<Arbitrary<T,U>>] Arbitraries to generate Hash. First one is for key and second is for value.
+      # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.
+      # @return [Arbitrary<Hash<T,U>>]
       def hash(*args, **kwargs)
         if args.size == 2
           key_arbitrary, value_arbitrary = args
@@ -123,41 +219,86 @@ def hash(*args, **kwargs)
         end
       end
 
+      # For booleans.
+      #
+      # @return [Arbitrary<Boolean>]
       def boolean
         one_of(true, false)
       end
 
+      # For any constant values.
+      # It's useful when you want to use a constant value that behaves like an arbitrary.
+      #
+      # @example
+      #   Pbt.constant(42).generate(Random.new) # => 42
+      #
       # @param val [Object]
+      # @return [Arbitrary<Object>]
       def constant(val)
         ConstantArbitrary.new(val)
       end
 
+      # For nil.
+      #
+      # @return [Arbitrary<nil>]
       def nil
         constant(nil)
       end
 
+      # For dates between `base_date + past_offset_days` and `base_date + future_offset_days`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param past_offset_days [Integer] Offset days for the past. Default is -18250 (about 50 years).
+      # @param future_offset_days [Integer] Offset days for the future. Default is 18250 (about 50 years).
+      # @return [Arbitrary<Date>]
       def date(base_date: Date.today, past_offset_days: -18250, future_offset_days: 18250)
         offset_arb = integer(min: past_offset_days, max: future_offset_days)
         offset_arb.map(DATE_MAPPER.call(base_date), DATE_UNMAPPER.call(base_date))
       end
 
+      # For past dates between `base_date - past_offset_days` and `base_date`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param past_offset_days [Integer] Offset days for the past. Default is -18250 (about 50 years).
+      # @return [Arbitrary<Date>]
       def past_date(base_date: Date.today, past_offset_days: -18250)
         date(base_date: base_date, past_offset_days: past_offset_days, future_offset_days: 0)
       end
 
+      # For future dates between `base_date` and `base_date - future_offset_days`.
+      #
+      # @param base_date [Date] Base date for the generated dates.
+      # @param future_offset_days [Integer] Offset days for the future. Default is 18250 (about 50 years).
+      # @return [Arbitrary<Date>]
       def future_date(base_date: Date.today, future_offset_days: 18250)
         date(base_date: base_date, past_offset_days: 0, future_offset_days: future_offset_days)
       end
 
+      # For times between `base_time + past_offset_seconds` and `base_time + future_offset_seconds`.
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param past_offset_seconds [Integer] Offset seconds for the past. Default is -1576800000 (about 50 years).
+      # @param future_offset_seconds [Integer] Offset seconds for the future. Default is 1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
       def time(base_time: Time.now, past_offset_seconds: -1576800000, future_offset_seconds: 1576800000)
         offset_arb = integer(min: past_offset_seconds, max: future_offset_seconds)
         offset_arb.map(TIME_MAPPER.call(base_time), TIME_UNMAPPER.call(base_time))
       end
 
+      # For past times between `base_time + past_offset_seconds` and `base_time`
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param past_offset_seconds [Integer] Offset seconds for the past. Default is -1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
       def past_time(base_time: Time.now, past_offset_seconds: -1576800000)
         time(base_time: base_time, past_offset_seconds: past_offset_seconds, future_offset_seconds: 0)
       end
 
+      # For future times between `base_time` and `base_time + future_offset_seconds`.
+      #
+      # @param base_time [Date] Base time for the generated times.
+      # @param future_offset_seconds [Integer] Offset seconds for the future. Default is 1576800000 (about 50 years).
+      # @return [Arbitrary<Time>]
       def future_time(base_time: Time.now, future_offset_seconds: 1576800000)
         time(base_time: base_time, past_offset_seconds: 0, future_offset_seconds: future_offset_seconds)
       end
diff --git a/lib/pbt/arbitrary/array_arbitrary.rb b/lib/pbt/arbitrary/array_arbitrary.rb
index 9494f9a..833870d 100644
--- a/lib/pbt/arbitrary/array_arbitrary.rb
+++ b/lib/pbt/arbitrary/array_arbitrary.rb
@@ -2,34 +2,36 @@
 
 module Pbt
   module Arbitrary
+    # Generates arrays of values generated by `value_arb` with type `T`.
     class ArrayArbitrary < Arbitrary
       DEFAULT_MAX_SIZE = 10
+      private_constant :DEFAULT_MAX_SIZE
 
-      # @param min_length [Integer]
-      # @param max_length [Integer]
-      def initialize(arbitrary, min_length = 0, max_length = DEFAULT_MAX_SIZE)
+      # @param value_arb [Arbitrary] Arbitrary to generate values.
+      # @param min_length [Integer] Minimum length of the generated array. Default is 0.
+      # @param max_length [Integer] Maximum length of the generated array. Default is 10.
+      def initialize(value_arb, min_length = 0, max_length = DEFAULT_MAX_SIZE)
         raise ArgumentError, "min_length must be zero or positive number" if min_length < 0
 
         @min_length = min_length
         @max_length = max_length
-        @arbitrary = arbitrary
+        @value_arb = value_arb
         @length_arb = IntegerArbitrary.new(min_length, max_length)
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
-        size = @length_arb.generate(rng)
-        size.times.map { @arbitrary.generate(rng) }
+        length = @length_arb.generate(rng)
+        length.times.map { @value_arb.generate(rng) }
       end
 
-      # Returns shrunken arrays.
-      # This doesn't produce all possible patterns because it could be too large (+1000) even for small arrays.
-      # @param current [Array]
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
         return Enumerator.new { |_| } if current.size == @min_length
 
         Enumerator.new do |y|
+          # First, shrink the length of the array and try combinations of elements.
+          # But this doesn't try all possible combinations since it'd be too huge and slow.
           @length_arb.shrink(current.size).each do |length|
             if length == 0
               y.yield []
@@ -40,8 +42,9 @@ def shrink(current)
             end
           end
 
+          # Second, shrink each element of the array.
           current.each_with_index do |item, i|
-            @arbitrary.shrink(item).each do |val|
+            @value_arb.shrink(item).each do |val|
               y.yield [*current[...i], val, *current[i + 1..]]
             end
           end
diff --git a/lib/pbt/arbitrary/choose_arbitrary.rb b/lib/pbt/arbitrary/choose_arbitrary.rb
index 9e297e9..afb3ab8 100644
--- a/lib/pbt/arbitrary/choose_arbitrary.rb
+++ b/lib/pbt/arbitrary/choose_arbitrary.rb
@@ -2,20 +2,21 @@
 
 module Pbt
   module Arbitrary
+    # Generates a random value from a range.
     class ChooseArbitrary < Arbitrary
       # @param range [Range<Integer>]
       def initialize(range)
         @range = range
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         rng.rand(@range)
       end
 
-      # range is ordered from min to max, so we can just shrink towards min
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
+        # Range is ordered from min to max, so we can just shrink towards min.
         min, max = [@range.begin, @range.end].sort
         IntegerArbitrary.new(min, max).shrink(current, target: min)
       end
diff --git a/lib/pbt/arbitrary/constant.rb b/lib/pbt/arbitrary/constant.rb
index 6a3221e..5d60869 100644
--- a/lib/pbt/arbitrary/constant.rb
+++ b/lib/pbt/arbitrary/constant.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "date"
-require "set" # For 3.1 or prior. Ruby 3.2.0 has Set in the built-in library.
+require "set" # For 3.1 or prior. Set became built-in library since Ruby 3.2.0
 
 module Pbt
   module Arbitrary
diff --git a/lib/pbt/arbitrary/constant_arbitrary.rb b/lib/pbt/arbitrary/constant_arbitrary.rb
index cc5b947..cd2d4d2 100644
--- a/lib/pbt/arbitrary/constant_arbitrary.rb
+++ b/lib/pbt/arbitrary/constant_arbitrary.rb
@@ -2,18 +2,19 @@
 
 module Pbt
   module Arbitrary
+    # Generates a constant value.
     class ConstantArbitrary < Arbitrary
-      # @param val [Object
+      # @param val [Object]
       def initialize(val)
         @val = val
       end
 
-      # @return [Object]
+      # @see Arbitrary#generate
       def generate(rng)
         @val
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
         Enumerator.new {}
       end
diff --git a/lib/pbt/arbitrary/filter_arbitrary.rb b/lib/pbt/arbitrary/filter_arbitrary.rb
index 0a5b922..99cd2a2 100644
--- a/lib/pbt/arbitrary/filter_arbitrary.rb
+++ b/lib/pbt/arbitrary/filter_arbitrary.rb
@@ -2,16 +2,16 @@
 
 module Pbt
   module Arbitrary
+    # Generates values from another arbitrary, but only if they pass a predicate.
     class FilterArbitrary < Arbitrary
-      # @param arb [ArrayArbitrary]
-      # @param refinement [Proc] a function to filter the generated value and shrunken values.
-      #
+      # @param arb [Arbitrary] Arbitrary to generate values to be filtered.
+      # @param refinement [Proc] Predicate proc to test each produced element. Return true to keep the element, false otherwise.
       def initialize(arb, &refinement)
         @arb = arb
         @refinement = refinement
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         loop do
           val = @arb.generate(rng)
@@ -19,7 +19,7 @@ def generate(rng)
         end
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
         Enumerator.new do |y|
           @arb.shrink(current).each do |v|
diff --git a/lib/pbt/arbitrary/fixed_hash_arbitrary.rb b/lib/pbt/arbitrary/fixed_hash_arbitrary.rb
index 4b8897f..e21f7be 100644
--- a/lib/pbt/arbitrary/fixed_hash_arbitrary.rb
+++ b/lib/pbt/arbitrary/fixed_hash_arbitrary.rb
@@ -2,20 +2,21 @@
 
 module Pbt
   module Arbitrary
+    # Generates a hash with fixed keys and arbitrary values.
     class FixedHashArbitrary < Arbitrary
-      # @param hash [Hash<Symbol->Pbt::Arbitrary>]
+      # @param hash [Hash<Object, Arbitrary<T>>] Hash with any keys and arbitraries as values.
       def initialize(hash)
         @keys = hash.keys
         @arb = TupleArbitrary.new(*hash.values)
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         values = @arb.generate(rng)
         @keys.zip(values).to_h
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
         # This is not the most comprehensive but allows a reasonable number of entries in the shrink
         Enumerator.new do |y|
diff --git a/lib/pbt/arbitrary/integer_arbitrary.rb b/lib/pbt/arbitrary/integer_arbitrary.rb
index 230c976..b225926 100644
--- a/lib/pbt/arbitrary/integer_arbitrary.rb
+++ b/lib/pbt/arbitrary/integer_arbitrary.rb
@@ -2,23 +2,24 @@
 
 module Pbt
   module Arbitrary
+    # Generates random integers between `min` and `max`.
     class IntegerArbitrary < Arbitrary
       DEFAULT_TARGET = 0
-      DEFAULT_SIZE = 1000000
+      private_constant :DEFAULT_TARGET
 
-      # @param min [Integer]
-      # @param max [Integer]
-      def initialize(min = nil, max = nil)
-        @max = max || DEFAULT_SIZE
-        @min = min || -DEFAULT_SIZE
+      # @param min [Integer] Minimum value to generate.
+      # @param max [Integer] Maximum value to generate.
+      def initialize(min, max)
+        @min = min
+        @max = max
       end
 
-      # @return [Integer]
+      # @see Arbitrary#generate
       def generate(rng)
         rng.rand(@min..@max)
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current, target: DEFAULT_TARGET)
         gap = current - target
         return Enumerator.new { |_| } if gap == 0
diff --git a/lib/pbt/arbitrary/map_arbitrary.rb b/lib/pbt/arbitrary/map_arbitrary.rb
index 10e391c..ff5b26e 100644
--- a/lib/pbt/arbitrary/map_arbitrary.rb
+++ b/lib/pbt/arbitrary/map_arbitrary.rb
@@ -2,20 +2,23 @@
 
 module Pbt
   module Arbitrary
+    # Generates a mapped value from another arbitrary.
     class MapArbitrary < Arbitrary
-      # @param arb [ArrayArbitrary]
+      # @param arb [Arbitrary] Arbitrary to generate values to be mapped.
+      # @param mapper [Proc] Proc to map generated values. Mainly used for generation.
+      # @param unmapper [Proc] Proc to unmap generated values. Used for shrinking.
       def initialize(arb, mapper, unmapper)
         @arb = arb
         @mapper = mapper
         @unmapper = unmapper
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         @mapper.call(@arb.generate(rng))
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
         Enumerator.new do |y|
           @arb.shrink(@unmapper.call(current)).each do |v|
diff --git a/lib/pbt/arbitrary/one_of_arbitrary.rb b/lib/pbt/arbitrary/one_of_arbitrary.rb
index 75df9f9..55abf2f 100644
--- a/lib/pbt/arbitrary/one_of_arbitrary.rb
+++ b/lib/pbt/arbitrary/one_of_arbitrary.rb
@@ -2,21 +2,22 @@
 
 module Pbt
   module Arbitrary
+    # Generates one of the given choices.
     class OneOfArbitrary < Arbitrary
-      # @param choices [Array]
+      # @param choices [Array] List of choices.
       def initialize(choices)
         @choices = choices
         @idx_arb = IntegerArbitrary.new(0, choices.size - 1)
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         @choices[@idx_arb.generate(rng)]
       end
 
-      # Shrinks to values earlier in the list of `choices`.
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
+        # Shrinks to values earlier in the list of `choices`.
         Enumerator.new do |y|
           @idx_arb.shrink(@choices.index(current)).map do |idx|
             y << @choices[idx]
diff --git a/lib/pbt/arbitrary/tuple_arbitrary.rb b/lib/pbt/arbitrary/tuple_arbitrary.rb
index fff4f30..376c990 100644
--- a/lib/pbt/arbitrary/tuple_arbitrary.rb
+++ b/lib/pbt/arbitrary/tuple_arbitrary.rb
@@ -2,20 +2,21 @@
 
 module Pbt
   module Arbitrary
+    # Generates a tuple of arbitrary values.
     class TupleArbitrary < Arbitrary
-      # @param arbs [Array<Pbt::Arbitrary>]
+      # @param arbs [Array<Arbitrary>] Arbitraries used to generate the values of the tuple.
       def initialize(*arbs)
         @arbs = arbs
       end
 
-      # @return [Array]
+      # @see Arbitrary#generate
       def generate(rng)
         @arbs.map { |arb| arb.generate(rng) }
       end
 
-      # @return [Enumerator]
+      # @see Arbitrary#shrink
       def shrink(current)
-        # This is not the most comprehensive but allows a reasonable number of entries in the shrink
+        # This is not the most comprehensive but allows a reasonable number of entries in the shrink.
         Enumerator.new do |y|
           @arbs.each_with_index do |arb, idx|
             arb.shrink(current[idx]).each do |v|
diff --git a/lib/pbt/check/case.rb b/lib/pbt/check/case.rb
index 49bc5a9..945f379 100644
--- a/lib/pbt/check/case.rb
+++ b/lib/pbt/check/case.rb
@@ -2,6 +2,7 @@
 
 module Pbt
   module Check
+    # @private
     Case = Struct.new(:val, :ractor, :exception, :index, keyword_init: true)
   end
 end
diff --git a/lib/pbt/check/configuration.rb b/lib/pbt/check/configuration.rb
index 609cf28..cab02f3 100644
--- a/lib/pbt/check/configuration.rb
+++ b/lib/pbt/check/configuration.rb
@@ -2,17 +2,23 @@
 
 module Pbt
   module Check
+    # Configuration for Pbt.
     Configuration = Struct.new(
       :verbose,
-      :concurrency_method,
+      :worker,
       :num_runs,
       :seed,
       :thread_report_on_exception,
       keyword_init: true
     ) do
+      # @param verbose [Boolean] Whether to print verbose output. Default is `false`.
+      # @param worker [Symbol] The concurrency method to use. :ractor`, `:thread`, `:process` and `:none` are supported. Default is `:ractor`.
+      # @param num_runs [Integer] The number of runs to perform. Default is `100`.
+      # @param seed [Integer] The seed to use for random number generation. It's useful to reproduce failed test with the seed you'd pick up from failure messages. Default is a random seed.
+      # @param thread_report_on_exception [Boolean] Whether to report exceptions in threads. It's useful to suppress error logs on Ractor that reports many errors. Default is `false`.
       def initialize(
         verbose: false,
-        concurrency_method: :ractor,
+        worker: :ractor,
         num_runs: 100,
         seed: Random.new.seed,
         thread_report_on_exception: false
@@ -22,10 +28,28 @@ def initialize(
     end
 
     module ConfigurationMethods
+      # Return the current configuration.
+      # If you modify the configuration, it will affect all future property-based tests.
+      #
+      # @example
+      #   config = Pbt.configuration
+      #   config.num_runs = 20
+      #
+      # @return [Configuration]
       def configuration
         @configuration ||= Configuration.new
       end
 
+      # Return the current configuration.
+      # If you modify the configuration, it will affect all future property-based tests.
+      #
+      # @example
+      #   Pbt.configure do |config|
+      #     config.num_runs = 20
+      #   end
+      #
+      # @yield [configuration] The current configuration.
+      # @yieldparam configuration [Configuration]
       def configure
         yield(configuration)
       end
diff --git a/lib/pbt/check/property.rb b/lib/pbt/check/property.rb
index 517ccc3..8091ba8 100644
--- a/lib/pbt/check/property.rb
+++ b/lib/pbt/check/property.rb
@@ -2,32 +2,44 @@
 
 module Pbt
   module Check
+    # Represents a property to be tested.
+    # This class holds an arbitrary to generate values and a predicate to test them.
     class Property
-      # @param arb [Array<Pbt::Arbitrary>]
-      # @param predicate [Proc]
+      # @param arb [Array<Arbitrary>]
+      # @param predicate [Proc] Predicate proc to test the generated values. Library users write this.
       def initialize(arb, &predicate)
         @arb = arb
         @predicate = predicate
       end
 
-      # @param rng [Random]
+      # Generate a next value to test.
+      #
+      # @param rng [Random] Random number generator.
       # @return [Object]
       def generate(rng)
         @arb.generate(rng)
       end
 
+      # Shrink the `val` to a smaller one.
+      # This is used to find the smallest failing case after a failure.
+      #
       # @param val [Object]
-      # @return [Object]
+      # @return [Enumerator<Object>]
       def shrink(val)
         @arb.shrink(val)
       end
 
+      # Run the predicate with the generated `val`.
+      #
       # @param val [Object]
       # @return [void]
       def run(val)
         @predicate.call(val)
       end
 
+      # Run the predicate with the generated `val` in a Ractor.
+      # This is used only for parallel testing with Ractors.
+      #
       # @param val [Object]
       # @return [Ractor]
       def run_in_ractor(val)
diff --git a/lib/pbt/check/runner_iterator.rb b/lib/pbt/check/runner_iterator.rb
index e87aec2..2d48fc1 100644
--- a/lib/pbt/check/runner_iterator.rb
+++ b/lib/pbt/check/runner_iterator.rb
@@ -5,12 +5,16 @@
 
 module Pbt
   module Check
+    # This class is an iterator of the generated/shrunken values.
+    #
+    # @private
+    # @!attribute [r] run_execution [Reporter::RunExecution]
     class RunnerIterator < DelegateClass(Array)
       attr_reader :run_execution
 
-      # @param source_values [Enumerator]
-      # @param property [Property]
-      # @param verbose [Boolean]
+      # @param source_values [Enumerator] Enumerator of generated values by arbitrary. This is used to determine initial N (=`num_runs`) cases.
+      # @param property [Property] Property to test. This is used to shrink the failed case.
+      # @param verbose [Boolean] Controls the verbosity of the output.
       def initialize(source_values, property, verbose)
         @run_execution = Reporter::RunExecution.new(verbose)
         @property = property
@@ -23,6 +27,9 @@ def initialize(source_values, property, verbose)
         super(enumerator) # delegate `#each` and etc. to enumerator
       end
 
+      # Check if there is a next value to test.
+      # If there is no next value, it returns false. Otherwise true.
+      #
       # @return [Boolean]
       def has_next?
         @next_values.peek
@@ -31,7 +38,11 @@ def has_next?
         false
       end
 
-      # @param c [Pbt::Check::Case]
+      # Handle result of a test.
+      # When a test is successful, it records the success.
+      # When a test is failed, it records the failure and set up the next values to test with property#shrink.
+      #
+      # @param c [Case]
       # @return [void]
       def handle_result(c)
         if c.exception
diff --git a/lib/pbt/check/runner_methods.rb b/lib/pbt/check/runner_methods.rb
index 73ba537..bfdbf02 100644
--- a/lib/pbt/check/runner_methods.rb
+++ b/lib/pbt/check/runner_methods.rb
@@ -7,22 +7,30 @@
 
 module Pbt
   module Check
+    # Module to be
     module RunnerMethods
       include Check::Tosser
 
-      # `assert` runs a property based test and reports its result.
-      # @param options [Hash]
-      # @param property [Proc]
+      # Run a property based test and report its result.
+      #
+      # @see Check::Configuration
+      # @param options [Hash] Optional parameters to customize the execution.
+      # @param property [Proc] Proc that returns Property instance.
       # @return [void]
+      # @raise [PropertyFailure]
       def assert(**options, &property)
         out = check(**options, &property)
         Reporter::RunDetailsReporter.new(out).report_run_details
       end
 
-      # `check` runs a property based test and return its result.
+      # Run a property based test and return its result.
+      # This doesn't throw contrary to `assert`.
       # Use `assert` unless you want to handle the result.
-      # @param options [Hash]
-      # @param property [Proc]
+      #
+      # @see RunnerMethods#assert
+      # @see Check::Configuration
+      # @param options [Hash] Optional parameters to customize the execution.
+      # @param property [Proc] Proc that returns Property instance.
       # @return [RunDetails]
       def check(**options, &property)
         property = property.call
@@ -43,26 +51,30 @@ def check(**options, &property)
       private
 
       # If using Ractor, so many exception reports happen in Ractor and a console gets too messy. Suppress them to avoid that.
-      # @param config [Hash]
+      #
+      # @param config [Hash] Configuration parameters.
+      # @param block [Proc]
       def suppress_exception_report_for_ractor(config, &block)
-        if config[:concurrency_method] == :ractor
+        if config[:worker] == :ractor
           original_report_on_exception = Thread.report_on_exception
           Thread.report_on_exception = config[:thread_report_on_exception]
         end
 
         yield
       ensure
-        Thread.report_on_exception = original_report_on_exception if config[:concurrency_method] == :ractor
+        Thread.report_on_exception = original_report_on_exception if config[:worker] == :ractor
       end
 
-      # @param property [Proc]
-      # @param source_values [Enumerator]
-      # @param options [Hash]
-      # @return [RunExecution]
-      def run_it(property, source_values, options)
-        runner = Check::RunnerIterator.new(source_values, property, options[:verbose])
+      # Run the property test for each value.
+      #
+      # @param property [Proc] Property to test.
+      # @param source_values [Enumerator] Enumerator of values to test.
+      # @param config [Hash] Configuration parameters.
+      # @return [RunExecution] Result of the test.
+      def run_it(property, source_values, config)
+        runner = Check::RunnerIterator.new(source_values, property, config[:verbose])
         while runner.has_next?
-          case options[:concurrency_method]
+          case config[:worker]
           in :ractor
             run_it_in_ractors(property, runner)
           in :process
@@ -151,11 +163,14 @@ def run_it_in_sequential(property, runner)
         end
       end
 
+      # Load Parallel gem. If it's not installed, raise an error.
+      # @see https://github.com/grosser/parallel
+      # @raise [InvalidConfiguration]
       def require_parallel
         require "parallel"
-      rescue
+      rescue LoadError
         raise InvalidConfiguration,
-          "Parallel gem is required to use concurrency_method `:process` or `:thread`. Please add `gem 'parallel'` to your Gemfile."
+          "Parallel gem (https://github.com/grosser/parallel) is required to use worker `:process` or `:thread`. Please add `gem 'parallel'` to your Gemfile."
       end
     end
   end
diff --git a/lib/pbt/check/tosser.rb b/lib/pbt/check/tosser.rb
index 997b51e..78ae4a5 100644
--- a/lib/pbt/check/tosser.rb
+++ b/lib/pbt/check/tosser.rb
@@ -2,19 +2,31 @@
 
 module Pbt
   module Check
+    # Module to be included in classes that need to generate values to test.
     module Tosser
-      def toss_next(generator, rng)
-        generator.generate(rng)
-      end
-
-      def toss(generator, seed)
+      # Generate values.
+      #
+      # @param arb [Arbitrary] Arbitrary to generate a value.
+      # @param seed [Integer] Random number generator's seed.
+      # @return [Enumerator]
+      def toss(arb, seed)
         Enumerator.new do |enum|
           rng = Random.new(seed)
           loop do
-            enum.yield toss_next(generator, rng)
+            enum.yield toss_next(arb, rng)
           end
         end
       end
+
+      private
+
+      # Generate next value.
+      #
+      # @param arb [Arbitrary] Arbitrary to generate a value.
+      # @param rng [Random] Random number generator.
+      def toss_next(arb, rng)
+        arb.generate(rng)
+      end
     end
   end
 end
diff --git a/lib/pbt/reporter/run_details.rb b/lib/pbt/reporter/run_details.rb
index b4b2151..ed170d9 100644
--- a/lib/pbt/reporter/run_details.rb
+++ b/lib/pbt/reporter/run_details.rb
@@ -2,6 +2,7 @@
 
 module Pbt
   module Reporter
+    # Details of a single run of a property test.
     RunDetails = Struct.new(
       :failed,
       :num_runs,
diff --git a/lib/pbt/reporter/run_details_reporter.rb b/lib/pbt/reporter/run_details_reporter.rb
index 32e3029..e02a794 100644
--- a/lib/pbt/reporter/run_details_reporter.rb
+++ b/lib/pbt/reporter/run_details_reporter.rb
@@ -2,12 +2,16 @@
 
 module Pbt
   module Reporter
+    # Reporter for the run details of a property test.
     class RunDetailsReporter
-      # @param [Pbt::Reporter::RunExecution] run_details
+      # @param run_details [Pbt::Reporter::RunExecution]
       def initialize(run_details)
         @run_details = run_details
       end
 
+      # Report the run details of a property test.
+      # If the property test failed, raise a PropertyFailure.
+      #
       # @raise [PropertyFailure]
       def report_run_details
         if @run_details.failed
diff --git a/lib/pbt/reporter/run_execution.rb b/lib/pbt/reporter/run_execution.rb
index 7c94029..6d6dfac 100644
--- a/lib/pbt/reporter/run_execution.rb
+++ b/lib/pbt/reporter/run_execution.rb
@@ -4,8 +4,9 @@
 
 module Pbt
   module Reporter
+    # Represents the result of a single run of a property test.
     class RunExecution
-      # @param verbose [Boolean]
+      # @param verbose [Boolean] Whether to print verbose output.
       def initialize(verbose)
         @verbose = verbose
         @path_to_failure = []
@@ -14,6 +15,8 @@ def initialize(verbose)
         @num_successes = 0
       end
 
+      # Record a failure in the run.
+      #
       # @param c [Pbt::Check::Case]
       def record_failure(c)
         @path_to_failure << c.index
@@ -24,42 +27,52 @@ def record_failure(c)
         @failure = c.exception
       end
 
+      # Record a successful run.
+      #
+      # @return [void]
       def record_success
         @num_successes += 1
       end
 
+      # Whether the test was successful.
+      #
+      # @return [Boolean]
       def success?
         !@failure
       end
 
-      def to_run_details(params)
+      # Convert execution to run details.
+      #
+      # @param config [Hash] Configuration parameters used for the run.
+      # @return [RunDetails] Details of the run.
+      def to_run_details(config)
         if success?
           RunDetails.new(
             failed: false,
             num_runs: @num_successes,
             num_shrinks: 0,
-            seed: params[:seed],
+            seed: config[:seed],
             counterexample: nil,
             counterexample_path: nil,
             error_message: nil,
             error_instance: nil,
             failures: @failures,
             verbose: @verbose,
-            run_configuration: params
+            run_configuration: config
           )
         else
           RunDetails.new(
             failed: true,
             num_runs: @path_to_failure[0] + 1,
             num_shrinks: @path_to_failure.size - 1,
-            seed: params[:seed],
+            seed: config[:seed],
             counterexample: @value,
             counterexample_path: @path_to_failure.join(":"),
             error_message: @failure.message,
             error_instance: @failure,
             failures: @failures,
             verbose: @verbose,
-            run_configuration: params
+            run_configuration: config
           )
         end
       end
diff --git a/spec/pbt/arbitrary/integer_arbitrary_spec.rb b/spec/pbt/arbitrary/integer_arbitrary_spec.rb
index 888263a..90851b4 100644
--- a/spec/pbt/arbitrary/integer_arbitrary_spec.rb
+++ b/spec/pbt/arbitrary/integer_arbitrary_spec.rb
@@ -3,7 +3,7 @@
 RSpec.describe Pbt::Arbitrary::IntegerArbitrary do
   describe "#generate" do
     it "generates an integer" do
-      val = Pbt::Arbitrary::IntegerArbitrary.new.generate(Random.new)
+      val = Pbt.integer.generate(Random.new)
       expect(val).to be_a(Integer)
     end
 
@@ -20,35 +20,35 @@
 
   describe "#shrink" do
     it "returns an Enumerator" do
-      arb = Pbt::Arbitrary::IntegerArbitrary.new
+      arb = Pbt.integer
       val = arb.generate(Random.new)
       expect(arb.shrink(val)).to be_a(Enumerator)
     end
 
     it "returns an Enumerator that iterates numbers down to 0 asymptotically" do
-      arb = Pbt::Arbitrary::IntegerArbitrary.new
+      arb = Pbt.integer
       expect(arb.shrink(100).to_a).to eq [50, 25, 13, 7, 4, 2, 1, 0]
     end
 
     it "returns an Enumerator that iterates numbers up to 0 asymptotically" do
-      arb = Pbt::Arbitrary::IntegerArbitrary.new
+      arb = Pbt.integer
       expect(arb.shrink(-100).to_a).to eq [-50, -25, -13, -7, -4, -2, -1, 0]
     end
 
     describe "target" do
       it "returns an Enumerator that iterates numbers up to target asymptotically" do
-        arb = Pbt::Arbitrary::IntegerArbitrary.new
+        arb = Pbt.integer
         expect(arb.shrink(100, target: 200).to_a).to eq [150, 175, 187, 193, 196, 198, 199, 200]
       end
 
       it "returns an Enumerator that iterates numbers down to target asymptotically" do
-        arb = Pbt::Arbitrary::IntegerArbitrary.new
+        arb = Pbt.integer
         expect(arb.shrink(-100, target: -200).to_a).to eq [-150, -175, -187, -193, -196, -198, -199, -200]
       end
 
       context "when current value and target is same" do
         it "returns an empty Enumerator" do
-          arb = Pbt::Arbitrary::IntegerArbitrary.new
+          arb = Pbt.integer
           expect(arb.shrink(0, target: 0).to_a).to eq []
         end
       end
diff --git a/spec/pbt/check/configuration_spec.rb b/spec/pbt/check/configuration_spec.rb
index fdc292f..978183a 100644
--- a/spec/pbt/check/configuration_spec.rb
+++ b/spec/pbt/check/configuration_spec.rb
@@ -6,7 +6,7 @@
       describe "for each runners" do
         it "can be configured for each runner" do
           runs = 0
-          Pbt.assert num_runs: 5, concurrency_method: :none do
+          Pbt.assert num_runs: 5, worker: :none do
             Pbt.property(Pbt.integer) do |_|
               runs += 1 # To count the number of runs, this test disables Ractor
             end
@@ -19,7 +19,7 @@
         around do |ex|
           Pbt.configure do |config|
             config.num_runs = 2
-            config.concurrency_method = :none
+            config.worker = :none
           end
 
           ex.run
@@ -27,7 +27,7 @@
           # rollback the configuration
           Pbt.configure do |config|
             config.num_runs = 100
-            config.concurrency_method = :ractor
+            config.worker = :ractor
           end
         end
 
@@ -40,11 +40,11 @@
       end
     end
 
-    describe "concurrency_method" do
+    describe "worker" do
       describe ":ractor" do
         context "when all cases pass" do
           it "reports success" do
-            run_details = Pbt.check num_runs: 5, concurrency_method: :ractor do
+            run_details = Pbt.check num_runs: 5, worker: :ractor do
               Pbt.property(Pbt.integer) {}
             end
 
@@ -61,7 +61,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :ractor,
+                worker: :ractor,
                 num_runs: 5,
                 seed: anything,
                 thread_report_on_exception: false
@@ -76,7 +76,7 @@
 
             # This seed generates [5, 1, 4] and the 4 fails.
             # Then it shrinks from 4 towards with [3, 2, 1] and finds 2 as the smallest counterexample.
-            run_details = Pbt.check num_runs: 10, concurrency_method: :ractor, seed: do
+            run_details = Pbt.check num_runs: 10, worker: :ractor, seed: do
               Pbt.property(Pbt.one_of(1, 2, 3, 4, 5)) do |n|
                 raise "dummy error" if n % 2 == 0
               end
@@ -95,7 +95,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :ractor,
+                worker: :ractor,
                 num_runs: 10,
                 seed:,
                 thread_report_on_exception: false
@@ -108,7 +108,7 @@
       describe ":thread" do
         context "when all cases pass" do
           it "reports success" do
-            run_details = Pbt.check num_runs: 5, concurrency_method: :thread do
+            run_details = Pbt.check num_runs: 5, worker: :thread do
               Pbt.property(Pbt.integer) {}
             end
 
@@ -125,7 +125,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :thread,
+                worker: :thread,
                 num_runs: 5,
                 seed: anything,
                 thread_report_on_exception: false
@@ -140,7 +140,7 @@
 
             # This seed generates [5, 1, 4] and the 4 fails.
             # Then it shrinks from 4 towards with [3, 2, 1] and finds 2 as the smallest counterexample.
-            run_details = Pbt.check num_runs: 10, concurrency_method: :thread, seed: do
+            run_details = Pbt.check num_runs: 10, worker: :thread, seed: do
               Pbt.property(Pbt.one_of(1, 2, 3, 4, 5)) do |n|
                 raise "dummy error" if n % 2 == 0
               end
@@ -159,7 +159,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :thread,
+                worker: :thread,
                 num_runs: 10,
                 seed:,
                 thread_report_on_exception: false
@@ -172,7 +172,7 @@
       describe ":process" do
         context "when all cases pass" do
           it "reports success" do
-            run_details = Pbt.check num_runs: 5, concurrency_method: :process do
+            run_details = Pbt.check num_runs: 5, worker: :process do
               Pbt.property(Pbt.integer) {}
             end
 
@@ -189,7 +189,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :process,
+                worker: :process,
                 num_runs: 5,
                 seed: anything,
                 thread_report_on_exception: false
@@ -204,7 +204,7 @@
 
             # This seed generates [5, 1, 4] and the 4 fails.
             # Then it shrinks from 4 towards with [3, 2, 1] and finds 2 as the smallest counterexample.
-            run_details = Pbt.check num_runs: 10, concurrency_method: :process, seed: do
+            run_details = Pbt.check num_runs: 10, worker: :process, seed: do
               Pbt.property(Pbt.one_of(1, 2, 3, 4, 5)) do |n|
                 raise "dummy error" if n % 2 == 0
               end
@@ -223,7 +223,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :process,
+                worker: :process,
                 num_runs: 10,
                 seed:,
                 thread_report_on_exception: false
@@ -236,7 +236,7 @@
       describe ":none" do
         context "when all cases pass" do
           it "reports success" do
-            run_details = Pbt.check num_runs: 5, concurrency_method: :none do
+            run_details = Pbt.check num_runs: 5, worker: :none do
               Pbt.property(Pbt.integer) {}
             end
 
@@ -253,7 +253,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :none,
+                worker: :none,
                 num_runs: 5,
                 seed: anything,
                 thread_report_on_exception: false
@@ -268,7 +268,7 @@
 
             # This seed generates [5, 1, 4] and the 4 fails.
             # Then it shrinks from 4 towards with [3, 2, 1] and finds 2 as the smallest counterexample.
-            run_details = Pbt.check num_runs: 10, concurrency_method: :none, seed: do
+            run_details = Pbt.check num_runs: 10, worker: :none, seed: do
               Pbt.property(Pbt.one_of(1, 2, 3, 4, 5)) do |n|
                 raise "dummy error" if n % 2 == 0
               end
@@ -287,7 +287,7 @@
               verbose: false,
               run_configuration: {
                 verbose: false,
-                concurrency_method: :none,
+                worker: :none,
                 num_runs: 10,
                 seed:,
                 thread_report_on_exception: false