Repacking/renaming.

Moves everything into a new package, `scala.runtime.jfunc`. This is a
preemptive move to avoid split-packaging problems under OSGi.

Uses slightly longer names for the types:

    s/F1/JFunction1/
    s/P1/JProcedure1/
    s/F/JFunc/

Author: retronym

README.md

@@ -8,7 +8,7 @@ using Java 8 lambda syntax.
 
 ```java
 import scala.concurrent.*;
-import static scala.runtime.F.func;
+import static scala.runtime.jfunc.JFunc.*;
 
 class Test {
 	private static Future<Integer> futureExample(Future<String> future, ExecutionContext ec) {
@@ -17,7 +17,7 @@ class Test {
 }
 ```
 
-[More Examples / Documentation](https://github.com/retronym/java-8-function1/blob/master/src/test/java/scala/runtime/test/Test.java)
+[More Examples / Documentation](https://github.com/retronym/java-8-function1/blob/master/src/test/java/scala/runtime/jfunc/Test.java)
 
 ### Hacking
 
@@ -38,7 +38,7 @@ class Test {
 package scala.runtime;
 
 @FunctionalInterface
-public interface F1$mcII$sp extends F1 {
+public interface JFunction1$mcII$sp extends JFunction1 {
     abstract int apply$mcII$sp(int v1);
 
     default Object apply(Object s) { return (Integer) apply$mcII$sp((Integer) s); }

build.sbt

@@ -2,16 +2,16 @@ scalaVersion := "2.11.0-RC1"
 
 sourceGenerators in Compile <+= sourceManaged in Compile map { dir =>
   def write(name: String, content: String) = {
-    val f = dir / "java" / "scala" / "runtime" / s"${name}.java"
+    val f = dir / "java" / "scala" / "runtime" / "jfunc" / s"${name}.java"
     IO.write(f, content)
     f
   }
-  Seq(write("F", CodeGen.factory)) ++ (0 to 22).map(n => write("F" + n, CodeGen.fN(n))) ++ (1 to 22).map(n => write("P" + n, CodeGen.pN(n)))
+  Seq(write("JFunc", CodeGen.factory)) ++ (0 to 22).map(n => write("JFunction" + n, CodeGen.fN(n))) ++ (1 to 22).map(n => write("JProcedure" + n, CodeGen.pN(n)))
 }
 
 sourceGenerators in Test <+= sourceManaged in Test map { dir =>
   def write(name: String, content: String) = {
-    val f = dir / "java" / "scala" / "runtime" / "test" / s"${name}.java"
+    val f = dir / "java" / "scala" / "runtime" / "jfunc" / s"${name}.java"
     IO.write(f, content)
     f
   }

project/CodeGen.scala

@@ -17,6 +17,7 @@ object Type {
 }
 
 object CodeGen {
+  def packaging = "package scala.runtime.jfunc;"
   case class arity(n: Int) {
     val ns = (1 to n).toList
 
@@ -28,21 +29,21 @@ object CodeGen {
       s"""
       |$copyright
       |
-      |package scala.runtime;
+      |$packaging
       |
       |@FunctionalInterface
-      |public interface F0<R> extends scala.Function0<R> {
+      |public interface JFunction0<R> extends scala.Function0<R> {
       |    default void $initName() {
       |    };
       |""".stripMargin
     private def f1Header =
       s"""
       |$copyright
       |
-      |package scala.runtime;
+      |$packaging
       |
       |@FunctionalInterface
-      |public interface F1<T1, R> extends scala.Function1<T1, R> {
+      |public interface JFunction1<T1, R> extends scala.Function1<T1, R> {
       |    default void $initName() {
       |    };
       |
@@ -65,10 +66,10 @@ object CodeGen {
       s"""
        |$copyright
        |
-       |package scala.runtime;
+       |$packaging
        |
        |@FunctionalInterface
-       |public interface F$n<$tparams, R> extends scala.Function$n<$tparams, R> {
+       |public interface JFunction$n<$tparams, R> extends scala.Function$n<$tparams, R> {
        |    default void $initName() {
        |    };
        |
@@ -93,16 +94,16 @@ object CodeGen {
     def pN: String = {
       val vparams = csv(n => s"T$n t$n")
       val vparamRefs = csv(n => s"t$n")
-      val parent = "F" + n
+      val parent = "JFunction" + n
       s"""
       |$copyright
       |
-      |package scala.runtime;
+      |$packaging
       |
       |import scala.runtime.BoxedUnit;
       |
       |@FunctionalInterface
-      |public interface P${n}<${tparams}> extends ${parent}<$tparams, BoxedUnit> {
+      |public interface JProcedure${n}<${tparams}> extends ${parent}<$tparams, BoxedUnit> {
       |    default void $initName() {
       |    }
       |
@@ -118,8 +119,8 @@ object CodeGen {
 
     def factory: String = {
       s"""
-      |public static <$tparams, R> scala.Function$n<$tparams, R> func(F$n<$tparams, R> f) { return f; }
-      |public static <$tparams> scala.Function$n<$tparams, BoxedUnit> proc(P$n<$tparams> p) { return p; }
+      |public static <$tparams, R> scala.Function$n<$tparams, R> func(JFunction$n<$tparams, R> f) { return f; }
+      |public static <$tparams> scala.Function$n<$tparams, BoxedUnit> proc(JProcedure$n<$tparams> p) { return p; }
       |""".stripMargin.trim
     }
 
@@ -220,13 +221,13 @@ object CodeGen {
     s"""
     |$copyright
     |
-    |package scala.runtime;
+    |$packaging
     |
     |import scala.runtime.BoxedUnit;
     |
-    |public final class F {
-    |    private F() {}
-    |    public static <R> scala.Function0<R> f0(F0<R> f) { return f; }
+    |public final class JFunc {
+    |    private JFunc() {}
+    |    public static <R> scala.Function0<R> func(JFunction0<R> f) { return f; }
     |${indent(ms)}
     |}
     |
@@ -237,7 +238,7 @@ object CodeGen {
     s"""
     |$copyright
     |
-    |package scala.runtime.test;
+    |$packaging
     |
     |final class TestAPI {
     |${(1 to 22).map(n => arity(n).accept).map(indent).mkString("\n\n")}

…c/test/java/scala/runtime/test/Test.java …/test/java/scala/runtime/jfunc/Test.javasrc/test/java/scala/runtime/test/Test.java renamed to src/test/java/scala/runtime/jfunc/Test.java src/test/java/scala/runtime/test/Test.java renamed to src/test/java/scala/runtime/jfunc/Test.java

@@ -1,11 +1,11 @@
 /*
  * Copyright (C) 2012-2014 Typesafe Inc. <http://www.typesafe.com>
  */
-package scala.runtime.test;
+package scala.runtime.jfunc;
 
 import scala.runtime.*;
-import static scala.runtime.test.TestAPI.*;
-import static scala.runtime.F.*;
+import static scala.runtime.jfunc.TestAPI.*;
+import static scala.runtime.jfunc.JFunc.*;
 
 public class Test {
     public static void main(String[] args) {
@@ -21,11 +21,11 @@ public static void main(String[] args) {
 
         // That's a pity, but we can get pretty close with this library!
 
-        // We have to tell javac to use `F1` as the functional interface.
-        F1<String, String> f1 = (String s) -> s;
+        // We have to tell javac to use `JFunction1` as the functional interface.
+        JFunction1<String, String> f1 = (String s) -> s;
 
         // That's more or less equivalent to the old, anonymous class syntax:
-        new F1<String, String>() {
+        new JFunction1<String, String>() {
             public String apply(String s) { return s; }
         };
 
@@ -40,9 +40,9 @@ public static void main(String[] args) {
         // F1 is a subclass of Function1:
         scala.Function1<String, String> f2 = f1;
 
-        // Factory methods in `F` can reduce the verbosity a little:
+        // Factory methods in `JFunc` can reduce the verbosity a little:
         // `func` is actually just an identity method; it only exists to
-        // trigger lambda creation using the `F1` functional interface.
+        // trigger lambda creation using the `JFunction1` functional interface.
         scala.Function1<String, String> f3 = func((String s) -> s);
 
         // Note that javac's type inference can infer the parameter type here,
@@ -53,7 +53,7 @@ public static void main(String[] args) {
 
         // Specialized variants of the `apply` method are implenented in the
         // functional interface
-        F1<Integer, Integer> f5 = (i) -> -i;
+        JFunction1<Integer, Integer> f5 = (i) -> -i;
         assert(f5.apply(1) == -1);
         assert(f5.apply$mcII$sp(1) == -1);
 
@@ -62,10 +62,10 @@ public static void main(String[] args) {
         scala.Function2<String, String, String> f6 = func((s1, s2) -> join(s1, s2));
         assert(f6.curried().apply("1").apply("2").equals("12"));
 
-        // Functions returning unit must use the `P1`, ... functional interfaces
+        // Functions returning unit must use the `JProcedure1`, ... functional interfaces
         // in order to convert a void lamdba return to Scala's Unit.
         //
-        // The easiest way to do this is via `F.proc`, ....
+        // The easiest way to do this is via `JFunc.proc`, ....
         //
         // Note that the lambda has a return type of `void` if the last
         // statement is a call to a `void` returning method, or if it is
@@ -74,7 +74,7 @@ public static void main(String[] args) {
         scala.Function1<String, BoxedUnit> f8 = proc(s -> {s.toUpperCase(); return;});
 
         // Function0 is also available
-        scala.Function0<String> f9 = F.f0(() -> "42");
+        scala.Function0<String> f9 = func(() -> "42");
         assert(f9.apply().equals("42"));
 
         // You can go up to 22 (the highest arity function defined in the Scala standard library.)