list-ops: update to match Kotlin track

Based on v1.0.0 of the canonical data:

https://github.com/exercism/problem-specifications/tree/28a32203b96ebaecac6a6968831bd66718d8ba30/exercises/list-ops

Plus modifications that are being discussed in

https://github.com/exercism/problem-specifications/issues/826

config.json

       ]
     },
     {
-      "slug": "change",
+      "slug": "list-ops",
       "difficulty": 8,
       "topics": [
-
+      
       ]
     },
     {
-      "slug": "palindrome-products",
+      "slug": "change",
       "difficulty": 8,
       "topics": [
 
       ]
     },
     {
-      "slug": "pythagorean-triplet",
-      "difficulty": 9,
+      "slug": "palindrome-products",
+      "difficulty": 8,
       "topics": [
 
       ]
     },
     {
-      "slug": "list-ops",
+      "slug": "pythagorean-triplet",
       "difficulty": 9,
       "topics": [
-      
+
       ]
     },
     {

exercises/list-ops/HINTS.md

+## Hints
+
+The `foldLeft` and `foldRight` methods are "fold" functions, which is a concept well-known in the functional programming world, but less so in the object-oriented one. See the Wikipedia page on folding for [general background](https://en.wikipedia.org/wiki/Fold_(higher-order_function)) and [signature/implementation hints](https://en.wikipedia.org/wiki/Fold_(higher-order_function)#Linear_folds).

exercises/list-ops/src/example/java/ListOps.java

 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.BinaryOperator;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
+import java.util.function.*;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-public class ListOps {
+class ListOps {
 
-    private ListOps() {
+    static <T> List<T> append(final List<T> list1, final List<T> list2) {
+        final List<T> result = new ArrayList<>();
+        result.addAll(list1);
+        result.addAll(list2);
+        return result;
+    }
+
+    static <T> List<T> concat(final List<List<T>> listOfLists) {
+        final List<T> result = new ArrayList<>();
+        listOfLists.forEach(result::addAll);
+        return result;
+    }
+
+    static <T> List<T> filter(final List<T> list, Predicate<T> predicate) {
+        return list.stream().filter(predicate).collect(Collectors.toList());
     }
 
-    public static <T> int length(final List<T> list) {
+    static <T> int size(final List<T> list) {
         return list.size();
     }
 
-    public static <T> List<T> reverse(final List<T> list) {
-        List<T> result = new ArrayList(list);
+    static <T, U> List<U> map(final List<T> list, Function<T, U> transform) {
+        return list.stream().map(transform).collect(Collectors.toList());
+    }
+
+    static <T> List<T> reverse(final List<T> list) {
+        final List<T> result = new ArrayList<>(list);
         Collections.reverse(result);
         return result;
     }
 
-    public static <T> List<T> map(final List<T> list,
-            UnaryOperator<T> mapper) {
-        return list.stream().map(mapper).collect(Collectors.toList());
-    }
+    static <T, U> U foldLeft(final List<T> list, final U initial, final BiFunction<U, T, U> f) {
+        if (list.isEmpty()) return initial;
 
-    public static <T> List<T> filter(final List<T> list,
-            Predicate<T> predicate) {
-        return list.stream().filter(predicate).collect(Collectors.toList());
+        return foldLeft(
+                new ArrayList<>(list.subList(1, list.size())),
+                f.apply(
+                        initial,
+                        list.get(0)),
+                f);
     }
 
-    public static <U, T> U reduce(final List<T> list,
-            U identity,
-            BiFunction<U, T, U> accumulator,
-            BinaryOperator<U> combiner) {
-        return list.stream().reduce(identity, accumulator, combiner);
+    static <T, U> U foldRight(final List<T> list, final U initial, final BiFunction<T, U, U> f) {
+        if (list.isEmpty()) return initial;
+
+        return f.apply(
+                list.get(0),
+                foldRight(
+                        new ArrayList<>(list.subList(1, list.size())),
+                        initial,
+                        f));
     }
 
-    public static <T> List<T> concat(final List<T>... lists) {
-        return Stream.of(lists)
-                .flatMap(Collection::stream)
-                .collect(Collectors.toList());
+    private ListOps() {
+        // No instances.
     }
 
 }

exercises/list-ops/src/main/java/ListOps.java

+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+class ListOps {
+
+    static <T> List<T> append(List<T> list1, List<T> list2) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T> List<T> concat(List<List<T>> listOfLists) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T> int size(List<T> list) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T, U> List<U> map(List<T> list, Function<T, U> transform) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T> List<T> reverse(List<T> list) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T, U> U foldLeft(List<T> list, U initial, BiFunction<U, T, U> f) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    static <T, U> U foldRight(List<T> list, U initial, BiFunction<T, U, U> f) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+
+    private ListOps() {
+        // No instances.
+    }
+
+}

exercises/list-ops/src/test/java/ListOpsTest.java

+import org.junit.Ignore;
+import org.junit.Test;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
-import java.util.function.BiFunction;
-import java.util.function.BinaryOperator;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-import static junit.framework.TestCase.assertEquals;
-import static junit.framework.TestCase.assertFalse;
-import static junit.framework.TestCase.assertNotNull;
-import static junit.framework.TestCase.assertTrue;
-import org.junit.Ignore;
-import org.junit.Test;
 
-public class ListOpsTest {
+import static org.junit.Assert.assertEquals;
 
-    private static final List<Integer> EMPTY_LIST
-            = Collections.emptyList();
+/*
+ * version: 1.0.0
+ */
+public class ListOpsTest {
 
     @Test
-    public void lengthOfAnEmptyListShouldBeZero() {
-        final int expected = 0;
-        final int actual = ListOps.length(EMPTY_LIST);
-
-        assertEquals(expected, actual);
+    public void testAppendingEmptyLists() {
+        assertEquals(
+                Collections.emptyList(),
+                ListOps.append(Collections.emptyList(), Collections.emptyList()));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldReturnTheCorrectLengthOfAnNonEmptyList() {
-        final List<Integer> list = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4)
-        );
-        final int actual = ListOps.length(list);
-        final int expected = list.size();
-
-        assertEquals(expected, actual);
-    }
-
     @Test
-    @Ignore("Remove to run test")
-    public void shouldReverseAnEmptyList() {
-        final List<Integer> actual = ListOps.reverse(EMPTY_LIST);
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    public void testAppendingNonEmptyListOnEmptyList() {
+        assertEquals(
+                Arrays.asList('1', '2', '3', '4'),
+                ListOps.append(Collections.emptyList(), Arrays.asList('1', '2', '3', '4')));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldReverseANonEmptyList() {
-        final List<Integer> list = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8)
-        );
-        final List<Integer> actual
-                = ListOps.reverse(list);
-        final List<Integer> expected
-                = Arrays.asList(8, 7, 6, 5, 4, 3, 2, 1, 0);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testAppendingNonEmptyListOnNonEmptyList() {
+        assertEquals(
+                Arrays.asList("1", "2", "2", "3", "4", "5"),
+                ListOps.append(Arrays.asList("1", "2"), Arrays.asList("2", "3", "4", "5")));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldMapAnEmptyListAndReturnAnEmptyList() {
-        final List<Integer> actual = ListOps.map(EMPTY_LIST, x -> x + 1);
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    @Test
+    public void testConcatOnEmptyListOfLists() {
+        assertEquals(
+                Collections.emptyList(),
+                ListOps.concat(Collections.emptyList()));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldMapNonEmptyList() {
-        final List<Integer> list
-                = Collections.unmodifiableList(Arrays.asList(1, 3, 5, 7));
-        final List<Integer> actual = ListOps.map(list, x -> x + 1);
+    @Test
+    public void testConcatOnNonEmptyListOfLists() {
+        List<List<Character>> listOfLists = Arrays.asList(
+                Arrays.asList('1', '2'),
+                Collections.singletonList('3'),
+                Collections.emptyList(),
+                Arrays.asList('4', '5', '6'));
 
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(Arrays.asList(2, 4, 6, 8), actual);
+        assertEquals(
+                Arrays.asList('1', '2', '3', '4', '5', '6'),
+                ListOps.concat(listOfLists));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldFilterAnEmptyListanddReturnAnEmptyList() {
-        final List<Integer> actual = ListOps.filter(EMPTY_LIST, x -> x > 0);
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    @Test
+    public void testFilteringEmptyList() {
+        assertEquals(
+                Collections.emptyList(),
+                ListOps.filter(Collections.<Integer>emptyList(), integer -> integer % 2 == 1));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldFilterNonEmptyList() {
-        Predicate<Integer> predicate = x -> x % 2 > 0;
-        final List<Integer> list = Collections.unmodifiableList(
-                IntStream.range(0, 100).boxed().collect(Collectors.toList())
-        );
-        final List<Integer> actual = ListOps.filter(list, predicate);
-        final List<Integer> expected = list.stream()
-                .filter(predicate)
-                .collect(Collectors.toList());
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testFilteringNonEmptyList() {
+        assertEquals(
+                Arrays.asList(1, 3, 5),
+                ListOps.filter(Arrays.asList(1, 2, 3, 5), integer -> integer % 2 == 1));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateZeroLists() {
-        List<Integer> actual = ListOps.concat();
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    @Test
+    public void testSizeOfEmptyList() {
+        assertEquals(0, ListOps.size(Collections.emptyList()));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateOneNonEmptyList() {
-        final List<Integer> list
-                = Collections.unmodifiableList(
-                        Arrays.asList(0, 1, 2, 3, 4)
-                );
-        final List<Integer> actual = ListOps.concat(list);
-        final List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testSizeOfNonEmptyList() {
+        assertEquals(4, ListOps.size(Arrays.asList("one", "two", "three", "four")));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateOneEmptyList() {
-        final List<Integer> actual = ListOps.concat(EMPTY_LIST);
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    @Test
+    public void testTransformingEmptyList() {
+        assertEquals(
+                Collections.emptyList(),
+                ListOps.map(Collections.<Integer>emptyList(), integer -> integer + 1 ));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateTwoEmptyLists() {
-        final List<Integer> actual = ListOps.concat(EMPTY_LIST, EMPTY_LIST);
-
-        assertNotNull(actual);
-        assertTrue(actual.isEmpty());
+    @Test
+    public void testTransformingNonEmptyList() {
+        assertEquals(
+                Arrays.asList(2, 4, 6, 8),
+                ListOps.map(Arrays.asList(1, 3, 5, 7), integer -> integer + 1 ));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateOneEmptyAndOneNonEmptyLists() {
-        final List<Integer> list
-                = Collections.unmodifiableList(
-                        Arrays.asList(0, 1, 2, 3, 4)
-                );
-        final List<Integer> actual = ListOps.concat(list, EMPTY_LIST);
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testFoldLeftOnEmptyList() {
+        assertEquals(
+                new Double(2.0), // Boxing required for method overload disambiguation.
+                ListOps.foldLeft(
+                        Collections.<Double>emptyList(),
+                        2.0,
+                        (x, y) -> x * y));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateOneNonEmptyAndOneEmptyLists() {
-        final List<Integer> list
-                = Collections.unmodifiableList(
-                        Arrays.asList(0, 1, 2, 3, 4)
-                );
-        final List<Integer> actual = ListOps.concat(EMPTY_LIST, list);
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testFoldLeftWithDirectionIndependentOperationOnNonEmptyList() {
+        assertEquals(
+                new Integer(15), // Boxing required for method overload disambiguation.
+                ListOps.foldLeft(
+                        Arrays.asList(1, 2, 3, 4),
+                        5,
+                        (x, y) -> x + y));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateTwoListsWithSameElements() {
-        final List<Integer> list1 = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4)
-        );
-        final List<Integer> list2 = Collections.unmodifiableList(
-                Arrays.asList(1, 2, 3, 4, 5, 6)
-        );
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 6);
-        final List<Integer> actual = ListOps.concat(list1, list2);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testFoldLeftWithDirectionDependentOperationOnNonEmptyList() {
+        assertEquals(
+                new Integer(0), // Boxing required for method overload disambiguation.
+                ListOps.foldLeft(
+                        Arrays.asList(2, 5),
+                        5,
+                        (x, y) -> x / y));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldConcatenateSeveralLists() {
-        final List<Integer> list1 = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3)
-        );
-        final List<Integer> list2 = Collections.unmodifiableList(
-                Arrays.asList(4, 5, 6, 7)
-        );
-        final List<Integer> list3 = Collections.unmodifiableList(
-                Arrays.asList(8, 9, 10, 11)
-        );
-        final List<Integer> list4 = Collections.unmodifiableList(
-                Arrays.asList(12, 13, 14, 15)
-        );
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
-                        14, 15);
-
-        final List<Integer> actual
-                = ListOps.concat(list1, list2, EMPTY_LIST, list3, list4);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testFoldRightOnEmptyList() {
+        assertEquals(
+                new Double(2.0), // Boxing required for method overload disambiguation.
+                ListOps.foldRight(
+                        Collections.<Double>emptyList(),
+                        2.0,
+                        (x, y) -> x * y));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldReturnIdentityWhenAnEmptyListIsReduced() {
-        final int expected = 0;
-        final int actual
-                = ListOps.reduce(EMPTY_LIST, 0, (x, y) -> x + y, Integer::sum);
-
-        assertEquals(expected, actual);
+    @Test
+    public void testFoldRightWithDirectionIndependentOperationOnNonEmptyList() {
+        assertEquals(
+                new Integer(15), // Boxing required for method overload disambiguation.
+                ListOps.foldRight(
+                        Arrays.asList(1, 2, 3, 4),
+                        5,
+                        (x, y) -> x + y));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldCalculateTheSumOfANonEmptyIntegerList() {
-        final List<Integer> list = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4)
-        );
-        final int actual = ListOps.reduce(list, 0,
-                (x, y) -> x + y,
-                Integer::sum);
-
-        assertEquals(10, actual);
+    @Test
+    public void testFoldRightWithDirectionDependentOperationOnNonEmptyList() {
+        assertEquals(
+                new Integer(2), // Boxing required for method overload disambiguation.
+                ListOps.foldRight(
+                        Arrays.asList(2, 5),
+                        5,
+                        (x, y) -> x / y));
     }
 
-    /*
-    https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html
-    https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html#reduce-U-java.util.function.BiFunction-java.util.function.BinaryOperator-
-     */
-    private BiFunction<List<Integer>, Integer, List<Integer>> accumulator
-            = (List<Integer> partial, Integer elem) -> {
-                List<Integer> result = new ArrayList<>(partial);
-                result.add(elem);
-                return result;
-            };
-
-    private BinaryOperator<List<Integer>> combiner
-            = (list1, list2) -> {
-                List<Integer> result = new ArrayList<>(list1);
-                result.addAll(list2);
-                return result;
-            };
-
-    @Test
     @Ignore("Remove to run test")
-    public void shouldReduceAnEmptyListAndANonEmptyListAndReturnConcatenation() {
-        final List<Integer> list = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4, 5)
-        );
-        final List<Integer> actual
-                = ListOps.reduce(list,
-                        new ArrayList<Integer>(),
-                        accumulator,
-                        combiner);
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4, 5);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testReversingEmptyList() {
+        assertEquals(
+                Collections.emptyList(),
+                ListOps.reverse(Collections.emptyList()));
     }
 
-    @Test
     @Ignore("Remove to run test")
-    public void shouldReduceTwoNonEmptyListsAndReturnConcatenation() {
-        final List<Integer> listOne = Collections.unmodifiableList(
-                Arrays.asList(0, 1, 2, 3, 4)
-        );
-        final List<Integer> listTwo = Collections.unmodifiableList(
-                Arrays.asList(5, 6, 7, 8, 9)
-        );
-        final List<Integer> actual
-                = ListOps.reduce(listTwo,
-                        listOne,
-                        accumulator,
-                        combiner);
-        final List<Integer> expected
-                = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
-
-        assertNotNull(actual);
-        assertFalse(actual.isEmpty());
-        assertEquals(expected, actual);
+    @Test
+    public void testReversingNonEmptyList() {
+        assertEquals(
+                Arrays.asList('7', '5', '3', '1'),
+                ListOps.reverse(Arrays.asList('1', '3', '5', '7')));
     }
 
 }