We can see many implementations for calculating all subclasses of a particular class from the Ruby community with different gems. The ActiveSupport::DescendantsTracker is one of such implementations used in Rails framework. Finally, Ruby has added the Class#subclasses native implementation for it's 3.1 version release.

After Ruby 3.1

=> class User; end
=> class Employee < User; end
=> class Client < User; end

=> class Manager < Employee; end
=> class Developer < Employee; end

=> User.subclasses
=> [Employee, Client]

=> Employee.subclasses
=> [Manager, Developer]

=> Developer.subclasses
=> []

Here's the relevant pull request and feature discussion for this change.

=> str = "Ruby 3.1 introduces MatchData#match method"
=>  m = /(?<lang>\S+)(\s)(?<version>[\d\.]+)/.match(str)
=> #<MatchData "Ruby 3.1" lang:"Ruby" version:"3.1">

Before Ruby 3.1

We have MatchData#[] method to access all the substring groups that are matched. We can access either a single match or multiple matches by giving a single index or a range of indexes, respectively, using MatchData#[] method.

=> m[:lang]
=> "Ruby"

=> m[1]
=> "Ruby"
=> m[:version]
=> "3.1"

=> m[0..2]
=> ["Ruby 3.1", "Ruby", "3.1"]

=> m[1..2]
=> ["Ruby", "3.1"]


=> m[0].length
=> 8

After Ruby 3.1

We have two new methods now to access the match data & its length. The MatchData#match & MatchData#match_length methods accepts either an index or a symbol as an argument to return the match data & its length.

=> m.match(0)
=> "Ruby 3.1"

=> m.match(:version)
=> "3.1"

=> m.match(3)
=> nil

=> m.match_length(0)
=> 8

=> m.match_length(:version)
=> 3

=> m.match_length(3)
=> nil

Please note that MatchData#match is not same as MatchData#[] method. The later accepts an optional length or range as an argument to return the matched data but the former doesn't accept it, instead it allows only a single index or symbol as an argument.

Here's the relevant pull request and feature discussion for this change.

We already know Array#intersection or Array#& methods which are used to find the common elements between arrays.

=> x = [1, 2, 5, 8]
=> y = [2, 4, 5, 9]
=> z = [3, 7]

=> x.intersection(y) # x & y
=> [2, 5]

=> x.intersection(z) # x & z
=> []

The intersection or & methods return an empty array or array having the common elements in it as result. We have to further call empty?, any? or blank? like methods to check whether two arrays intersect each other or not.

Before Ruby 3.1

=> x.intersection(y).empty?
=> false

=> (x & z).empty?
=> true

=> (y & z).any?
=> false

After Ruby 3.1

=> x.intersect?(y)
=> true

=> y.intersect?(z)
=> false

The Array#intersect? method accepts only single array as argument, but Array#intersection method can accept multiple arrays as arguments.

=> x.intersection(y, z) # x & y & z
=> []

The newly introduced intersect? method is faster than the above described checks using intersection or & since the new method avoids creating an intermediate array while evaluating for common elements. Also new method returns true as soon as it finds a common element between arrays.

Here's the relevant pull request and feature discussion for this change.

Ruby 3.1 introduces an optional hash argument for the Enumerable#tally method to count. If a hash is given, the total number of occurrences of each element is added to the hash values and the final hash is returned.

Ruby 2.7.0+

=> letters = ["a", "b", "c", "a", "d", "c", "a", "c", "a"]
=> result = letters.tally
=> {"a"=>4, "b"=>1, "c"=>3, "d"=>1}

Before Ruby 3.1

=> new_letters = ["a", "b", "c", "a", "c", "a"]
=> new_letters.tally(result)
=> ArgumentError (wrong number of arguments (given 1, expected 0))

After Ruby 3.1

=> new_letters = ["a", "b", "c", "a", "c", "a"]
=> new_letters.tally(result)
=> {"a"=>7, "b"=>2, "c"=>5, "d"=>1}

The value corresponding to each element in the hash must be an integer. Otherwise, the method raises TypeError on execution.

If the default value is defined for the given hash, it will be ignored and the count of occurrences will be added in the returned hash.

=> letters = ["a", "b", "c", "a"]
=> letters.tally(Hash.new(10))
=> {"a"=>2, "b"=>1, "c"=>1}

Here's the relevant pull request and feature discussion for this change.

Ruby 3.1 introduces the compact method in the Enumerable module. Now we can use the compact method along with the Enumerator and Enumerator::Lazy classes which include the Enumerable module.

Before Ruby 3.1

=> enum = [1, nil, 3, nil, 5].to_enum
=> #<Enumerator: ...>

=> enum.compact
=> NoMethodError (undefined method `compact' for #<Enumerator: [1, nil, 3, nil, 5]:each>)

=>  enum.reject { |x| x.nil? }
=> [1, 3, 5]

After Ruby 3.1

=> enum = [1, nil, 3, nil, 5].to_enum
=> #<Enumerator: ...>

=> enum.compact
=> [1, 3, 5]

We can access the compact method to remove all nil occurrences from any classes where we include the Enumerable module.

class Person
  include Enumerable

  attr_accessor :names

  def initialize(names = [])
    @names = names
  end

  def each &block
    @names.each(&block)
  end
end

=> list = Person.new(["John", nil, "James", nil])
=> #<Person:0x0000000101cd3de8 @names=["John", nil, "James", nil]>

=> list.compact
=> ["John", "James"]

Similarly, lazy evaluation can be chained with the compact method to remove all nil entries from the Enumerator collection.

=> enum = [1, nil, 3, nil, 5].to_enum.lazy.compact
=> #<Enumerator::Lazy: ...>

=> enum.force
=> [1, 3, 5]


=> list = Person.new(["John", nil, "James", nil]).lazy.compact
=> #<Enumerator::Lazy: ...>

=> list.force
=> ["John", "James"]

Here's the relevant pull request and feature discussion for this change.