8 files changed, 123 insertions, 140 deletions

diff --git a/src/ch/epfl/xblast/Cell.java b/src/ch/epfl/xblast/Cell.java
index 6874b54..3f41e5c 100644
--- a/src/ch/epfl/xblast/Cell.java
+++ b/src/ch/epfl/xblast/Cell.java
@@ -30,12 +30,12 @@ public final class Cell implements Comparable<Cell> {
     /**
      * The list of the board's Cell-s, major-ordered.
      */
-    public static final List<Cell> ROW_MAJOR_ORDER = Collections.unmodifiableList(rowMajorOrder());
+    public static final List<Cell> ROW_MAJOR_ORDER = rowMajorOrder();
 
     /**
      * The list of the board's Cell-s, spiral-ordered.
      */
-    public static final List<Cell> SPIRAL_ORDER = Collections.unmodifiableList(spiralOrder());
+    public static final List<Cell> SPIRAL_ORDER = spiralOrder();
 
     /**
      * The coordinates of the Cell.
@@ -69,14 +69,14 @@ public final class Cell implements Comparable<Cell> {
      *
      * @return the list of Cell-s
      */
-    private static ArrayList<Cell> rowMajorOrder() {
+    private static List<Cell> rowMajorOrder() {
         ArrayList<Cell> list = new ArrayList<>(COUNT);
 
         for (int row = 0; row < ROWS; ++row)
             for (int col = 0; col < COLUMNS; ++col)
                 list.add(new Cell(col, row));
 
-        return list;
+        return Collections.unmodifiableList(list);
     }
 
     /**
@@ -84,7 +84,7 @@ public final class Cell implements Comparable<Cell> {
      *
      * @return the list of Cell-s
      */
-    private static ArrayList<Cell> spiralOrder() {
+    private static List<Cell> spiralOrder() {
         ArrayList<Cell> list = new ArrayList<>(COUNT);
         ArrayList<Integer> ix = range(0, COLUMNS, 1);
         ArrayList<Integer> iy = range(0, ROWS, 1);
@@ -101,7 +101,7 @@ public final class Cell implements Comparable<Cell> {
             horizontal = !horizontal;
         }
 
-        return list;
+        return Collections.unmodifiableList(list);
     }
 
     /**
diff --git a/src/ch/epfl/xblast/Lists.java b/src/ch/epfl/xblast/Lists.java
index bf0cafa..777fab2 100644
--- a/src/ch/epfl/xblast/Lists.java
+++ b/src/ch/epfl/xblast/Lists.java
@@ -37,33 +37,27 @@ public final class Lists {
     }
 
     /**
-     * Returns a symmetric version of the list, without repeating the last element of the input list.
-     * For instance, mirrored([kay]) will return [kayak].
+     * Returns a copy of the given list with element e prepended.
      *
-     * @param l   the input list
+     * @param l   the list
+     * @param e   the element to prepend
      * @param <T> the type of the list's elements
-     * @return the mirrored list
-     * @throws IllegalArgumentException if the given list is empty
+     * @return a copy of the list with the element prepended
      */
-    public static <T> List<T> mirrored(List<T> l) {
-        if (l == null || l.size() == 0) throw new IllegalArgumentException();
-
-        return Stream
-                .concat(l.stream(), Lists.reversed(l).stream().skip(1))
-                .collect(Collectors.toList());
+    public static <T> List<T> prepended(List<T> l, T e) {
+        return Lists.inserted(l, 0, e);
     }
 
     /**
-     * Returns a reversed copy of the given list, leaving the original one unmodified.
+     * Returns a copy of the given list with element e appended.
      *
-     * @param l   the list to reverse
+     * @param l   the list
+     * @param e   the element to append
      * @param <T> the type of the list's elements
-     * @return a reversed copy of the list
+     * @return a copy of the list with the element appended
      */
-    private static <T> List<T> reversed(List<T> l) {
-        List<T> r = new ArrayList<>(l);
-        Collections.reverse(r);
-        return r;
+    public static <T> List<T> appended(List<T> l, T e) {
+        return Lists.inserted(l, l.size(), e);
     }
 
     /**
@@ -89,46 +83,24 @@ public final class Lists {
      * @return a copy of the list with the element inserted at start and end
      */
     public static <T> List<T> surrounded(List<T> l, T e) {
-        return Lists.inserted(Lists.inserted(l, 0, e), l.size() + 1, e);
+        return Lists.appended(Lists.prepended(l, e), e);
     }
 
     /**
-     * Returns a copy of the given list with element e inserted at index i.
-     *
-     * @param l   the list
-     * @param i   the insertion index
-     * @param e   the element to insert
-     * @param <T> the type of the list's elements
-     * @return a copy of the list with the element inserted
-     */
-    public static <T> List<T> inserted(List<T> l, int i, T e) {
-        List<T> r = new LinkedList<>(l);
-        r.add(i, e);
-        return r;
-    }
-
-    /**
-     * Returns a copy of the given list with element e prepended.
+     * Returns a symmetric version of the list, without repeating the last element of the input list.
+     * For instance, mirrored([kay]) will return [kayak].
      *
-     * @param l   the list
-     * @param e   the element to prepend
+     * @param l   the input list
      * @param <T> the type of the list's elements
-     * @return a copy of the list with the element prepended
+     * @return the mirrored list
+     * @throws IllegalArgumentException if the given list is empty
      */
-    public static <T> List<T> prepended(List<T> l, T e) {
-        return Lists.inserted(l, 0, e);
-    }
+    public static <T> List<T> mirrored(List<T> l) {
+        if (l == null || l.size() == 0) throw new IllegalArgumentException();
 
-    /**
-     * Returns a copy of the given list with element e appended.
-     *
-     * @param l   the list
-     * @param e   the element to append
-     * @param <T> the type of the list's elements
-     * @return a copy of the list with the element appended
-     */
-    public static <T> List<T> appended(List<T> l, T e) {
-        return Lists.inserted(l, l.size(), e);
+        return Stream
+                .concat(l.stream(), Lists.reversed(l).stream().skip(1))
+                .collect(Collectors.toList());
     }
 
     /**
@@ -173,16 +145,56 @@ public final class Lists {
      * @param lists the lists to concatenate
      * @param <T>   the type of the list's elements
      * @return the list result of the concatenation
+     * @deprecated Use List<T> concatenated(List<List<T>> lists) instead to avoid parametrized varargs.
      */
     public static <T> List<T> concatenated(List<T>... lists) {
+        return concatenated(Arrays.asList(lists));
+    }
+
+    /**
+     * Returns an immutable copy of the given lists, concatenated.
+     *
+     * @param lists the lists to concatenate
+     * @param <T>   the type of the list's elements
+     * @return the list result of the concatenation
+     */
+    public static <T> List<T> concatenated(List<List<T>> lists) {
         return Collections.unmodifiableList(
-                Stream.of(lists)
+                lists.stream()
                         .map(List::stream)
-                        .reduce(Stream::concat).orElse(Stream.empty())
+                        .reduce(Stream::concat).orElseGet(Stream::empty)
                         .collect(Collectors.toList()));
     }
 
     /**
+     * Returns a reversed copy of the given list, leaving the original one unmodified.
+     *
+     * @param l   the list to reverse
+     * @param <T> the type of the list's elements
+     * @return a reversed copy of the list
+     */
+    private static <T> List<T> reversed(List<T> l) {
+        List<T> r = new ArrayList<>(l);
+        Collections.reverse(r);
+        return r;
+    }
+
+    /**
+     * Returns a copy of the given list with element e inserted at index i.
+     *
+     * @param l   the list