Remove Utility Functions from Public API

Fixes #1797

src/main/java/rx/Observable.java

@@ -12,15 +12,15 @@
  */
 package rx;
 
-import static rx.functions.Functions.alwaysFalse;
-
 import java.util.*;
 import java.util.concurrent.*;
 
 import rx.exceptions.*;
 import rx.functions.*;
 import rx.internal.operators.*;
 import rx.internal.util.ScalarSynchronousObservable;
+import rx.internal.util.UtilityFunctions;
+
 import rx.observables.*;
 import rx.observers.SafeSubscriber;
 import rx.plugins.*;
@@ -4030,7 +4030,7 @@ public final <T2> Observable<T2> dematerialize() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229764.aspx">MSDN: Observable.distinct</a>
      */
     public final Observable<T> distinct() {
-        return lift(new OperatorDistinct<T, T>(Functions.<T>identity()));
+        return lift(new OperatorDistinct<T, T>(UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -4070,7 +4070,7 @@ public final <U> Observable<T> distinct(Func1<? super T, ? extends U> keySelecto
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229494.aspx">MSDN: Observable.distinctUntilChanged</a>
      */
     public final Observable<T> distinctUntilChanged() {
-        return lift(new OperatorDistinctUntilChanged<T, T>(Functions.<T>identity()));
+        return lift(new OperatorDistinctUntilChanged<T, T>(UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -4854,7 +4854,7 @@ public final <T2, D1, D2, R> Observable<R> groupJoin(Observable<T2> right, Func1
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229242.aspx">MSDN: Observable.IgnoreElements</a>
      */
     public final Observable<T> ignoreElements() {
-        return filter(alwaysFalse());
+        return filter(UtilityFunctions.alwaysFalse());
     }
 
     /**
@@ -4874,7 +4874,7 @@ public final Observable<T> ignoreElements() {
      * @see <a href= "http://msdn.microsoft.com/en-us/library/hh229905.aspx">MSDN: Observable.Any</a>
      */
     public final Observable<Boolean> isEmpty() {
-        return lift(new OperatorAny<T>(Functions.alwaysTrue(), true));
+        return lift(new OperatorAny<T>(UtilityFunctions.alwaysTrue(), true));
     }
 
     /**
@@ -8481,7 +8481,7 @@ public final Observable<List<T>> toList() {
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh229137.aspx">MSDN: Observable.ToDictionary</a>
      */
     public final <K> Observable<Map<K, T>> toMap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMap<T, K, T>(keySelector, Functions.<T>identity()));
+        return lift(new OperatorToMap<T, K, T>(keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**
@@ -8558,7 +8558,7 @@ public final <K, V> Observable<Map<K, V>> toMap(Func1<? super T, ? extends K> ke
      * @see <a href="http://msdn.microsoft.com/en-us/library/hh212098.aspx">MSDN: Observable.ToLookup</a>
      */
     public final <K> Observable<Map<K, Collection<T>>> toMultimap(Func1<? super T, ? extends K> keySelector) {
-        return lift(new OperatorToMultimap<T, K, T>(keySelector, Functions.<T>identity()));
+        return lift(new OperatorToMultimap<T, K, T>(keySelector, UtilityFunctions.<T>identity()));
     }
 
     /**

src/main/java/rx/functions/Functions.java

@@ -330,134 +330,4 @@ public Void call(Object... args) {
         };
     }
 
-    /**
-     * Returns a function that always returns {@code true}.
-     *
-     * @return a {@link Func1} that accepts an Object and returns the Boolean {@code true}
-     */
-    public static <T> Func1<? super T, Boolean> alwaysTrue() {
-        return AlwaysTrue.INSTANCE;
-    }
-
-    /**
-     * Returns a function that always returns {@code false}.
-     *
-     * @return a {@link Func1} that accepts an Object and returns the Boolean {@code false}
-     */
-    public static <T> Func1<? super T, Boolean> alwaysFalse() {
-        return AlwaysFalse.INSTANCE;
-    }
-
-    /**
-     * Returns a function that always returns the Object it is passed.
-     *
-     * @return a {@link Func1} that accepts an Object and returns the same Object
-     */
-    public static <T> Func1<T, T> identity() {
-        return new Func1<T, T>() {
-            @Override
-            public T call(T o) {
-                return o;
-            }
-        };
-    }
-
-    private enum AlwaysTrue implements Func1<Object, Boolean> {
-        INSTANCE;
-
-        @Override
-        public Boolean call(Object o) {
-            return true;
-        }
-    }
-
-    private enum AlwaysFalse implements Func1<Object, Boolean> {
-        INSTANCE;
-
-        @Override
-        public Boolean call(Object o) {
-            return false;
-        }
-    }
-
-    /**
-     * Returns a function that merely returns {@code null}, without side effects.
-     *
-     * @return a function that returns {@code null}
-     */
-    @SuppressWarnings("unchecked")
-    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> returnNull() {
-        return NULL_FUNCTION;
-    }
-
-    @SuppressWarnings("rawtypes")
-    private static final NullFunction NULL_FUNCTION = new NullFunction();
-
-    private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
-            Func0<R>,
-            Func1<T0, R>,
-            Func2<T0, T1, R>,
-            Func3<T0, T1, T2, R>,
-            Func4<T0, T1, T2, T3, R>,
-            Func5<T0, T1, T2, T3, T4, R>,
-            Func6<T0, T1, T2, T3, T4, T5, R>,
-            Func7<T0, T1, T2, T3, T4, T5, T6, R>,
-            Func8<T0, T1, T2, T3, T4, T5, T6, T7, R>,
-            Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>,
-            FuncN<R> {
-        @Override
-        public R call() {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
-            return null;
-        }
-
-        @Override
-        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
-            return null;
-        }
-
-        @Override
-        public R call(Object... args) {
-            return null;
-        }
-    }
 }

src/main/java/rx/internal/operators/OperatorSequenceEqual.java

@@ -21,7 +21,7 @@
 import rx.Observable;
 import rx.functions.Func1;
 import rx.functions.Func2;
-import rx.functions.Functions;
+import rx.internal.util.UtilityFunctions;
 
 /**
  * Returns an {@link Observable} that emits a single {@code Boolean} value that indicates whether two source
@@ -84,6 +84,6 @@ public Boolean call(Object t1, Object t2) {
                         return equality.call((T)t1, (T)t2);
                     }
 
-                }).all(Functions.<Boolean> identity());
+                }).all(UtilityFunctions.<Boolean> identity());
     }
 }

src/main/java/rx/internal/util/UtilityFunctions.java

@@ -0,0 +1,163 @@
+/**
+ * Copyright 2014 Netflix, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+ * compliance with the License. You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is
+ * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
+ * the License for the specific language governing permissions and limitations under the License.
+ */
+package rx.internal.util;
+
+import rx.functions.Func0;
+import rx.functions.Func1;
+import rx.functions.Func2;
+import rx.functions.Func3;
+import rx.functions.Func4;
+import rx.functions.Func5;
+import rx.functions.Func6;
+import rx.functions.Func7;
+import rx.functions.Func8;
+import rx.functions.Func9;
+import rx.functions.FuncN;
+
+/**
+ * Utility functions for internal use that we don't want part of the public API. 
+ */
+public final class UtilityFunctions {
+
+    /**
+     * Returns a function that always returns {@code true}.
+     *
+     * @return a {@link Func1} that accepts an Object and returns the Boolean {@code true}
+     */
+    public static <T> Func1<? super T, Boolean> alwaysTrue() {
+        return AlwaysTrue.INSTANCE;
+    }
+
+    /**
+     * Returns a function that always returns {@code false}.
+     *
+     * @return a {@link Func1} that accepts an Object and returns the Boolean {@code false}
+     */
+    public static <T> Func1<? super T, Boolean> alwaysFalse() {
+        return AlwaysFalse.INSTANCE;
+    }
+
+    /**
+     * Returns a function that always returns the Object it is passed.
+     *
+     * @return a {@link Func1} that accepts an Object and returns the same Object
+     */
+    public static <T> Func1<T, T> identity() {
+        return new Func1<T, T>() {
+            @Override
+            public T call(T o) {
+                return o;
+            }
+        };
+    }
+
+    private enum AlwaysTrue implements Func1<Object, Boolean> {
+        INSTANCE;
+
+        @Override
+        public Boolean call(Object o) {
+            return true;
+        }
+    }
+
+    private enum AlwaysFalse implements Func1<Object, Boolean> {
+        INSTANCE;
+
+        @Override
+        public Boolean call(Object o) {
+            return false;
+        }
+    }
+
+    /**
+     * Returns a function that merely returns {@code null}, without side effects.
+     *
+     * @return a function that returns {@code null}
+     */
+    @SuppressWarnings("unchecked")
+    public static <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> returnNull() {
+        return NULL_FUNCTION;
+    }
+
+    @SuppressWarnings("rawtypes")
+    private static final NullFunction NULL_FUNCTION = new NullFunction();
+
+    private static final class NullFunction<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, R> implements
+            Func0<R>,
+            Func1<T0, R>,
+            Func2<T0, T1, R>,
+            Func3<T0, T1, T2, R>,
+            Func4<T0, T1, T2, T3, R>,
+            Func5<T0, T1, T2, T3, T4, R>,
+            Func6<T0, T1, T2, T3, T4, T5, R>,
+            Func7<T0, T1, T2, T3, T4, T5, T6, R>,
+            Func8<T0, T1, T2, T3, T4, T5, T6, T7, R>,
+            Func9<T0, T1, T2, T3, T4, T5, T6, T7, T8, R>,
+            FuncN<R> {
+        @Override
+        public R call() {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8) {
+            return null;
+        }
+
+        @Override
+        public R call(T0 t1, T1 t2, T2 t3, T3 t4, T4 t5, T5 t6, T6 t7, T7 t8, T8 t9) {
+            return null;
+        }
+
+        @Override
+        public R call(Object... args) {
+            return null;
+        }
+    }
+
+}