Ruby Lambda For Sorting by Multiple Parameters - ruby

Question

I need to create lambdas for sort criteria.
To simplify the lambda creation process, I would like to order the comparisons consistently, for example:
[a.v1, b.v2] <=> [a.v1, b.v2]
[a.v1, b.v2] <=> [-a.v1, b.v2]
[a.v1, b.v2] <=> [a.v1, -b.v2]
[a.v1, b.v2] <=> [-a.v1, -b.v2]
To ensure that the lambdas work the way I expect, I wrote the following rspec:
class Obj
attr_reader :v1, :v2, :v3
def initialize(param1, param2, param3)
#v1 = param1
#v2 = param2
#v3 = param3
end
end
RSpec.describe(Array) do
let(:o1) { Obj.new(1, 1, 1) }
let(:o2) { Obj.new(2, 1, 1) }
let(:o3) { Obj.new(2, 2, 1) }
let(:o4) { Obj.new(3, 2, 1) }
let(:objs) { [o1, o2, o3, o4] }
# See https://ruby-doc.org/3.2.0/Comparable.html
it "uses comparators properly" do
expect([o1.v1] <=> [o2.v1]).to eq(-1)
expect([o1.v1, o1.v2] <=> [o2.v1, o2.v2]).to eq(-1)
expect([o1.v2, o1.v1] <=> [o3.v1, o3.v2]).to eq(-1)
expect([o1.v2, o1.v1] <=> [o3.v1, -o3.v2]).to eq(-1)
expect([o2.v2, o1.v1] <=> [-o2.v2, o2.v1]).to eq(1)
expect([o2.v2, o1.v1] <=> [-o2.v2, -o2.v1]).to eq(1)
end
# See https://ruby-doc.org/3.2.0/Enumerable.html#method-i-sort
it "sorts by 2 keys, both ascending" do
sort_lambda = ->(a, b) { [a.v1, a.v2] <=> [b.v1, b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o2, o3, o4])
end
it "sorts by 2 keys, both descending" do
sort_lambda = ->(a, b) { [a.v1, a.v2] <=> [-b.v1, -b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o3, o2, o1])
end
it "sorts by 2 keys, first descending and second ascending" do
sort_lambda = ->(a, b) { [a.v1, b.v2] <=> [-a.v1, b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o3, o2, o1])
end
# This one fails ... why?
it "sorts by 2 keys, first ascending and second descending" do
sort_lambda = ->(a, b) { [a.v1, b.v2] <=> [a.v1, -b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o3, o2, o4])
end
end
The tests all pass, except the last one, which fails with:
Failure/Error: expect(result).to eq([o1, o3, o2, o4])
expected: [#<Obj:0x00007fc2ac112940 #v1=1, #v2=1, #v3=1>, #<Obj:0x00007fc2ac112828 #v1=2, #v2=2, #v3=1>, #<Obj:0x00007fc2ac1128c8 #v1=2, #v2=1, #v3=1>, #<Obj:0x00007fc2ac112788 #v1=3, #v2=2, #v3=1>]
got: [#<Obj:0x00007fc2ac112788 #v1=3, #v2=2, #v3=1>, #<Obj:0x00007fc2ac112828 #v1=2, #v2=2, #v3=1>, #<Obj:0x00007fc2ac1128c8 #v1=2, #v2=1, #v3=1>, #<Obj:0x00007fc2ac112940 #v1=1, #v2=1, #v3=1>]
Why?

Answer 1

I think you might misunderstand how Array#<=> (spaceship) works. (or maybe it is just a typo in your tests)
What this does is sort by a[0] <=> b[0] and if that is 0 (equal) then it moves on to a[1] <=> b[1] and so on until (x <=> y) != 0; however it will only compare a set once meaning 4 elements 4 iterations. This causes an issue for you because it means that it will never have a set of comparisons where a == o2 && b == o3 and then also a == o3 && b == o2
In your failing test:
sort_lambda = ->(a, b) { [a.v1, b.v2] <=> [a.v1, -b.v2] }
a.v1 will always equal a.v1 e.g. return 0 so it moves on to comparing b.v2 to -b.v2 and you end up with b.v2 in descending order.
It appears what you actually wanted is
sort_lambda = ->(a, b) { [a.v1, -a.v2] <=> [b.v1, -b.v2] }
Example:
a = [[1,1,1],[2,1,1],[2,2,1],[3,2,1]]
sort_lambda = ->(a, b) { [a.v1, -a.v2] <=> [b.v1, -b.v2] }
a.sort(&sort_lambda)
#=> [[1, 1, 1], [2, 2, 1], [2, 1, 1], [3, 2, 1]]
Notes:
All your tests suffer from a very specific issue which is that the operator needs to be applied to both sides. For example it "sorts by 2 keys, both descending" appears to pass but this is only due to the order in which you have presented the arguments. e.g.
sort_lambda = ->(a, b) { [a[0], a[1]] <=> [-b[0], -b[1]] }
a.sort(&sort_lambda)
#=> [[3, 2, 1], [2, 2, 1], [2, 1, 1], [1, 1, 1]] #looks like it works
b = [a[0],a[2],a[1],a[3]]
b.sort(&sort_lambda)
#=> [[3, 2, 1], [2, 1, 1], [2, 2, 1], [1, 1, 1]] # Oh No
b.sort(&sort_lambda) == a.sort(&sort_lambda) #=> false
# apply the same unary on both sides
sort_lambda = ->(a, b) { [-a[0], -a[1]] <=> [-b[0], -b[1]] }
b.sort(&sort_lambda)
#=> [[3, 2, 1], [2, 2, 1], [2, 1, 1], [1, 1, 1]] # that's better
b.sort(&sort_lambda) == a.sort(&sort_lambda) #=> true
The it "sorts by 2 keys, first descending and second ascending" test is wrong but because your expectation ([o4, o3, o2, o1]) is incorrect the test passes. Based on the test description the expected output should be [o4, o2, o3, o1] and the lambda body should change to [-a.v1, a.v2] <=> [-b.v1, b.v2]
These tests are easier expressed using sort_by e.g. sort_by {|a| [-a.v1,a.v2]}

Answer 2

For posterity, here is the answer with #engineersmnky's corrections. Both a sort and an equivalent sort_by approach is provided for each scenario.
class Obj
attr_reader :v1, :v2, :v3
def initialize(param1, param2, param3)
#v1 = param1
#v2 = param2
#v3 = param3
end
end
RSpec.describe(Array) do # rubocop:disable Metrics/BlockLength
let(:o1) { Obj.new(1, 1, 1) }
let(:o2) { Obj.new(2, 1, 1) }
let(:o3) { Obj.new(2, 2, 1) }
let(:o4) { Obj.new(3, 2, 1) }
let(:objs) { [o1, o2, o3, o4] }
# See https://ruby-doc.org/3.2.0/Comparable.html
it "uses comparators properly" do
expect([o1.v1] <=> [o2.v1]).to eq(-1)
expect([o1.v1, o1.v2] <=> [o2.v1, o2.v2]).to eq(-1)
expect([o1.v2, o1.v1] <=> [o3.v1, o3.v2]).to eq(-1)
expect([o1.v2, o1.v1] <=> [o3.v1, -o3.v2]).to eq(-1)
expect([o2.v2, o1.v1] <=> [-o2.v2, o2.v1]).to eq(1)
expect([o2.v2, o1.v1] <=> [-o2.v2, -o2.v1]).to eq(1)
end
# See https://ruby-doc.org/3.2.0/Enumerable.html#method-i-sort
it "sort with 2 keys, both ascending" do
sort_lambda = ->(a, b) { [a.v1, a.v2] <=> [b.v1, b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o2, o3, o4])
end
it "sort_by with 2 keys, both ascending" do
sort_lambda = ->(a) { [a.v1, a.v2] }
result = objs.sort_by(&sort_lambda)
expect(result).to eq([o1, o2, o3, o4])
end
it "sort with 2 keys, both descending" do
sort_lambda = ->(a, b) { [-a.v1, -a.v2] <=> [-b.v1, -b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o3, o2, o1])
end
it "sort_by with 2 keys, both descending" do
sort_lambda = ->(a) { [-a.v1, -a.v2] }
result = objs.sort_by(&sort_lambda)
expect(result).to eq([o4, o3, o2, o1])
end
it "sort with 2 keys, first descending and second ascending" do
sort_lambda = ->(a, b) { [-a.v1, a.v2] <=> [-b.v1, b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o2, o3, o1])
end
it "sort_by with 2 keys, first descending and second ascending" do
sort_lambda = ->(a) { [-a.v1, a.v2] }
result = objs.sort_by(&sort_lambda)
expect(result).to eq([o4, o2, o3, o1])
end
it "sort with 2 keys, first ascending and second descending" do
sort_lambda = ->(a, b) { [a.v1, -a.v2] <=> [b.v1, -b.v2] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o3, o2, o4])
end
it "sort_by with 2 keys, first ascending and second descending" do
sort_lambda = ->(a) { [a.v1, -a.v2] }
result = objs.sort_by(&sort_lambda)
expect(result).to eq([o1, o3, o2, o4])
end
end
This solution throws an exception if a property of type Date is used as a descending sort key. The error message of the form undefined method -#' for #<Date: 2011-01-01 ((2455563j,0s,0n),+0s,2299161j)>`.
To see the error:
Modify initialize to be:
def initialize(param1, param2)
#v1 = Date.parse(param1)
#v2 = Date.parse(param2)
#v3 = param3
end
Modify the definitions of o1 .. o4 to be of the form:
let(:o1) { Obj.new('2000-01-01', '2001-01-01', 1) }
let(:o2) { Obj.new('2010-01-01', '2001-01-01', 1) }
let(:o3) { Obj.new('2010-01-01', '2011-01-01', 1) }
let(:o4) { Obj.new('2020-01-01', '2011-01-01', 1) }
let(:objs) { [o1, o2, o3, o4] }

Answer 3

The previous answers fail when applying a descending sort according to Date field(s). This solution uses the suggestion from #ngineersmnky to reverse the comparison order for fields that need to be sorted in descending order.
Note that although sort_by is more convenient to use than sort, only sort provides the ability to reverse the order of comparison, so it must be used for this solution, and not sort_by.
class Obj
# `date_modified` is primary sort key
# `date` (when specified) is secondary sort key
attr_reader :date, :date_modified
def initialize(param1, param2)
#date_modified = Date.parse(param1)
#date = Date.parse(param2)
end
end
RSpec.describe(Obj) do
let(:o1) { Obj.new('2000-01-01', '2001-01-01') }
let(:o2) { Obj.new('2010-01-01', '2001-01-01') }
let(:o3) { Obj.new('2010-01-01', '2011-01-01') }
let(:o4) { Obj.new('2020-01-01', '2011-01-01') }
let(:objs) { [o1, o2, o3, o4] }
# See https://ruby-doc.org/3.2.0/Comparable.html
it "compares one key with ascending dates" do
expect([o1.date_modified] <=> [o2.date_modified]).to eq(-1)
expect([o2.date_modified] <=> [o3.date_modified]).to eq(0)
expect([o3.date_modified] <=> [o4.date_modified]).to eq(-1)
end
it "compares two keys with ascending dates" do
expect([o1.date_modified, o1.date] <=> [o2.date_modified, o2.date]).to eq(-1)
expect([o2.date_modified, o2.date] <=> [o3.date_modified, o3.date]).to eq(-1)
expect([o3.date_modified, o3.date] <=> [o4.date_modified, o4.date]).to eq(-1)
end
it "compares one key with descending dates" do
expect([o1.date_modified] <=> [o2.date_modified]).to eq(-1)
expect([o2.date_modified] <=> [o3.date_modified]).to eq(0)
end
it "compares two keys with descending dates" do
expect([o2.date_modified, o2.date] <=> [o1.date_modified, o1.date]).to eq(1)
expect([o3.date_modified, o3.date] <=> [o2.date_modified, o2.date]).to eq(1)
expect([o4.date_modified, o4.date] <=> [o3.date_modified, o3.date]).to eq(1)
end
# See https://ruby-doc.org/3.2.0/Enumerable.html#method-i-sort
it "sort with both keys ascending" do
sort_lambda = ->(a, b) { [a.date_modified, a.date] <=> [b.date_modified, b.date] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o2, o3, o4])
end
it "sort with both keys descending" do
sort_lambda = ->(a, b) { [b.date_modified, b.date] <=> [a.date_modified, a.date] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o3, o2, o1])
end
it "sort with date_modified descending and date ascending" do
sort_lambda = ->(a, b) { [b.date_modified, a.date] <=> [a.date_modified, b.date] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o4, o2, o3, o1])
end
it "sort with date_modified ascending and date descending" do
sort_lambda = ->(a, b) { [a.date_modified, b.date] <=> [b.date_modified, a.date] }
result = objs.sort(&sort_lambda)
expect(result).to eq([o1, o3, o2, o4])
end
end