Fix compiler warnings.

javadev · javadev · commit b79e7e77295b · 2019-04-24T09:46:38.000+03:00
diff --git a/src/main/java/com/github/underscore/U.java b/src/main/java/com/github/underscore/U.java
@@ -1102,6 +1102,7 @@ public int size() {
         return size(iterable);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> int size(final E ... array) {
         return array.length;
     }
@@ -1157,6 +1158,7 @@ public static <E> E first(final Iterable<E> iterable) {
         return iterable.iterator().next();
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E first(final E ... array) {
         return array[0];
     }
@@ -1212,6 +1214,7 @@ public static <E> E head(final Iterable<E> iterable) {
         return first(iterable);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E head(final E ... array) {
         return first(array);
     }
@@ -1239,6 +1242,7 @@ public static <E> List<E> initial(final List<E> list, final int n) {
         return list.subList(0, Math.max(0, list.size() - n));
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] initial(final E ... array) {
         return initial(array, 1);
     }
@@ -1255,6 +1259,7 @@ public List<T> initial(final int n) {
         return initial((List<T>) iterable, n);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E last(final E ... array) {
         return array[array.length - 1];
     }
@@ -1315,6 +1320,7 @@ public static <E> List<E> rest(final List<E> list, int n) {
         return list.subList(Math.min(n, list.size()), list.size());
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] rest(final E ... array) {
         return rest(array, 1);
     }
@@ -1340,6 +1346,7 @@ public static <E> List<E> tail(final List<E> list, final int n) {
         return rest(list, n);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] tail(final E ... array) {
         return rest(array);
     }
@@ -1364,6 +1371,7 @@ public static <E> List<E> drop(final List<E> list, final int n) {
         return rest(list, n);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] drop(final E ... array) {
         return rest(array);
     }
@@ -1449,6 +1457,7 @@ public List<T> flatten(final boolean shallow) {
     /*
      * Documented, #without
      */
+    @SuppressWarnings("unchecked")
     public static <E> List<E> without(final List<E> list, E ... values) {
         final List<E> valuesList = Arrays.asList(values);
         return filter(list, new Predicate<E>() {
@@ -1494,6 +1503,7 @@ public static <E> List<E> distinct(final List<E> list) {
         return uniq(list);
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] distinct(final E ... array) {
         return uniq(array);
     }
@@ -1509,6 +1519,7 @@ public static <K, E> E[] distinctBy(final E[] array, final Function<E, K> func)
     /*
      * Documented, #union
      */
+    @SuppressWarnings("unchecked")
     public static <E> List<E> union(final List<E> list, final List<E> ... lists) {
         final Set<E> union = newLinkedHashSet();
         union.addAll(list);
@@ -1518,6 +1529,7 @@ public static <E> List<E> union(final List<E> list, final List<E> ... lists) {
         return newArrayList(union);
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> unionWith(final List<T> ... lists) {
         return union(newArrayList(iterable), lists);
     }
@@ -1544,6 +1556,7 @@ public static <E> List<E> intersection(final List<E> list1, final List<E> list2)
         return result;
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> List<E> intersection(final List<E> list, final List<E> ... lists) {
         final Deque<List<E>> stack = new ArrayDeque<List<E>>();
         stack.push(list);
@@ -1553,6 +1566,7 @@ public static <E> List<E> intersection(final List<E> list, final List<E> ... lis
         return stack.peek();
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> intersectionWith(final List<T> ... lists) {
         return intersection(newArrayList(iterable), lists);
     }
@@ -1580,6 +1594,7 @@ public static <E> List<E> difference(final List<E> list1, final List<E> list2) {
         return result;
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> List<E> difference(final List<E> list, final List<E> ... lists) {
         final Deque<List<E>> stack = new ArrayDeque<List<E>>();
         stack.push(list);
@@ -1589,6 +1604,7 @@ public static <E> List<E> difference(final List<E> list, final List<E> ... lists
         return stack.peek();
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> differenceWith(final List<T> ... lists) {
         return difference(newArrayList(iterable), lists);
     }
@@ -1606,6 +1622,7 @@ public static <E> E[] difference(final E[] ... arrays) {
     /*
      * Documented, #zip
      */
+    @SuppressWarnings("unchecked")
     public static <T> List<List<T>> zip(final List<T> ... lists) {
         final List<List<T>> zipped = newArrayList();
         each(Arrays.asList(lists), new Consumer<List<T>>() {
@@ -1625,6 +1642,7 @@ public void accept(final List<T> list) {
         return zipped;
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> List<List<T>> unzip(final List<T> ... lists) {
         final List<List<T>> unzipped = newArrayList();
         for (int index = 0; index < lists[0].size(); index += 1) {
@@ -2078,6 +2096,7 @@ public boolean test(final E item) {
     /*
      * Documented, #compose
      */
+    @SuppressWarnings("unchecked")
     public static <T> Function<T, T> compose(final Function<T, T> ... func) {
         return new Function<T, T>() {
             public T apply(final T arg) {
@@ -2223,6 +2242,7 @@ public static List<String> methods(final Object object) {
     /*
      * Documented, #extend
      */
+    @SuppressWarnings("unchecked")
     public static <K, V> Map<K, V> extend(final Map<K, V> destination, final Map<K, V> ... sources) {
         final Map<K, V> result = newLinkedHashMap();
         for (final Map.Entry<K, V> entry : destination.entrySet()) {
@@ -2356,6 +2376,7 @@ public static Object clone(final Object obj) {
         throw new IllegalArgumentException("Cannot clone object");
     }
 
+    @SuppressWarnings("unchecked")
     public static <E> E[] clone(final E ... iterable) {
         return Arrays.copyOf(iterable, iterable.length);
     }
@@ -2648,6 +2669,7 @@ public static <T> Chain<T> chain(final Iterable<T> iterable, int size) {
         return new U.Chain<T>(newArrayList(iterable, size));
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> Chain<T> chain(final T ... array) {
         return new U.Chain<T>(Arrays.asList(array));
     }
@@ -2935,14 +2957,17 @@ public <F> Chain<F> distinctBy(final Function<T, F> func) {
             return new Chain<F>(U.newArrayList((Iterable<F>) U.uniq(list, func)));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> union(final List<T> ... lists) {
             return new Chain<T>(U.union(list, lists));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> intersection(final List<T> ... lists) {
             return new Chain<T>(U.intersection(list, lists));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> difference(final List<T> ... lists) {
             return new Chain<T>(U.difference(list, lists));
         }
@@ -2987,6 +3012,7 @@ public Chain<T> interposeByList(final Iterable<T> interIter) {
             return new Chain<T>(U.interposeByList(value(), interIter));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> concat(final List<T> ... lists) {
             return new Chain<T>(U.concat(list, lists));
         }
@@ -3019,6 +3045,7 @@ public Chain<String> join(final String separator) {
             return new Chain<String>(U.join(list, separator));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> push(final T ... values) {
             return new Chain<T>(U.push(value(), values));
         }
@@ -3031,6 +3058,7 @@ public Chain<Tuple<T, List<T>>> shift() {
             return new Chain<Tuple<T, List<T>>>(U.shift(value()));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> unshift(final T ... values) {
             return new Chain<T>(U.unshift(value(), values));
         }
@@ -3096,6 +3124,7 @@ public static <T extends Comparable<T>> List<T> sort(final Iterable<T> iterable)
         return localList;
     }
 
+    @SuppressWarnings("unchecked")
     public static <T extends Comparable<T>> T[] sort(final T ... array) {
         final T[] localArray = array.clone();
         Arrays.sort(localArray);
@@ -3143,6 +3172,7 @@ public String join() {
         return join(iterable);
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> List<T> push(final List<T> list, final T ... values) {
         final List<T> result = newArrayList(list);
         for (T value : values) {
@@ -3151,6 +3181,7 @@ public static <T> List<T> push(final List<T> list, final T ... values) {
         return result;
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> push(final T ... values) {
         return push((List<T>) getIterable(), values);
     }
@@ -3163,6 +3194,7 @@ public Tuple<T, List<T>> pop() {
         return pop((List<T>) getIterable());
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> List<T> unshift(final List<T> list, final T ... values) {
         final List<T> result = newArrayList(list);
         int index = 0;
@@ -3173,6 +3205,7 @@ public static <T> List<T> unshift(final List<T> list, final T ... values) {
         return result;
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> unshift(final T ... values) {
         return unshift((List<T>) getIterable(), values);
     }
@@ -3185,6 +3218,7 @@ public Tuple<T, List<T>> shift() {
         return shift((List<T>) getIterable());
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> T[] concat(final T[] first, final T[] ... other) {
         int length = 0;
         for (T[] otherItem : other) {
@@ -3202,6 +3236,7 @@ public static <T> T[] concat(final T[] first, final T[] ... other) {
     /*
      * Documented, #concat
      */
+    @SuppressWarnings("unchecked")
     public static <T> List<T> concat(final Iterable<T> first, final Iterable<T> ... other) {
         List<T> list = newArrayList(first);
         for (Iterable<T> iter : other) {
@@ -3210,6 +3245,7 @@ public static <T> List<T> concat(final Iterable<T> first, final Iterable<T> ...
         return list;
     }
 
+    @SuppressWarnings("unchecked")
     public List<T> concatWith(final Iterable<T> ... other) {
         return concat(iterable, other);
     }
@@ -3339,6 +3375,7 @@ public static <T> List<T> reverse(final Iterable<T> iterable) {
         return result;
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> T[] reverse(final T ... array) {
         T temp;
         final T[] newArray = array.clone();
@@ -3568,6 +3605,7 @@ protected static <K, E> Map<K, E> newLinkedHashMap() {
         return new LinkedHashMap<K, E>();
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> Predicate<T> and(
             final Predicate<? super T> pred1,
             final Predicate<? super T> pred2,
@@ -3592,6 +3630,7 @@ public boolean test(T value) {
         };
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> Predicate<T> or(
             final Predicate<? super T> pred1,
             final Predicate<? super T> pred2,
diff --git a/src/main/java/com/github/underscore/lodash/U.java b/src/main/java/com/github/underscore/lodash/U.java
@@ -345,14 +345,17 @@ public <F> Chain<F> distinctBy(final Function<T, F> func) {
             return new Chain<F>(U.newArrayList((Iterable<F>) U.uniq(value(), func)));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> union(final List<T> ... lists) {
             return new Chain<T>(U.union(value(), lists));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> intersection(final List<T> ... lists) {
             return new Chain<T>(U.intersection(value(), lists));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> difference(final List<T> ... lists) {
             return new Chain<T>(U.difference(value(), lists));
         }
@@ -397,6 +400,7 @@ public Chain<T> interposeByList(final Iterable<T> interIter) {
             return new Chain<T>(U.interposeByList(value(), interIter));
         }
 
+        @SuppressWarnings("unchecked")
         public Chain<T> concat(final List<T> ... lists) {
             return new Chain<T>(U.concat(value(), lists));
         }
@@ -711,6 +715,7 @@ public static <T> Chain<T> chain(final Iterable<T> iterable, int size) {
         return new U.Chain<T>(newArrayList(iterable, size));
     }
 
+    @SuppressWarnings("unchecked")
     public static <T> Chain<T> chain(final T ... list) {
         return new U.Chain<T>(Arrays.asList(list));
     }

Original file line number	Diff line number	Diff line change
`@@ -1102,6 +1102,7 @@ public int size() {`
`1102`	`1102`	`return size(iterable);`
`1103`	`1103`	`}`
`1104`	`1104`
	`1105`	`+ @SuppressWarnings("unchecked")`
`1105`	`1106`	`public static <E> int size(final E ... array) {`
`1106`	`1107`	`return array.length;`
`1107`	`1108`	`}`
`@@ -1157,6 +1158,7 @@ public static <E> E first(final Iterable<E> iterable) {`
`1157`	`1158`	`return iterable.iterator().next();`
`1158`	`1159`	`}`
`1159`	`1160`
	`1161`	`+ @SuppressWarnings("unchecked")`
`1160`	`1162`	`public static <E> E first(final E ... array) {`
`1161`	`1163`	`return array[0];`
`1162`	`1164`	`}`
`@@ -1212,6 +1214,7 @@ public static <E> E head(final Iterable<E> iterable) {`
`1212`	`1214`	`return first(iterable);`
`1213`	`1215`	`}`
`1214`	`1216`
	`1217`	`+ @SuppressWarnings("unchecked")`
`1215`	`1218`	`public static <E> E head(final E ... array) {`
`1216`	`1219`	`return first(array);`
`1217`	`1220`	`}`
`@@ -1239,6 +1242,7 @@ public static <E> List<E> initial(final List<E> list, final int n) {`
`1239`	`1242`	`return list.subList(0, Math.max(0, list.size() - n));`
`1240`	`1243`	`}`
`1241`	`1244`
	`1245`	`+ @SuppressWarnings("unchecked")`
`1242`	`1246`	`public static <E> E[] initial(final E ... array) {`
`1243`	`1247`	`return initial(array, 1);`
`1244`	`1248`	`}`
`@@ -1255,6 +1259,7 @@ public List<T> initial(final int n) {`
`1255`	`1259`	`return initial((List<T>) iterable, n);`
`1256`	`1260`	`}`
`1257`	`1261`
	`1262`	`+ @SuppressWarnings("unchecked")`
`1258`	`1263`	`public static <E> E last(final E ... array) {`
`1259`	`1264`	`return array[array.length - 1];`
`1260`	`1265`	`}`
`@@ -1315,6 +1320,7 @@ public static <E> List<E> rest(final List<E> list, int n) {`
`1315`	`1320`	`return list.subList(Math.min(n, list.size()), list.size());`
`1316`	`1321`	`}`
`1317`	`1322`
	`1323`	`+ @SuppressWarnings("unchecked")`
`1318`	`1324`	`public static <E> E[] rest(final E ... array) {`
`1319`	`1325`	`return rest(array, 1);`
`1320`	`1326`	`}`
`@@ -1340,6 +1346,7 @@ public static <E> List<E> tail(final List<E> list, final int n) {`
`1340`	`1346`	`return rest(list, n);`
`1341`	`1347`	`}`
`1342`	`1348`
	`1349`	`+ @SuppressWarnings("unchecked")`
`1343`	`1350`	`public static <E> E[] tail(final E ... array) {`
`1344`	`1351`	`return rest(array);`
`1345`	`1352`	`}`
`@@ -1364,6 +1371,7 @@ public static <E> List<E> drop(final List<E> list, final int n) {`
`1364`	`1371`	`return rest(list, n);`
`1365`	`1372`	`}`
`1366`	`1373`
	`1374`	`+ @SuppressWarnings("unchecked")`
`1367`	`1375`	`public static <E> E[] drop(final E ... array) {`
`1368`	`1376`	`return rest(array);`
`1369`	`1377`	`}`
`@@ -1449,6 +1457,7 @@ public List<T> flatten(final boolean shallow) {`
`1449`	`1457`	`/*`
`1450`	`1458`	`* Documented, #without`
`1451`	`1459`	`*/`
	`1460`	`+ @SuppressWarnings("unchecked")`
`1452`	`1461`	`public static <E> List<E> without(final List<E> list, E ... values) {`
`1453`	`1462`	`final List<E> valuesList = Arrays.asList(values);`
`1454`	`1463`	`return filter(list, new Predicate<E>() {`
`@@ -1494,6 +1503,7 @@ public static <E> List<E> distinct(final List<E> list) {`
`1494`	`1503`	`return uniq(list);`
`1495`	`1504`	`}`
`1496`	`1505`
	`1506`	`+ @SuppressWarnings("unchecked")`
`1497`	`1507`	`public static <E> E[] distinct(final E ... array) {`
`1498`	`1508`	`return uniq(array);`
`1499`	`1509`	`}`
`@@ -1509,6 +1519,7 @@ public static <K, E> E[] distinctBy(final E[] array, final Function<E, K> func)`
`1509`	`1519`	`/*`
`1510`	`1520`	`* Documented, #union`
`1511`	`1521`	`*/`
	`1522`	`+ @SuppressWarnings("unchecked")`
`1512`	`1523`	`public static <E> List<E> union(final List<E> list, final List<E> ... lists) {`
`1513`	`1524`	`final Set<E> union = newLinkedHashSet();`
`1514`	`1525`	`union.addAll(list);`
`@@ -1518,6 +1529,7 @@ public static <E> List<E> union(final List<E> list, final List<E> ... lists) {`
`1518`	`1529`	`return newArrayList(union);`
`1519`	`1530`	`}`
`1520`	`1531`
	`1532`	`+ @SuppressWarnings("unchecked")`
`1521`	`1533`	`public List<T> unionWith(final List<T> ... lists) {`
`1522`	`1534`	`return union(newArrayList(iterable), lists);`
`1523`	`1535`	`}`
`@@ -1544,6 +1556,7 @@ public static <E> List<E> intersection(final List<E> list1, final List<E> list2)`
`1544`	`1556`	`return result;`
`1545`	`1557`	`}`
`1546`	`1558`
	`1559`	`+ @SuppressWarnings("unchecked")`
`1547`	`1560`	`public static <E> List<E> intersection(final List<E> list, final List<E> ... lists) {`
`1548`	`1561`	`final Deque<List<E>> stack = new ArrayDeque<List<E>>();`
`1549`	`1562`	`stack.push(list);`
`@@ -1553,6 +1566,7 @@ public static <E> List<E> intersection(final List<E> list, final List<E> ... lis`
`1553`	`1566`	`return stack.peek();`
`1554`	`1567`	`}`
`1555`	`1568`
	`1569`	`+ @SuppressWarnings("unchecked")`
`1556`	`1570`	`public List<T> intersectionWith(final List<T> ... lists) {`
`1557`	`1571`	`return intersection(newArrayList(iterable), lists);`
`1558`	`1572`	`}`
`@@ -1580,6 +1594,7 @@ public static <E> List<E> difference(final List<E> list1, final List<E> list2) {`
`1580`	`1594`	`return result;`
`1581`	`1595`	`}`
`1582`	`1596`
	`1597`	`+ @SuppressWarnings("unchecked")`
`1583`	`1598`	`public static <E> List<E> difference(final List<E> list, final List<E> ... lists) {`
`1584`	`1599`	`final Deque<List<E>> stack = new ArrayDeque<List<E>>();`
`1585`	`1600`	`stack.push(list);`
`@@ -1589,6 +1604,7 @@ public static <E> List<E> difference(final List<E> list, final List<E> ... lists`
`1589`	`1604`	`return stack.peek();`
`1590`	`1605`	`}`
`1591`	`1606`
	`1607`	`+ @SuppressWarnings("unchecked")`
`1592`	`1608`	`public List<T> differenceWith(final List<T> ... lists) {`
`1593`	`1609`	`return difference(newArrayList(iterable), lists);`
`1594`	`1610`	`}`
`@@ -1606,6 +1622,7 @@ public static <E> E[] difference(final E[] ... arrays) {`
`1606`	`1622`	`/*`
`1607`	`1623`	`* Documented, #zip`
`1608`	`1624`	`*/`
	`1625`	`+ @SuppressWarnings("unchecked")`
`1609`	`1626`	`public static <T> List<List<T>> zip(final List<T> ... lists) {`
`1610`	`1627`	`final List<List<T>> zipped = newArrayList();`
`1611`	`1628`	`each(Arrays.asList(lists), new Consumer<List<T>>() {`
`@@ -1625,6 +1642,7 @@ public void accept(final List<T> list) {`
`1625`	`1642`	`return zipped;`
`1626`	`1643`	`}`
`1627`	`1644`
	`1645`	`+ @SuppressWarnings("unchecked")`
`1628`	`1646`	`public static <T> List<List<T>> unzip(final List<T> ... lists) {`
`1629`	`1647`	`final List<List<T>> unzipped = newArrayList();`
`1630`	`1648`	`for (int index = 0; index < lists[0].size(); index += 1) {`
`@@ -2078,6 +2096,7 @@ public boolean test(final E item) {`
`2078`	`2096`	`/*`
`2079`	`2097`	`* Documented, #compose`
`2080`	`2098`	`*/`
	`2099`	`+ @SuppressWarnings("unchecked")`
`2081`	`2100`	`public static <T> Function<T, T> compose(final Function<T, T> ... func) {`
`2082`	`2101`	`return new Function<T, T>() {`
`2083`	`2102`	`public T apply(final T arg) {`
`@@ -2223,6 +2242,7 @@ public static List<String> methods(final Object object) {`
`2223`	`2242`	`/*`
`2224`	`2243`	`* Documented, #extend`
`2225`	`2244`	`*/`
	`2245`	`+ @SuppressWarnings("unchecked")`
`2226`	`2246`	`public static <K, V> Map<K, V> extend(final Map<K, V> destination, final Map<K, V> ... sources) {`
`2227`	`2247`	`final Map<K, V> result = newLinkedHashMap();`
`2228`	`2248`	`for (final Map.Entry<K, V> entry : destination.entrySet()) {`
`@@ -2356,6 +2376,7 @@ public static Object clone(final Object obj) {`
`2356`	`2376`	`throw new IllegalArgumentException("Cannot clone object");`
`2357`	`2377`	`}`
`2358`	`2378`
	`2379`	`+ @SuppressWarnings("unchecked")`
`2359`	`2380`	`public static <E> E[] clone(final E ... iterable) {`
`2360`	`2381`	`return Arrays.copyOf(iterable, iterable.length);`
`2361`	`2382`	`}`
`@@ -2648,6 +2669,7 @@ public static <T> Chain<T> chain(final Iterable<T> iterable, int size) {`
`2648`	`2669`	`return new U.Chain<T>(newArrayList(iterable, size));`
`2649`	`2670`	`}`
`2650`	`2671`
	`2672`	`+ @SuppressWarnings("unchecked")`
`2651`	`2673`	`public static <T> Chain<T> chain(final T ... array) {`
`2652`	`2674`	`return new U.Chain<T>(Arrays.asList(array));`
`2653`	`2675`	`}`
`@@ -2935,14 +2957,17 @@ public <F> Chain<F> distinctBy(final Function<T, F> func) {`
`2935`	`2957`	`return new Chain<F>(U.newArrayList((Iterable<F>) U.uniq(list, func)));`
`2936`	`2958`	`}`
`2937`	`2959`
	`2960`	`+ @SuppressWarnings("unchecked")`
`2938`	`2961`	`public Chain<T> union(final List<T> ... lists) {`
`2939`	`2962`	`return new Chain<T>(U.union(list, lists));`
`2940`	`2963`	`}`
`2941`	`2964`
	`2965`	`+ @SuppressWarnings("unchecked")`
`2942`	`2966`	`public Chain<T> intersection(final List<T> ... lists) {`
`2943`	`2967`	`return new Chain<T>(U.intersection(list, lists));`
`2944`	`2968`	`}`
`2945`	`2969`
	`2970`	`+ @SuppressWarnings("unchecked")`
`2946`	`2971`	`public Chain<T> difference(final List<T> ... lists) {`
`2947`	`2972`	`return new Chain<T>(U.difference(list, lists));`
`2948`	`2973`	`}`
`@@ -2987,6 +3012,7 @@ public Chain<T> interposeByList(final Iterable<T> interIter) {`
`2987`	`3012`	`return new Chain<T>(U.interposeByList(value(), interIter));`
`2988`	`3013`	`}`
`2989`	`3014`
	`3015`	`+ @SuppressWarnings("unchecked")`
`2990`	`3016`	`public Chain<T> concat(final List<T> ... lists) {`
`2991`	`3017`	`return new Chain<T>(U.concat(list, lists));`
`2992`	`3018`	`}`
`@@ -3019,6 +3045,7 @@ public Chain<String> join(final String separator) {`
`3019`	`3045`	`return new Chain<String>(U.join(list, separator));`
`3020`	`3046`	`}`
`3021`	`3047`
	`3048`	`+ @SuppressWarnings("unchecked")`
`3022`	`3049`	`public Chain<T> push(final T ... values) {`
`3023`	`3050`	`return new Chain<T>(U.push(value(), values));`
`3024`	`3051`	`}`
`@@ -3031,6 +3058,7 @@ public Chain<Tuple<T, List<T>>> shift() {`
`3031`	`3058`	`return new Chain<Tuple<T, List<T>>>(U.shift(value()));`
`3032`	`3059`	`}`
`3033`	`3060`
	`3061`	`+ @SuppressWarnings("unchecked")`
`3034`	`3062`	`public Chain<T> unshift(final T ... values) {`
`3035`	`3063`	`return new Chain<T>(U.unshift(value(), values));`
`3036`	`3064`	`}`
`@@ -3096,6 +3124,7 @@ public static <T extends Comparable<T>> List<T> sort(final Iterable<T> iterable)`
`3096`	`3124`	`return localList;`
`3097`	`3125`	`}`
`3098`	`3126`
	`3127`	`+ @SuppressWarnings("unchecked")`
`3099`	`3128`	`public static <T extends Comparable<T>> T[] sort(final T ... array) {`
`3100`	`3129`	`final T[] localArray = array.clone();`
`3101`	`3130`	`Arrays.sort(localArray);`
`@@ -3143,6 +3172,7 @@ public String join() {`
`3143`	`3172`	`return join(iterable);`
`3144`	`3173`	`}`
`3145`	`3174`
	`3175`	`+ @SuppressWarnings("unchecked")`
`3146`	`3176`	`public static <T> List<T> push(final List<T> list, final T ... values) {`
`3147`	`3177`	`final List<T> result = newArrayList(list);`
`3148`	`3178`	`for (T value : values) {`
`@@ -3151,6 +3181,7 @@ public static <T> List<T> push(final List<T> list, final T ... values) {`
`3151`	`3181`	`return result;`
`3152`	`3182`	`}`
`3153`	`3183`
	`3184`	`+ @SuppressWarnings("unchecked")`
`3154`	`3185`	`public List<T> push(final T ... values) {`
`3155`	`3186`	`return push((List<T>) getIterable(), values);`
`3156`	`3187`	`}`
`@@ -3163,6 +3194,7 @@ public Tuple<T, List<T>> pop() {`
`3163`	`3194`	`return pop((List<T>) getIterable());`
`3164`	`3195`	`}`
`3165`	`3196`
	`3197`	`+ @SuppressWarnings("unchecked")`
`3166`	`3198`	`public static <T> List<T> unshift(final List<T> list, final T ... values) {`
`3167`	`3199`	`final List<T> result = newArrayList(list);`
`3168`	`3200`	`int index = 0;`
`@@ -3173,6 +3205,7 @@ public static <T> List<T> unshift(final List<T> list, final T ... values) {`
`3173`	`3205`	`return result;`
`3174`	`3206`	`}`
`3175`	`3207`
	`3208`	`+ @SuppressWarnings("unchecked")`
`3176`	`3209`	`public List<T> unshift(final T ... values) {`
`3177`	`3210`	`return unshift((List<T>) getIterable(), values);`
`3178`	`3211`	`}`
`@@ -3185,6 +3218,7 @@ public Tuple<T, List<T>> shift() {`
`3185`	`3218`	`return shift((List<T>) getIterable());`
`3186`	`3219`	`}`
`3187`	`3220`
	`3221`	`+ @SuppressWarnings("unchecked")`
`3188`	`3222`	`public static <T> T[] concat(final T[] first, final T[] ... other) {`
`3189`	`3223`	`int length = 0;`
`3190`	`3224`	`for (T[] otherItem : other) {`
`@@ -3202,6 +3236,7 @@ public static <T> T[] concat(final T[] first, final T[] ... other) {`
`3202`	`3236`	`/*`
`3203`	`3237`	`* Documented, #concat`
`3204`	`3238`	`*/`
	`3239`	`+ @SuppressWarnings("unchecked")`
`3205`	`3240`	`public static <T> List<T> concat(final Iterable<T> first, final Iterable<T> ... other) {`
`3206`	`3241`	`List<T> list = newArrayList(first);`
`3207`	`3242`	`for (Iterable<T> iter : other) {`
`@@ -3210,6 +3245,7 @@ public static <T> List<T> concat(final Iterable<T> first, final Iterable<T> ...`
`3210`	`3245`	`return list;`
`3211`	`3246`	`}`
`3212`	`3247`
	`3248`	`+ @SuppressWarnings("unchecked")`
`3213`	`3249`	`public List<T> concatWith(final Iterable<T> ... other) {`
`3214`	`3250`	`return concat(iterable, other);`
`3215`	`3251`	`}`
`@@ -3339,6 +3375,7 @@ public static <T> List<T> reverse(final Iterable<T> iterable) {`
`3339`	`3375`	`return result;`
`3340`	`3376`	`}`
`3341`	`3377`
	`3378`	`+ @SuppressWarnings("unchecked")`
`3342`	`3379`	`public static <T> T[] reverse(final T ... array) {`
`3343`	`3380`	`T temp;`
`3344`	`3381`	`final T[] newArray = array.clone();`
`@@ -3568,6 +3605,7 @@ protected static <K, E> Map<K, E> newLinkedHashMap() {`
`3568`	`3605`	`return new LinkedHashMap<K, E>();`
`3569`	`3606`	`}`
`3570`	`3607`
	`3608`	`+ @SuppressWarnings("unchecked")`
`3571`	`3609`	`public static <T> Predicate<T> and(`
`3572`	`3610`	`final Predicate<? super T> pred1,`
`3573`	`3611`	`final Predicate<? super T> pred2,`
`@@ -3592,6 +3630,7 @@ public boolean test(T value) {`
`3592`	`3630`	`};`
`3593`	`3631`	`}`
`3594`	`3632`
	`3633`	`+ @SuppressWarnings("unchecked")`
`3595`	`3634`	`public static <T> Predicate<T> or(`
`3596`	`3635`	`final Predicate<? super T> pred1,`
`3597`	`3636`	`final Predicate<? super T> pred2,`
Original file line number	Diff line number	Diff line change
`@@ -345,14 +345,17 @@ public <F> Chain<F> distinctBy(final Function<T, F> func) {`
`345`	`345`	`return new Chain<F>(U.newArrayList((Iterable<F>) U.uniq(value(), func)));`
`346`	`346`	`}`
`347`	`347`
	`348`	`+ @SuppressWarnings("unchecked")`
`348`	`349`	`public Chain<T> union(final List<T> ... lists) {`
`349`	`350`	`return new Chain<T>(U.union(value(), lists));`
`350`	`351`	`}`
`351`	`352`
	`353`	`+ @SuppressWarnings("unchecked")`
`352`	`354`	`public Chain<T> intersection(final List<T> ... lists) {`
`353`	`355`	`return new Chain<T>(U.intersection(value(), lists));`
`354`	`356`	`}`
`355`	`357`
	`358`	`+ @SuppressWarnings("unchecked")`
`356`	`359`	`public Chain<T> difference(final List<T> ... lists) {`
`357`	`360`	`return new Chain<T>(U.difference(value(), lists));`
`358`	`361`	`}`
`@@ -397,6 +400,7 @@ public Chain<T> interposeByList(final Iterable<T> interIter) {`
`397`	`400`	`return new Chain<T>(U.interposeByList(value(), interIter));`
`398`	`401`	`}`
`399`	`402`
	`403`	`+ @SuppressWarnings("unchecked")`
`400`	`404`	`public Chain<T> concat(final List<T> ... lists) {`
`401`	`405`	`return new Chain<T>(U.concat(value(), lists));`
`402`	`406`	`}`
`@@ -711,6 +715,7 @@ public static <T> Chain<T> chain(final Iterable<T> iterable, int size) {`
`711`	`715`	`return new U.Chain<T>(newArrayList(iterable, size));`
`712`	`716`	`}`
`713`	`717`
	`718`	`+ @SuppressWarnings("unchecked")`
`714`	`719`	`public static <T> Chain<T> chain(final T ... list) {`
`715`	`720`	`return new U.Chain<T>(Arrays.asList(list));`
`716`	`721`	`}`