Implement the 'reverse' option for sorted()

Author: MirkoDziadzka

runtime/builtin_types.go

@@ -570,7 +570,7 @@ func builtinRepr(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 	return s.ToObject(), nil
 }
 
-func builtinSorted(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
+func builtinSorted(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException) {
 	// TODO: Support (cmp=None, key=None, reverse=False)
 	if raised := checkFunctionArgs(f, "sorted", args, ObjectType); raised != nil {
 		return nil, raised
@@ -580,6 +580,14 @@ func builtinSorted(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
 		return nil, raised
 	}
 	toListUnsafe(result).Sort(f)
+	// Implement reverse. 
+	reverse, raised := IsTrue(f, kwargs.get("reverse", None))
+	if raised != nil {
+		return nil, raised
+	}
+	if reverse {
+		toListUnsafe(result).Reverse()
+	}
 	return result, nil
 }
 

runtime/builtin_types_test.go

@@ -256,6 +256,11 @@ func TestBuiltinFuncs(t *testing.T) {
 		{f: "sorted", args: wrapArgs(newTestDict("foo", 1, "bar", 2)), want: newTestList("bar", "foo").ToObject()},
 		{f: "sorted", args: wrapArgs(1), wantExc: mustCreateException(TypeErrorType, "'int' object is not iterable")},
 		{f: "sorted", args: wrapArgs(newTestList("foo", "bar"), 2), wantExc: mustCreateException(TypeErrorType, "'sorted' requires 1 arguments")},
+		{f: "sorted", args: wrapArgs(newTestList(1, 2, 0, 3)), kwargs: wrapKWArgs("reverse", False), want: newTestRange(4).ToObject()},
+		{f: "sorted", args: wrapArgs(newTestList(1, 2, 0, 3)), kwargs: wrapKWArgs("reverse", 0), want: newTestRange(4).ToObject()},
+		{f: "sorted", args: wrapArgs(newTestList(1, 2, 0, 3)), kwargs: wrapKWArgs("reverse", None), want: newTestRange(4).ToObject()},
+		{f: "sorted", args: wrapArgs(newTestList(1, 2, 0, 3)), kwargs: wrapKWArgs("reverse", True), want: newTestList(3, 2, 1, 0).ToObject()},
+		{f: "sorted", args: wrapArgs(newTestList(1, 2, 0, 3)), kwargs: wrapKWArgs("reverse", 1), want: newTestList(3, 2, 1, 0).ToObject()},
 		{f: "unichr", args: wrapArgs(0), want: NewUnicode("\x00").ToObject()},
 		{f: "unichr", args: wrapArgs(65), want: NewStr("A").ToObject()},
 		{f: "unichr", args: wrapArgs(0x120000), wantExc: mustCreateException(ValueErrorType, "unichr() arg not in range(0x10ffff)")},

runtime/list.go

@@ -61,6 +61,18 @@ func (l *List) Append(o *Object) {
 	l.mutex.Unlock()
 }
 
+// Reverse the list in place.
+func (l *List) Reverse() {
+	l.mutex.Lock()
+	halfLen := len(l.elems) / 2
+	for i := 0; i < halfLen; i++ {
+		j := len(l.elems) - i - 1
+		l.elems[i], l.elems[j] = l.elems[j], l.elems[i]
+	}
+	l.mutex.Unlock()
+}
+
+
 // SetItem sets the index'th element of l to value.
 func (l *List) SetItem(f *Frame, index int, value *Object) *BaseException {
 	l.mutex.RLock()
@@ -354,13 +366,7 @@ func listReverse(f *Frame, args Args, _ KWArgs) (*Object, *BaseException) {
 		return nil, raised
 	}
 	l := toListUnsafe(args[0])
-	l.mutex.Lock()
-	halfLen := len(l.elems) / 2
-	for i := 0; i < halfLen; i++ {
-		j := len(l.elems) - i - 1
-		l.elems[i], l.elems[j] = l.elems[j], l.elems[i]
-	}
-	l.mutex.Unlock()
+	l.Reverse()
 	return None, nil
 }
 

testing/builtin_test.py

@@ -254,6 +254,9 @@ def __init__(self, x):
 assert sorted(["a", "e", "c", "b"]) == ["a", "b", "c", "e"]
 assert sorted((3, 1, 5, 2, 4)) == [1, 2, 3, 4, 5]
 assert sorted({"foo": 1, "bar": 2}) == ["bar", "foo"]
+assert sorted([1, 2], reverse=True) == [2, 1]
+assert sorted([1, 2], reverse=42) == [2, 1]
+assert sorted([1, 2], reverse=0) == [1, 2]
 
 # Test zip