groovy-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sun...@apache.org
Subject [3/8] groovy git commit: GROOVY-8874: Refine tuples to support functional programming better(closes #821)
Date Mon, 12 Nov 2018 16:43:36 GMT
http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer3.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer3.java b/src/main/groovy/groovy/util/function/Consumer3.java
new file mode 100644
index 0000000..f5ac7e2
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer3.java
@@ -0,0 +1,89 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+
+
+/**
+ * A consumer with 3 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer3<T1, T2, T3> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        accept(args.v1(), args.v2(), args.v3());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T2, T3> acceptPartially(T1 v1) {
+        return (v2, v3) -> accept(v1, v2, v3);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T3> acceptPartially(T1 v1, T2 v2) {
+        return (v3) -> accept(v1, v2, v3);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return () -> accept(v1, v2, v3);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T2, T3> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3) -> accept(args.v1(), v2, v3);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T3> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3) -> accept(args.v1(), args.v2(), v3);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer4.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer4.java b/src/main/groovy/groovy/util/function/Consumer4.java
new file mode 100644
index 0000000..97f7252
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer4.java
@@ -0,0 +1,104 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+
+
+/**
+ * A consumer with 4 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer4<T1, T2, T3, T4> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T2, T3, T4> acceptPartially(T1 v1) {
+        return (v2, v3, v4) -> accept(v1, v2, v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T3, T4> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4) -> accept(v1, v2, v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T4> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4) -> accept(v1, v2, v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return () -> accept(v1, v2, v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T2, T3, T4> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4) -> accept(args.v1(), v2, v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T3, T4> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4) -> accept(args.v1(), args.v2(), v3, v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T4> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4) -> accept(args.v1(), args.v2(), args.v3(), v4);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer5.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer5.java b/src/main/groovy/groovy/util/function/Consumer5.java
new file mode 100644
index 0000000..99d76a7
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer5.java
@@ -0,0 +1,119 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+
+
+/**
+ * A consumer with 5 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer5<T1, T2, T3, T4, T5> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T2, T3, T4, T5> acceptPartially(T1 v1) {
+        return (v2, v3, v4, v5) -> accept(v1, v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T3, T4, T5> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5) -> accept(v1, v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T4, T5> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5) -> accept(v1, v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T5> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5) -> accept(v1, v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return () -> accept(v1, v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T2, T3, T4, T5> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5) -> accept(args.v1(), v2, v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T3, T4, T5> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5) -> accept(args.v1(), args.v2(), v3, v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T4, T5> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5) -> accept(args.v1(), args.v2(), args.v3(), v4, v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T5> acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), v5);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer6.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer6.java b/src/main/groovy/groovy/util/function/Consumer6.java
new file mode 100644
index 0000000..6f55b57
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer6.java
@@ -0,0 +1,134 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+
+
+/**
+ * A consumer with 6 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer6<T1, T2, T3, T4, T5, T6> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T2, T3, T4, T5, T6> acceptPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6) -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T3, T4, T5, T6> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6) -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T4, T5, T6> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6) -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T5, T6> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6) -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T6> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6) -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return () -> accept(v1, v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T2, T3, T4, T5, T6> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6) -> accept(args.v1(), v2, v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T3, T4, T5, T6> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6) -> accept(args.v1(), args.v2(), v3, v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T4, T5, T6> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6) -> accept(args.v1(), args.v2(), args.v3(), v4, v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T5, T6> acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T6> acceptPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer7.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer7.java b/src/main/groovy/groovy/util/function/Consumer7.java
new file mode 100644
index 0000000..f7f022e
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer7.java
@@ -0,0 +1,149 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+
+
+/**
+ * A consumer with 7 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer7<T1, T2, T3, T4, T5, T6, T7> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T2, T3, T4, T5, T6, T7> acceptPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T3, T4, T5, T6, T7> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T4, T5, T6, T7> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T5, T6, T7> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T6, T7> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T7> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7) -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return () -> accept(v1, v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T2, T3, T4, T5, T6, T7> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7) -> accept(args.v1(), v2, v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T3, T4, T5, T6, T7> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7) -> accept(args.v1(), args.v2(), v3, v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T4, T5, T6, T7> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7) -> accept(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T5, T6, T7> acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T6, T7> acceptPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T7> acceptPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer8.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer8.java b/src/main/groovy/groovy/util/function/Consumer8.java
new file mode 100644
index 0000000..e39f69c
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer8.java
@@ -0,0 +1,164 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+
+
+/**
+ * A consumer with 8 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer8<T1, T2, T3, T4, T5, T6, T7, T8> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer7<T2, T3, T4, T5, T6, T7, T8> acceptPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T3, T4, T5, T6, T7, T8> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T4, T5, T6, T7, T8> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T5, T6, T7, T8> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T6, T7, T8> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T7, T8> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T8> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8) -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return () -> accept(v1, v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer7<T2, T3, T4, T5, T6, T7, T8> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8) -> accept(args.v1(), v2, v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T3, T4, T5, T6, T7, T8> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8) -> accept(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T4, T5, T6, T7, T8> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8) -> accept(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T5, T6, T7, T8> acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T6, T7, T8> acceptPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T7, T8> acceptPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T8> acceptPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Consumer9.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Consumer9.java b/src/main/groovy/groovy/util/function/Consumer9.java
new file mode 100644
index 0000000..ebea668
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Consumer9.java
@@ -0,0 +1,179 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+import groovy.lang.Tuple9;
+
+
+/**
+ * A consumer with 9 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Consumer9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+
+    /**
+     * Performs this operation on the given argument.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default void accept(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9());
+    }
+
+    /**
+     * Performs this operation on the given argument.
+     */
+    void accept(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9);
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer8<T2, T3, T4, T5, T6, T7, T8, T9> acceptPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer7<T3, T4, T5, T6, T7, T8, T9> acceptPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T4, T5, T6, T7, T8, T9> acceptPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T5, T6, T7, T8, T9> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T6, T7, T8, T9> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T7, T8, T9> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T8, T9> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8, v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T9> acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return (v9) -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+        return () -> accept(v1, v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer8<T2, T3, T4, T5, T6, T7, T8, T9> acceptPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9) -> accept(args.v1(), v2, v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer7<T3, T4, T5, T6, T7, T8, T9> acceptPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8, v9) -> accept(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer6<T4, T5, T6, T7, T8, T9> acceptPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8, v9) -> accept(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer5<T5, T6, T7, T8, T9> acceptPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8, v9) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer4<T6, T7, T8, T9> acceptPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8, v9) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer3<T7, T8, T9> acceptPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8, v9) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer2<T8, T9> acceptPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8, v9) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8, v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer1<T9> acceptPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return (v9) -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), v9);
+    }
+
+    /**
+     * Let this consumer partially accept the arguments.
+     */
+    default Consumer0 acceptPartially(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        return () -> accept(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function0.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function0.java b/src/main/groovy/groovy/util/function/Function0.java
new file mode 100644
index 0000000..4a2a219
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function0.java
@@ -0,0 +1,69 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple0;
+
+import java.util.function.Supplier;
+
+/**
+ * A function with 0 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function0<R> extends Supplier<R> {
+
+    /**
+     * Apply this function to the arguments.
+     */
+    default R apply() {
+        return get();
+    }
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple0 args) {
+        return get();
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    @Override
+    R get();
+
+    /**
+     * Convert this function to a {@link Supplier}
+     */
+    default Supplier<R> toSupplier() {
+        return this::apply;
+    }
+
+    /**
+     * Convert to this function from a {@link Supplier}
+     */
+    static <R> Function0<R> from(Supplier<R> supplier) {
+        return supplier::get;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function1.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function1.java b/src/main/groovy/groovy/util/function/Function1.java
new file mode 100644
index 0000000..e1cc245
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function1.java
@@ -0,0 +1,75 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+
+import java.util.function.Function;
+
+/**
+ * A function with 1 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function1<T1, R> extends Function<T1, R> {
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple1<? extends T1> args) {
+        return apply(args.v1());
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    @Override
+    R apply(T1 v1);
+
+    /**
+     * Convert this function to a {@link Function}.
+     */
+    default Function<T1, R> toFunction() {
+        return this::apply;
+    }
+
+    /**
+     * Convert to this function from a {@link Function}.
+     */
+    static <T1, R> Function1<T1, R> from(Function<? super T1, ? extends R> function) {
+        return function::apply;
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(T1 v1) {
+        return () -> apply(v1);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(Tuple1<? extends T1> args) {
+        return () -> apply(args.v1());
+    }
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function10.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function10.java b/src/main/groovy/groovy/util/function/Function10.java
new file mode 100644
index 0000000..d05a0a8
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function10.java
@@ -0,0 +1,195 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple10;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+import groovy.lang.Tuple9;
+
+
+/**
+ * A function with 10 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> {
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple10<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10> args) {
+        return apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10());
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    R apply(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10);
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T2, T3, T4, T5, T6, T7, T8, T9, T10, R> applyPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T3, T4, T5, T6, T7, T8, T9, T10, R> applyPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T4, T5, T6, T7, T8, T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T5, T6, T7, T8, T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T6, T7, T8, T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T7, T8, T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T8, T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8, v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T9, T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return (v9, v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T10, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+        return (v10) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+        return () -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T2, T3, T4, T5, T6, T7, T8, T9, T10, R> applyPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10) -> apply(args.v1(), v2, v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T3, T4, T5, T6, T7, T8, T9, T10, R> applyPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10) -> apply(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T4, T5, T6, T7, T8, T9, T10, R> applyPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8, v9, v10) -> apply(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T5, T6, T7, T8, T9, T10, R> applyPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8, v9, v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T6, T7, T8, T9, T10, R> applyPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8, v9, v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T7, T8, T9, T10, R> applyPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8, v9, v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T8, T9, T10, R> applyPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8, v9, v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8, v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T9, T10, R> applyPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return (v9, v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), v9, v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T10, R> applyPartially(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        return (v10) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), v10);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(Tuple10<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10> args) {
+        return () -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10());
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function11.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function11.java b/src/main/groovy/groovy/util/function/Function11.java
new file mode 100644
index 0000000..38d5286
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function11.java
@@ -0,0 +1,210 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple10;
+import groovy.lang.Tuple11;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+import groovy.lang.Tuple9;
+
+
+/**
+ * A function with 11 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> {
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple11<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11> args) {
+        return apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11());
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    R apply(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11);
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T3, T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T5, T6, T7, T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T6, T7, T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T7, T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T8, T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8, v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T9, T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return (v9, v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T10, T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+        return (v10, v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T11, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+        return (v11) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) {
+        return () -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) -> apply(args.v1(), v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T3, T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11) -> apply(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T4, T5, T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T5, T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8, v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T6, T7, T8, T9, T10, T11, R> applyPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8, v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T7, T8, T9, T10, T11, R> applyPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8, v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T8, T9, T10, T11, R> applyPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8, v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8, v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T9, T10, T11, R> applyPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return (v9, v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), v9, v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T10, T11, R> applyPartially(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        return (v10, v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), v10, v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T11, R> applyPartially(Tuple10<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10> args) {
+        return (v11) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), v11);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(Tuple11<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11> args) {
+        return () -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11());
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function12.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function12.java b/src/main/groovy/groovy/util/function/Function12.java
new file mode 100644
index 0000000..b7bae15
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function12.java
@@ -0,0 +1,225 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple10;
+import groovy.lang.Tuple11;
+import groovy.lang.Tuple12;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+import groovy.lang.Tuple9;
+
+
+/**
+ * A function with 12 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> {
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple12<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11, ? extends T12> args) {
+        return apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), args.v12());
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    R apply(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12);
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T6, T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T7, T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T8, T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8, v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T9, T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return (v9, v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T10, T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+        return (v10, v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T11, T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+        return (v11, v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T12, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) {
+        return (v12) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) {
+        return () -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1(), v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T4, T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T5, T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T6, T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T7, T8, T9, T10, T11, T12, R> applyPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T8, T9, T10, T11, T12, R> applyPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8, v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8, v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T9, T10, T11, T12, R> applyPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return (v9, v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), v9, v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T10, T11, T12, R> applyPartially(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        return (v10, v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), v10, v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T11, T12, R> applyPartially(Tuple10<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10> args) {
+        return (v11, v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), v11, v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T12, R> applyPartially(Tuple11<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11> args) {
+        return (v12) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), v12);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(Tuple12<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11, ? extends T12> args) {
+        return () -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), args.v12());
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/groovy/blob/3ac1abcd/src/main/groovy/groovy/util/function/Function13.java
----------------------------------------------------------------------
diff --git a/src/main/groovy/groovy/util/function/Function13.java b/src/main/groovy/groovy/util/function/Function13.java
new file mode 100644
index 0000000..fdadc58
--- /dev/null
+++ b/src/main/groovy/groovy/util/function/Function13.java
@@ -0,0 +1,240 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 groovy.util.function;
+
+import groovy.lang.Tuple1;
+import groovy.lang.Tuple10;
+import groovy.lang.Tuple11;
+import groovy.lang.Tuple12;
+import groovy.lang.Tuple13;
+import groovy.lang.Tuple2;
+import groovy.lang.Tuple3;
+import groovy.lang.Tuple4;
+import groovy.lang.Tuple5;
+import groovy.lang.Tuple6;
+import groovy.lang.Tuple7;
+import groovy.lang.Tuple8;
+import groovy.lang.Tuple9;
+
+
+/**
+ * A function with 13 arguments.
+ *
+ * @since 3.0.0
+ */
+@FunctionalInterface
+public interface Function13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> {
+
+    /**
+     * Apply this function to the arguments.
+     *
+     * @param args The arguments as a tuple.
+     */
+    default R apply(Tuple13<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11, ? extends T12, ? extends T13> args) {
+        return apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), args.v12(), args.v13());
+    }
+
+    /**
+     * Apply this function to the arguments.
+     */
+    R apply(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13);
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function11<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4) {
+        return (v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) {
+        return (v6, v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T7, T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) {
+        return (v7, v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T8, T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) {
+        return (v8, v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T9, T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {
+        return (v9, v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T10, T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {
+        return (v10, v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T11, T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {
+        return (v11, v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T12, T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) {
+        return (v12, v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T13, R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) {
+        return (v13) -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) {
+        return () -> apply(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple1<? extends T1> args) {
+        return (v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function11<T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple2<? extends T1, ? extends T2> args) {
+        return (v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function10<T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple3<? extends T1, ? extends T2, ? extends T3> args) {
+        return (v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function9<T5, T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple4<? extends T1, ? extends T2, ? extends T3, ? extends T4> args) {
+        return (v5, v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), v5, v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function8<T6, T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple5<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5> args) {
+        return (v6, v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), v6, v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function7<T7, T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple6<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6> args) {
+        return (v7, v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), v7, v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function6<T8, T9, T10, T11, T12, T13, R> applyPartially(Tuple7<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7> args) {
+        return (v8, v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), v8, v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function5<T9, T10, T11, T12, T13, R> applyPartially(Tuple8<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8> args) {
+        return (v9, v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), v9, v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function4<T10, T11, T12, T13, R> applyPartially(Tuple9<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9> args) {
+        return (v10, v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), v10, v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function3<T11, T12, T13, R> applyPartially(Tuple10<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10> args) {
+        return (v11, v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), v11, v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function2<T12, T13, R> applyPartially(Tuple11<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11> args) {
+        return (v12, v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), v12, v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function1<T13, R> applyPartially(Tuple12<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11, ? extends T12> args) {
+        return (v13) -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), args.v12(), v13);
+    }
+
+    /**
+     * Partially apply this function to the arguments.
+     */
+    default Function0<R> applyPartially(Tuple13<? extends T1, ? extends T2, ? extends T3, ? extends T4, ? extends T5, ? extends T6, ? extends T7, ? extends T8, ? extends T9, ? extends T10, ? extends T11, ? extends T12, ? extends T13> args) {
+        return () -> apply(args.v1(), args.v2(), args.v3(), args.v4(), args.v5(), args.v6(), args.v7(), args.v8(), args.v9(), args.v10(), args.v11(), args.v12(), args.v13());
+    }
+
+}


Mime
View raw message