Issue #20080 has been updated by stuyam (Stuart Yamartino). @ufuk I like `#bounds` as a name also, great suggestion, let's try that. @Dan0042 Sorry for the bad example, I didn't show a good use case I just showed show I thought it would work. Here are a few use cases: Use Case 1: Query filter, array deconstruction example ```ruby def filter_by_date_range(date_range) start_date, end_date = date_range.bounds where('start > ? AND end < ?', start_date, end_date) end ``` (I know rails supports ranges in ActiveRecord but I have needed this for more manual queries) Use Case 2. Serialize a range to store as an array in a database column: ```ruby # assumes a table with a `range_column` of type jsonb[] (array) def store_in_table SomeTable.insert('range_column', range.bounds) end ``` Use Case 3: Convert array of ranges to array of array bounds: ```ruby range_array = [(1..10), (10..20), (20..30)] bounds_array = range_array.map(&:bounds) #=> [[1, 10], [10, 20], [20, 30]] ``` Up until now you can only every "deserialize" the data out of a range into other parts using `#begin` and `#end` but have never been able to do it in one go. Sometimes you want just one value but often you want both. Often a range is passes between methods to keep the data as a single object especially if they are contextual to each other. For example, rather than passing around `start_date` and `end_date` as method params through a bunch of methods, you can just pass around a `date_range`. But in that case the range is just a way of keeping those values logically together. Or if one is nil such as a beginless or endless range it is more clear when they are kept together. In the end though, the `start_date` and `end_date` can be easily pulled out using array deconstruction with the `#bounds` method. ---------------------------------------- Feature #20080: Implement #begin_and_end method on Range https://bugs.ruby-lang.org/issues/20080#change-105825 * Author: stuyam (Stuart Yamartino) * Status: Open * Priority: Normal ---------------------------------------- Followup Reference: #20027 This feature request is to implement a method called `#begin_and_end` on `Range` that returns an array of the first and last value stored in a range: ```ruby (1..300).begin_and_end #=> [1, 300] first, last = (300..1).begin_and_end first #=> 300 last #=> 1 ``` I believe this would be a great addition to Ranges as they are often used to pass around a single object used to hold endpoints, and this allows easier retrieval of those endpoints. This would allow easier deconstruction into start and end values using array deconstruction as well as a simpler way to serialize to a more primitive object such as an array for database storage. This implementation was suggested by @mame in my initial feature suggestion regarding range deconstruction: https://bugs.ruby-lang.org/issues/20027 This implementation would work similar to how `#minmax` works where it returns an array of two numbers, however the difference is that `#minmax` doesn't work with reverse ranges as @Dan0042 pointed out in the link above: ```ruby (1..42).minmax #=> [1, 42] (42..1).minmax #=> [nil, nil] ``` -- https://bugs.ruby-lang.org/