(..100) is a Beginless Range and it is equivalent to (nil..100).

Let's see how Beginless Range could be used.

> array = (1..10).to_a# Select first 6 elements> array[..5]=> [1, 2, 3, 4, 5, 6]# Select first 5 elements> array[...5]=> [1, 2, 3, 4, 5]# grep (INFINITY..5) in (1..5)> (1..10).grep(..5)=> [1, 2, 3, 4, 5]# (..100) is equivalent to (nil..100)> (..100) == (nil..100)=> true

Here is another example where in the case statement the condition can be readas below the specified level.

case temperaturewhen ..-15  puts "Deep Freeze"when -15..8  puts "Refrigerator"when 8..15  puts "Cold"when 15..25  puts "Room Temperature"when (25..)   # Kindly notice the brackets here  puts "Hot"end

It can also be used for defining constants for ranges.

TEMPERATURE = {  ..-15  => :deep_freeze,  -15..8 => :refrigerator,  8..15  => :cold,  15..25 => :room_temperature,  25..   => :hotend

Using Beginless Range in DSL makes it easier to write conditions and it looksmore natural.

# In RailsUser.where(created_at: (..DateTime.now))# User Load (2.2ms)  SELECT "users".* FROM "users" WHERE "users"."created_at" <= $1 LIMIT $2  [["created_at", "2020-08-05 15:00:19.111217"], ["LIMIT", 11]]# In RubySpecruby_version(..'1.9') do# Tests for old Rubyend

Here is the relevantcommitand discussion regarding this change.

Before Ruby 2.7, we could have achieved the same with 2 iterations usingselect & map combination or map & compact combination.

irb> numbers = [3, 6, 7, 9, 5, 4]# we can use select & map to find square of odd numbersirb> numbers.select { |x| x.odd? }.map { |x| x**2 }=> [9, 49, 81, 25]# or we can use map & compact to find square of odd numbersirb> numbers.map { |x| x**2 if x.odd? }.compact=> [9, 49, 81, 25]

Ruby 2.7

Ruby 2.7 adds Enumerable#filter_map which can be used to filter & map theelements in a single iteration and which is more faster when compared to otheroptions described above.

irb> numbers = [3, 6, 7, 9, 5, 4]irb> numbers.filter_map { |x| x**2 if x.odd? }=> [9, 49, 81, 25]

The original discussion had started8 years back. Here is the latestthread andgithub commitfor reference.

Ruby 2.7 NEWShas listed the spec of keyword arguments for Ruby 3.0. We will take the examplesmentioned there and for each scenario we will look into how we can fix them inthe existing codebase.

Scenario 1

When method definition accepts keyword arguments as the last argument.

def sum(a: 0, b: 0)  a + bend

Passing exact keyword arguments in a method call is acceptable, but inapplications we usually pass a hash to a method call.

sum(a: 2, b: 4) # OKsum({ a: 2, b: 4 }) # Warned

In this case, we can add a double splat operator to the hash to avoiddeprecation warning.

sum(**{ a: 2, b: 4 }) # OK

Scenario 2

When method call passes keyword arguments but does not pass enough requiredpositional arguments.

If the number of positional arguments doesn't match with method definition, thenkeyword arguments passed in method call will be considered as the lastpositional argument to the method.

def sum(num, x: 0)  num.values.sum + xend

sum(a: 2, b: 4) # Warnedsum(a: 2, b: 4, x: 6) # Warned

To avoid deprecation warning and for code to be compatible with Ruby 3, weshould pass hash instead of keyword arguments in method call.

sum({ a: 2, b: 4 }) # OKsum({ a: 2, b: 4}, x: 6) # OK

Scenario 3

When a method accepts a hash and keyword arguments but method call passes onlyhash or keyword arguments.

If a method arguments are a mix of symbol keys and non-symbol keys, and themethod definition accepts either one of them then Ruby splits the keywordarguments but also raises a warning.

def sum(num={}, x: 0)  num.values.sum + xend

sum("x" => 2, x: 4) # Warnedsum(x: 2, "x" => 4) # Warned

To fix this warning, we should pass hash separately as defined in the methoddefinition.

sum({ "x" => 4 }, x: 2) # OK

Scenario 4

When an empty hash with double splat operator is passed to a method thatdoesn't accept keyword arguments.

Passing keyword arguments using double splat operator to a method that doesn'taccept keyword argument will send empty hash similar to earlier version of Rubybut will raise a warning.

def sum(num)  num.values.sumend

numbers = {}sum(**numbers) # Warned

To avoid this warning, we should change method call to pass hash instead ofusing double splat operator.

numbers = {}sum(numbers) # OK

Added support for non-symbol keys

In Ruby 2.6.0, support for non-symbol keys in method call was removed. It isadded back in Ruby 2.7. When method accepts arbitrary keyword arguments usingdouble splat operator then non-symbol keys can also be passed.

def sum(**num)  num.values.sumend

ruby 2.6.5

sum("x" => 4, "y" => 3)=> ArgumentError (wrong number of arguments (given 1, expected 0))sum(x: 4, y: 3)=> 7

ruby 2.7.0

sum("x" => 4, "y" => 3)=> 7sum(x: 4, y: 3)=> 7

Added support for **nil

Ruby 2.7 added support for **nil to explicitly mention if a method doesn'taccept any keyword arguments in method call.

def sum(a, b, **nil)  a + bendsum(2, 3, x: 4)=> ArgumentError (no keywords accepted)

To suppress above deprecation warnings we can use-W:no-deprecated option.

In conclusion, Ruby 2.7 has worked big steps towards changing specification ofkeyword arguments which will be completely changed in Ruby 3.

For more information on discussion, code changes and official documentation,please head to Feature #14183discussion, pull request andNEWS release.

By applyingEnumerable#lazymethod on any enumerable object, we can convert that object intoEnumerator::Lazy object. The chains of actions on this lazy enumerator will beevaluated only when it is needed. It helps us in processing operations on largecollections, files and infinite sequences seamlessly.

# This line of code will hang and you will have to quit the console by Ctrl+C.irb> list = (1..Float::INFINITY).select { |i| i%3 == 0 }.reject(&:even?)# Just adding `lazy`, the above line of code now executes properly# and returns result without going to infinite loop. Here the chains of# operations are performed as and when it is needed.irb> lazy_list = (1..Float::INFINITY).lazy.select { |i| i%3 == 0 }.reject(&:even?)=> #<Enumerator::Lazy: ...>irb> lazy_list.first(5)=> [3, 9, 15, 21, 27]

When we chain more operations on Enumerable#lazy object, it again returns lazyobject without executing it. So, when we pass lazy objects to any method whichexpects a normal enumerable object as an argument, we have to force evaluationon lazy object by callingto_amethod or it's aliasforce.

# Define a lazy enumerator object.irb> list = (1..30).lazy.select { |i| i%3 == 0 }.reject(&:even?)=> #<Enumerator::Lazy: #<Enumerator::Lazy: ... 1..30>:select>:reject># The chains of operations will return again a lazy enumerator.irb> result = list.select { |x| x if x <= 15 }=> #<Enumerator::Lazy: #<Enumerator::Lazy: ... 1..30>:select>:reject>:map># It returns error when we call usual array methods on result.irb> result.sampleirb> NoMethodError (undefined method `sample'irb> for #<Enumerator::Lazy:0x00007faab182a5d8>)irb> result.lengthirb> NoMethodError (undefined method `length'irb> for #<Enumerator::Lazy:0x00007faab182a5d8>)# We can call the normal array methods on lazy object after forcing# its actual execution with methods as mentioned above.irb> result.force.sample=> 9irb> result.to_a.length=> 3

TheEnumerable#eagermethod returns a normal enumerator from a lazy enumerator, so that lazyenumerator object can be passed to any methods which expects a normal enumerableobject as an argument. Also, we can call other usual array methods on thecollection to get desired results.

# By adding eager on lazy object, the chains of operations would return# actual result here. If lazy object is passed to any method, the# processed result will be received as an argument.irb> eager_list = (1..30).lazy.select { |i| i%3 == 0 }.reject(&:even?).eager=> #<Enumerator: #<Enumerator::Lazy: ... 1..30>:select>:reject>:each>irb> result = eager_list.select { |x| x if x <= 15 }irb> result.sample=> 9irb> result.length=> 3

The same way, we can use eager method when we pass lazy enumerator as anargument to any method which expects a normal enumerator.

irb> list = (1..10).lazy.select { |i| i%3 == 0 }.reject(&:even?)irb> def display(enum)irb>   enum.map { |x| p x }irb> endirb>  display(list)=> #<Enumerator::Lazy: #<Enumerator::Lazy: ... 1..30>:select>:reject>:map>irb> eager_list = (1..10).lazy.select { |i| i%3 == 0 }.reject(&:even?).eagerirb> display(eager_list)=> 3=> 9

Here's the relevantcommitand feature discussion for thischange.

> (1..10).each { |n| p n * 3 }> { a: [1, 2, 3], b: [2, 4, 6], c: [3, 6, 9] }.each { |_k, v| p v }> [10, 100, 1000].each_with_index { |n, i| p n, i }

Ruby 2.7 introduces a new way to access block parameters. Ruby 2.7 onwards, ifblock parameters are obvious and we wish to not use absurd names like n or ietc, we can use numbered parameters which are available inside a block bydefault.

We can use **1_ for first parameter, **2_ for second parameter and so on.

Here's how Ruby 2.7 provides numbered parameters inside a block. Below shown arethe examples from above, only this time using numbered parameters.

> (1..10).each { p _1 * 3 }> { a: [1, 2, 3], b: [2, 4, 6], c: [3, 6, 9] }.each { p _2 }> [10, 100, 1000].each_with_index { p _1, _2 }

Like mentioned inNews-2.7.0 docs,Ruby now raises a warning if we try to define local variable in the format _1.Local variable will have precedence over numbered parameter inside the block.

> _1 = 0> => warning: `_1' is reserved for numbered parameter; consider another name> [10].each { p _1 }> => 0

Numbered parameters are not accessible inside the block if we define ordinaryparameters. If we try to access _1 when ordinary parameters are defined, thenruby raises SyntaxError like shown below.

> ["a", "b", "c"].each_with_index { |alphabet, index| p _1, _2}=> SyntaxError ((irb):1: ordinary parameter is defined)

This feature was suggested 9 years back and came back in discussion last year.After many suggestions community agreed to use _1 syntax.

Head to following links to read the discussion behind numbered parameters,Feature #4475 andDiscussion #15723.

Here's relevantcommitfor this feature.

Before Ruby 2.7, we could have achieved it using group_by or inject.

irb> scores = [100, 35, 70, 100, 70, 30, 35, 100, 45, 30]# we can use group_by to group the scoresirb> scores.group_by { |v| v }.map { |k, v| [k, v.size] }.to_h=> {100=>3, 35=>2, 70=>2, 30=>2, 45=>1}# or we can use inject to group the scoresirb> scores.inject(Hash.new(0)) {|hash, score| hash[score] += 1; hash }=> {100=>3, 35=>2, 70=>2, 30=>2, 45=>1}

Ruby 2.7

Ruby 2.7 adds Enumerable#tally which can be used to find the frequency.Tally makes the code more readable and intuitive. It returns a hash where keysare the unique elements and values are its corresponding frequency.

irb> scores = [100, 35, 70, 100, 70, 30, 35, 100, 45, 30]irb> scores.tally=> {100=>3, 35=>2, 70=>2, 30=>2, 45=>1}

Check out thegithub commitfor more details on this.