From 8ba1f04147d8f85e1a26fac2f91f91ecdad366d4 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Mon, 24 Nov 2014 15:08:01 -0500
Subject: [PATCH 01/12] Partial application initial development

No support yet for recursive partial applications; just a basic concept.
---
 Makefile                       |   5 +-
 src/apply/partial.xsl          |  85 ++++++++++++++
 test/apply/partial-test.xsl    |  43 +++++++
 test/apply/partial.xspec       | 202 +++++++++++++++++++++++++++++++++
 test/transform/apply-gen.xspec |   4 +-
 5 files changed, 335 insertions(+), 4 deletions(-)
 create mode 100644 src/apply/partial.xsl
 create mode 100644 test/apply/partial-test.xsl
 create mode 100644 test/apply/partial.xspec

diff --git a/Makefile b/Makefile
index 4df9b82..ab7c49e 100644
--- a/Makefile
+++ b/Makefile
@@ -19,12 +19,13 @@
 path_src  := src
 path_test := test
 
-test_in_apply_gen := $(path_test)/transform/apply-gen-test-in.xsl.apply
+test_apply := $(path_test)/apply/partial-test.xsl.apply \
+              $(path_test)/transform/apply-gen-test-in.xsl.apply
 
 .PHONY: check test
 
 test: check
-check: $(test_in_apply_gen)
+check:  $(test_apply)
 	$(path_test)/runner
 
 %.apply: %
diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
new file mode 100644
index 0000000..14ad561
--- /dev/null
+++ b/src/apply/partial.xsl
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Partial function application
+
+  Copyright (C) 2014 LoVullo Associates, Inc.
+
+    This file is part of hoxsl.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  Partial applications may only be used with dynamic functions
+  (functions compatible with `f:apply').
+-->
+
+<stylesheet version="2.0"
+  xmlns="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:f="http://www.lovullo.com/hoxsl/apply">
+
+
+<!--
+  Partially apply dynamic function reference FNREF
+
+  When provided to `f:apply', FNREF will be applied with ARGS as its
+  beginning argments, followed by any arguments to `f:apply'.
+
+  Note that you usually do not have to invoke this function directly:
+  the dynamic function calls will handle currying/partial application
+  for you, which has a much more inviting syntax.
+
+  TODO: Accept partial application as FNREF.
+-->
+<function name="f:partial">
+  <param name="fnref" as="element(f:ref)" />
+  <param name="args"  as="item()*" />
+
+  <f:ref>
+    <sequence select="$fnref/@*" />
+
+    <attribute name="partial"
+               select="count( $args )" />
+
+    <sequence select="$fnref/*" />
+  </f:ref>
+
+  <!-- nested sequences are implicitly flattened, so we're not
+       returning a sub-sequence here -->
+  <sequence select="$args" />
+</function>
+
+
+<!--
+  Determines whether FNREF is a partial application
+
+  You really should not rely on this for your code—it is intended for
+  internal use.  Instead, treat partial applications opaquely as their
+  own functions.
+-->
+<function name="f:is-partial" as="xs:boolean">
+  <param name="fnref" as="item()+" />
+
+  <!-- if we're passed a sequence, then the function portion of the
+       reference is first; all others are arguments -->
+  <variable name="fn"
+            select="$fnref[ 1 ]" />
+
+  <!-- we never want to fail, so we perform our type check here rather
+       than using param/@as -->
+  <sequence select="$fn instance of element(f:ref)
+                    and exists( $fn/@partial )
+                    and number( $fn/@partial ) gt 0" />
+</function>
+
+</stylesheet>
diff --git a/test/apply/partial-test.xsl b/test/apply/partial-test.xsl
new file mode 100644
index 0000000..0695395
--- /dev/null
+++ b/test/apply/partial-test.xsl
@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Tests partial function application
+
+  Copyright (C) 2014 LoVullo Associates, Inc.
+
+    This file is part of hoxsl.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<stylesheet version="2.0"
+  xmlns="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:f="http://www.lovullo.com/hoxsl/apply"
+  xmlns:foo="http://www.lovullo.com/_junk">
+
+  <!-- SUT -->
+  <import href="../../src/apply/partial.xsl" />
+
+  <!-- generated -->
+  <import href="partial-test.xsl.apply" />
+
+
+  <function name="foo:ternary">
+    <param name="x" />
+    <param name="y" />
+    <param name="z" />
+
+    <sequence select="$x, $y, $z" />
+  </function>
+</stylesheet>
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
new file mode 100644
index 0000000..8f0df53
--- /dev/null
+++ b/test/apply/partial.xspec
@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Tests partial function application
+
+  Copyright (C) 2014 LoVullo Associates, Inc.
+
+    This file is part of hoxsl.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<description xmlns="http://www.jenitennison.com/xslt/xspec"
+             xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+             xmlns:x="http://www.jenitennison.com/xslt/xspec"
+             xmlns:f="http://www.lovullo.com/hoxsl/apply"
+             xmlns:foo="http://www.lovullo.com/_junk"
+             stylesheet="partial-test.xsl">
+
+  <scenario label="f:partial">
+    <variable name="fnref"
+              select="foo:ternary()" />
+
+    <variable name="args">
+      <foo:parent>
+        <foo:a />
+        <foo:b />
+        <foo:c />
+      </foo:parent>
+    </variable>
+
+
+    <scenario label="given an empty argument list">
+      <call function="f:partial">
+        <param name="fnref" select="$fnref" />
+        <param name="args"  select="()" />
+      </call>
+
+      <expect label="returns FNREF"
+              test="$x:result[ 1 ] = $fnref" />
+
+      <expect label="indicates that 0 arguments were partially applied"
+              test="$x:result/@partial = 0" />
+
+      <expect label="returns nothing else"
+              test="count( $x:result ) = 1" />
+    </scenario>
+
+
+    <scenario label="given arguments fewer than function param count">
+      <call function="f:partial">
+        <param name="fnref" select="$fnref" />
+        <param name="args"  select="$args/foo:a, $args/foo:b" />
+      </call>
+
+      <expect label="returns FNREF as first item in sequence"
+              test="$x:result[ 1 ] = $fnref" />
+
+      <expect label="indicates that N arguments were partially applied"
+              test="$x:result/@partial = 2" />
+
+      <expect label="returns each argument, ordered"
+              test="$x:result[ 2 ] = $args/foo:a
+                    and exists(
+                      $x:result[ 2 ]/parent::foo:parent )
+                    and $x:result[ 3 ] = $args/foo:b
+                    and exists(
+                      $x:result[ 3 ]/parent::foo:parent )" />
+    </scenario>
+
+
+    <scenario label="given arguments for all function params">
+      <call function="f:partial">
+        <param name="fnref" select="$fnref" />
+        <param name="args"  select="1, 2, 3" />
+      </call>
+
+      <expect label="returns FNREF as first item in sequence"
+              test="$x:result[ 1 ] = $fnref" />
+
+      <!-- we checked previously for argument values; we assume here
+           that it is working in this case...hopefully that is not
+           wrong! -->
+      <expect label="returns all arguments"
+              test="count( $x:result ) = 4" />
+    </scenario>
+  </scenario>
+
+
+  <scenario label="f:is-partial">
+    <scenario label="given a non-none">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="5" />
+      </call>
+
+      <expect label="returns false()"
+              test="$x:result = false()" />
+    </scenario>
+
+
+    <scenario label="given a non-fref node">
+      <call function="f:is-partial">
+        <param name="fnref">
+          <foo:moo />
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              test="$x:result = false()" />
+    </scenario>
+
+
+    <!-- this leaks implementation details :x -->
+    <scenario label="given a non-fref node with spoofed attribute">
+      <call function="f:is-partial">
+        <param name="fnref">
+          <foo:moo partial="5" f:partial="5" />
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              test="$x:result = false()" />
+    </scenario>
+
+
+    <scenario label="given a valid fref, not partially applied">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="foo:ternary()" />
+      </call>
+
+      <expect label="returns false()"
+              test="$x:result = false()" />
+    </scenario>
+
+
+    <!-- if partially applied with no arguments, then it may as well
+         not be; let's not alter the logic of callers just because it
+         was called with no effect -->
+    <scenario label="given a valid fref, partially applied with zero
+                     arguments">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="f:partial( foo:ternary(), () )" />
+      </call>
+
+      <expect label="returns false()"
+              test="$x:result = false()" />
+    </scenario>
+
+
+    <scenario label="given a valid fref, partially applied with N>0
+                     arguments, including argument sequence">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="f:partial( foo:ternary(), (1, 2) )" />
+      </call>
+
+      <expect label="returns true()"
+              test="$x:result = true()" />
+    </scenario>
+
+
+    <!-- caller may extract the function ref from the sequence and
+         assert on that -->
+    <scenario label="given a valid fref, partially applied with N>0
+                     arguments, without argument sequence">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="f:partial( foo:ternary(), (1, 2) )[ 1 ]" />
+      </call>
+
+      <expect label="returns true()"
+              test="$x:result = true()" />
+    </scenario>
+
+
+    <!-- we still want to consider all arguments to be a partial
+         application (consider it as producing a nullary
+         function)—otherwise, the abstraction is broken -->
+    <scenario label="given arguments for each parameter">
+      <call function="f:is-partial">
+        <param name="fnref"
+               select="f:partial( foo:ternary(), (1, 2, 3) )" />
+      </call>
+
+      <expect label="returns true()"
+              test="$x:result = true()" />
+    </scenario>
+  </scenario>
+</description>
diff --git a/test/transform/apply-gen.xspec b/test/transform/apply-gen.xspec
index df9dae9..51de570 100644
--- a/test/transform/apply-gen.xspec
+++ b/test/transform/apply-gen.xspec
@@ -73,7 +73,7 @@
           <xsl:function name="foo:bar">
             <xsl:param name="a" />
             <xsl:param name="b" as="xs:decimal" />
-            <xsl:param name="c" />"
+            <xsl:param name="c" />
           </xsl:function>
         </xsl:stylesheet>
       </context>
@@ -187,7 +187,7 @@
     <scenario label="f:arity">
       <call function="f:arity">
         <param name="fnref" select="foo:sub-two()" />
-      </call>"
+      </call>
 
       <expect label="is able to determine arity"
               test="$x:result = 2" />

From a02865d8b14636a57e7678d4c883e8b5334c8844 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Mon, 24 Nov 2014 15:41:32 -0500
Subject: [PATCH 02/12] May now partially apply partial applications

---
 src/apply/partial.xsl    | 20 ++++++++++++++++----
 test/apply/partial.xspec | 21 +++++++++++++++++++++
 tools/xspec              |  2 +-
 3 files changed, 38 insertions(+), 5 deletions(-)

diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index 14ad561..ae59d9b 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -39,21 +39,33 @@
   the dynamic function calls will handle currying/partial application
   for you, which has a much more inviting syntax.
 
-  TODO: Accept partial application as FNREF.
+  Partially applied functions may continue to be partially applied
+  until their parameters are exhausted.  This can be used to implement
+  currying.
 -->
 <function name="f:partial">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="args"  as="item()*" />
 
+  <!-- perform type check here, not above, since we can be passed a
+       sequence (e.g.a  partially applied function) -->
+  <variable name="ref"
+            as="element(f:ref)"
+            select="$fnref[ 1 ]" />
+
   <f:ref>
-    <sequence select="$fnref/@*" />
+    <sequence select="$ref/@*" />
 
     <attribute name="partial"
                select="count( $args )" />
 
-    <sequence select="$fnref/*" />
+    <sequence select="$ref/*" />
   </f:ref>
 
+  <!-- include any previously applied arguments (if we're partially
+       applying a partial application) -->
+  <sequence select="remove( $fnref, 1 )" />
+
   <!-- nested sequences are implicitly flattened, so we're not
        returning a sub-sequence here -->
   <sequence select="$args" />
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
index 8f0df53..e6e8c1e 100644
--- a/test/apply/partial.xspec
+++ b/test/apply/partial.xspec
@@ -94,6 +94,27 @@
       <expect label="returns all arguments"
               test="count( $x:result ) = 4" />
     </scenario>
+
+
+    <!-- partial applications should behave as their own functions -->
+    <scenario label="partially applying partial application">
+      <call function="f:partial">
+        <param name="fnref" select="f:partial( $fnref, (1, 2) )" />
+        <param name="args"  select="3" />
+      </call>
+
+      <expect label="returns FNREF as first item in sequence"
+              test="$x:result[ 1 ] = $fnref" />
+
+      <expect label="returns arguments from both partial applications"
+              test="count( $x:result ) = 4" />
+
+      <expect label="arguments are ordered with previous applications
+                     first in sequence"
+              test="$x:result[ 2 ] = 1
+                    and $x:result[ 3 ] = 2
+                    and $x:result[ 4 ] = 3" />
+    </scenario>
   </scenario>
 
 
diff --git a/tools/xspec b/tools/xspec
index 3dc0ab2..20c6b8a 160000
--- a/tools/xspec
+++ b/tools/xspec
@@ -1 +1 @@
-Subproject commit 3dc0ab2e1b78dae5d31c228c22a7dd8868d5678f
+Subproject commit 20c6b8a32f37a6511698fe89b78b82fd1aa64bd2

From 04373b5eddf27eabd565f4a5cd1916826508cbec Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Tue, 25 Nov 2014 10:54:03 -0500
Subject: [PATCH 03/12] f:arity extracted into its own stylesheet

It depends on partial application logic, but does not belong in partial.xsl
---
 src/apply.xsl          | 18 ++---------
 src/apply/arity.xsl    | 48 +++++++++++++++++++++++++++++
 test/apply.xspec       | 39 ------------------------
 test/apply/arity.xspec | 68 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 118 insertions(+), 55 deletions(-)
 create mode 100644 src/apply/arity.xsl
 create mode 100644 test/apply/arity.xspec

diff --git a/src/apply.xsl b/src/apply.xsl
index d7fd6e3..5a2b704 100644
--- a/src/apply.xsl
+++ b/src/apply.xsl
@@ -30,6 +30,8 @@
   xmlns:xs="http://www.w3.org/2001/XMLSchema"
   xmlns:f="http://www.lovullo.com/hoxsl/apply">
 
+<import href="apply/arity.xsl" />
+
 
 <function name="f:apply">
   <param name="fnref" as="element(f:ref)" />
@@ -193,20 +195,4 @@
   </message>
 </template>
 
-
-<!--
-  Attempt to retrieve arity of delayed function
-
-  The input must be a function reference.  If the arity cannot be
-  determined, -1 is returned.
--->
-<function name="f:arity" as="xs:decimal">
-  <param name="fnref" as="element(f:ref)" />
-
-  <sequence select="if ( $fnref/@arity ) then
-                      $fnref/@arity
-                    else
-                      -1" />
-</function>
-
 </stylesheet>
diff --git a/src/apply/arity.xsl b/src/apply/arity.xsl
new file mode 100644
index 0000000..5e9de23
--- /dev/null
+++ b/src/apply/arity.xsl
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Arity calculations on dynamic and partially applied functions
+
+  Copyright (C) 2014 LoVullo Associates, Inc.
+
+    This file is part of hoxsl.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<stylesheet version="2.0"
+  xmlns="http://www.w3.org/1999/XSL/Transform"
+  xmlns:xs="http://www.w3.org/2001/XMLSchema"
+  xmlns:f="http://www.lovullo.com/hoxsl/apply">
+
+
+
+<!--
+  Attempt to retrieve arity of dynamic function
+
+  The input must be a function reference.  Partially applied function
+  references will have an arity equivalent to the remaining parameters
+  in the original function.
+
+  If the arity cannot be determined, -1 is returned.
+-->
+<function name="f:arity" as="xs:decimal">
+  <param name="fnref" as="element(f:ref)" />
+
+  <sequence select="if ( $fnref/@arity ) then
+                      $fnref/@arity
+                    else
+                      -1" />
+</function>
+
+</stylesheet>
diff --git a/test/apply.xspec b/test/apply.xspec
index 8608775..90e644b 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -192,43 +192,4 @@
       </scenario>
     </scenario>
   </scenario>
-
-
-  <scenario label="f:arity">
-    <scenario label="given a proper function reference">
-      <variable name="test-arity"
-                select="5" />
-
-      <!-- test our format directly; do not rely on the
-           apply-gen code -->
-      <variable name="fnref">
-        <f:ref arity="{$test-arity}">
-          <foo:bar />
-        </f:ref>
-      </variable>
-
-      <call function="f:arity">
-        <param name="fnref"
-               select="$fnref" />
-      </call>
-
-      <expect label="provides function arity"
-              test="$x:result = $test-arity" />
-    </scenario>
-
-
-    <scenario label="given a function reference with no defined arity">
-      <variable name="fnref">
-        <f:ref><foo:bar /></f:ref>
-      </variable>
-
-      <call function="f:arity">
-        <param name="fnref"
-               select="$fnref" />
-      </call>
-
-      <expect label="returns -1"
-              test="$x:result = -1" />
-    </scenario>
-  </scenario>
 </description>
diff --git a/test/apply/arity.xspec b/test/apply/arity.xspec
new file mode 100644
index 0000000..bb94b01
--- /dev/null
+++ b/test/apply/arity.xspec
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Tests arity calculations
+
+  Copyright (C) 2014 LoVullo Associates, Inc.
+
+    This file is part of hoxsl.
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+-->
+
+<description xmlns="http://www.jenitennison.com/xslt/xspec"
+             xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+             xmlns:x="http://www.jenitennison.com/xslt/xspec"
+             xmlns:f="http://www.lovullo.com/hoxsl/apply"
+             xmlns:foo="http://www.lovullo.com/_junk"
+             stylesheet="../../src/apply/arity.xsl">
+
+
+  <scenario label="f:arity">
+    <scenario label="given a proper function reference">
+      <variable name="test-arity"
+                select="5" />
+
+      <!-- test our format directly; do not rely on the
+           apply-gen code -->
+      <variable name="fnref">
+        <f:ref arity="{$test-arity}">
+          <foo:bar />
+        </f:ref>
+      </variable>
+
+      <call function="f:arity">
+        <param name="fnref"
+               select="$fnref" />
+      </call>
+
+      <expect label="provides function arity"
+              test="$x:result = $test-arity" />
+    </scenario>
+
+
+    <scenario label="given a function reference with no defined arity">
+      <variable name="fnref">
+        <f:ref><foo:bar /></f:ref>
+      </variable>
+
+      <call function="f:arity">
+        <param name="fnref"
+               select="$fnref" />
+      </call>
+
+      <expect label="returns -1"
+              test="$x:result = -1" />
+    </scenario>
+  </scenario>
+</description>

From 0dc019c9edec29f752f7d63b0db357baa6ab662e Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Tue, 25 Nov 2014 15:02:36 -0500
Subject: [PATCH 04/12] Error and hook for arity count in partial application

---
 src/apply/partial.xsl       | 89 +++++++++++++++++++++++++++++++------
 test/apply/partial-test.xsl | 15 +++++++
 test/apply/partial.xspec    | 81 ++++++++++++++++++++++++++-------
 3 files changed, 155 insertions(+), 30 deletions(-)

diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index ae59d9b..e94d904 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -28,6 +28,8 @@
   xmlns:xs="http://www.w3.org/2001/XMLSchema"
   xmlns:f="http://www.lovullo.com/hoxsl/apply">
 
+<import href="arity.xsl" />
+
 
 <!--
   Partially apply dynamic function reference FNREF
@@ -43,7 +45,7 @@
   until their parameters are exhausted.  This can be used to implement
   currying.
 -->
-<function name="f:partial">
+<function name="f:partial" as="item()+">
   <param name="fnref" as="item()+" />
   <param name="args"  as="item()*" />
 
@@ -53,22 +55,45 @@
             as="element(f:ref)"
             select="$fnref[ 1 ]" />
 
-  <f:ref>
-    <sequence select="$ref/@*" />
+  <variable name="argout" as="item()*">
+    <!-- include any previously applied arguments (if we're partially
+         applying a partial application) -->
+    <sequence select="remove( $fnref, 1 )" />
 
-    <attribute name="partial"
-               select="count( $args )" />
+    <!-- nested sequences are implicitly flattened, so we're not
+         returning a sub-sequence here -->
+    <sequence select="$args" />
+  </variable>
 
-    <sequence select="$ref/*" />
-  </f:ref>
+  <variable name="argn" as="xs:decimal"
+            select="count( $argout )" />
 
-  <!-- include any previously applied arguments (if we're partially
-       applying a partial application) -->
-  <sequence select="remove( $fnref, 1 )" />
+  <variable name="arity" as="xs:decimal"
+            select="f:arity( $ref )" />
 
-  <!-- nested sequences are implicitly flattened, so we're not
-       returning a sub-sequence here -->
-  <sequence select="$args" />
+  <choose>
+    <when test="$argn gt $arity">
+      <apply-templates mode="f:partial-arity-error-hook"
+                       select="$ref">
+        <with-param name="args"  select="$argout" />
+        <with-param name="arity" select="$arity" />
+        <with-param name="argn"  select="$argn" />
+      </apply-templates>
+    </when>
+
+    <otherwise>
+      <f:ref>
+        <sequence select="$ref/@*" />
+
+        <attribute name="partial"
+                   select="count( $args )" />
+
+        <sequence select="$ref/*" />
+      </f:ref>
+
+      <sequence select="$argout" />
+    </otherwise>
+  </choose>
 </function>
 
 
@@ -94,4 +119,42 @@
                     and number( $fn/@partial ) gt 0" />
 </function>
 
+
+<!--
+  Hook invoked when the number of arguments of a partial application
+  exceeds the parameter count of the target function
+
+  The `target' function is the root of the partial application—given
+  @t{Fx @arrow{} F'y @arrow{} F''z}, @t{F} is the target.
+
+  Implementations may override this hook to display their own errors,
+  or even handle the error and continue by returning a proper partial
+  application.  For such implementation details, see
+  @file{apply/partial.xsl}.
+-->
+<template mode="f:partial-arity-error-hook"
+          match="f:ref"
+          priority="1">
+  <param name="args"  as="item()*" />
+  <param name="arity" as="xs:decimal" />
+
+  <variable name="ref" as="element(f:ref)"
+            select="." />
+  <variable name="argn" as="xs:decimal"
+            select="count( $args )" />
+  <variable name="fn"
+            select="$ref/*[1]" />
+  <variable name="fname"
+            select="concat( '{', namespace-uri( $fn ), '}',
+                    $fn/local-name() )" />
+
+  <sequence
+      select="error(
+                QName( namespace-uri-for-prefix( 'f', $ref ),
+                       'err:PARTIAL_PARAM_OVERFLOW' ),
+                concat( 'Attempted partial application of ',
+                        $fname, '#', $arity, ' with ',
+                        $argn, ' arguments' ) )" />
+</template>
+
 </stylesheet>
diff --git a/test/apply/partial-test.xsl b/test/apply/partial-test.xsl
index 0695395..144d76b 100644
--- a/test/apply/partial-test.xsl
+++ b/test/apply/partial-test.xsl
@@ -33,6 +33,21 @@
   <import href="partial-test.xsl.apply" />
 
 
+  <!-- the default implementation is to raise an error, which can't be
+       tested without XSLT 3.0 support -->
+  <template mode="f:partial-arity-error-hook"
+            match="f:ref"
+            priority="5">
+    <param name="args" as="item()*" />
+    <param name="arity" as="xs:decimal" />
+
+    <foo:partial-error arity="{$arity}" />
+
+    <sequence select="." />
+    <sequence select="$args" />
+  </template>
+
+
   <function name="foo:ternary">
     <param name="x" />
     <param name="y" />
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
index e6e8c1e..902cc2c 100644
--- a/test/apply/partial.xspec
+++ b/test/apply/partial.xspec
@@ -27,19 +27,20 @@
              xmlns:foo="http://www.lovullo.com/_junk"
              stylesheet="partial-test.xsl">
 
-  <scenario label="f:partial">
-    <variable name="fnref"
-              select="foo:ternary()" />
+  <variable name="fnref"
+            select="foo:ternary()" />
 
-    <variable name="args">
-      <foo:parent>
-        <foo:a />
-        <foo:b />
-        <foo:c />
-      </foo:parent>
-    </variable>
+  <variable name="args">
+    <foo:parent>
+      <foo:a />
+      <foo:b />
+      <foo:c />
+      <foo:d />
+    </foo:parent>
+  </variable>
 
 
+  <scenario label="f:partial constructor">
     <scenario label="given an empty argument list">
       <call function="f:partial">
         <param name="fnref" select="$fnref" />
@@ -70,12 +71,8 @@
               test="$x:result/@partial = 2" />
 
       <expect label="returns each argument, ordered"
-              test="$x:result[ 2 ] = $args/foo:a
-                    and exists(
-                      $x:result[ 2 ]/parent::foo:parent )
-                    and $x:result[ 3 ] = $args/foo:b
-                    and exists(
-                      $x:result[ 3 ]/parent::foo:parent )" />
+              test="$x:result[ 2 ] is $args/foo:a
+                    and $x:result[ 3 ] is $args/foo:b" />
     </scenario>
 
 
@@ -118,7 +115,7 @@
   </scenario>
 
 
-  <scenario label="f:is-partial">
+  <scenario label="f:is-partial predicate">
     <scenario label="given a non-none">
       <call function="f:is-partial">
         <param name="fnref"
@@ -220,4 +217,54 @@
               test="$x:result = true()" />
     </scenario>
   </scenario>
+
+
+  <scenario label="f:partial-arity-error-hook mode">
+    <scenario label="given more arguments than target function
+                     parameters">
+      <!-- see partial-test.xsl for the result sequence order -->
+      <call function="f:partial">
+        <param name="fnref" select="$fnref" />
+        <param name="args"  select="$args/foo:a,
+                                    $args/foo:b,
+                                    $args/foo:c,
+                                    $args/foo:d" />
+      </call>
+
+      <expect label="produces an error"
+              test="$x:result[ 1 ] instance of
+                      element( foo:partial-error )" />
+
+      <expect label="provides source dynamic function reference"
+              test="$x:result[ 2 ] is $fnref" />
+
+      <expect label="provides arity of target (root of all partial
+                     applications) function"
+              test="$x:result[ 1 ]/@arity = 3" />
+
+      <expect label="provides each argument of partial application
+                     attempt, including excess"
+              test="$x:result[ 3 ] is $args/foo:a
+                    and $x:result[ 4 ] is $args/foo:b
+                    and $x:result[ 5 ] is $args/foo:c
+                    and $x:result[ 6 ] is $args/foo:d" />
+    </scenario>
+
+
+    <scenario label="triggered when sum of partial applications yields
+                     more arguments than target parameters">
+      <call function="f:partial">
+        <param name="fnref"
+               select="f:partial( $fnref, ($args/foo:a,
+                                           $args/foo:b) )" />
+        <param name="args"  select="$args/foo:c,
+                                    $args/foo:d" />
+      </call>
+
+      <expect label="produces error with all arguments"
+              test="exists( foo:partial-error )
+                    and $x:result[ 3 ] is $args/foo:a
+                    and $x:result[ 6 ] is $args/foo:d" />
+    </scenario>
+  </scenario>
 </description>

From 465ef7e8a5c4017861dcdfcb2e6908d50399b435 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 11:16:24 -0500
Subject: [PATCH 05/12] Apply test case ensures arguments are passed by
 reference

Confidence in its application is also increased through a unique node.
---
 test/apply-test.xsl |  34 +++++----
 test/apply.xspec    | 164 ++++++++++++++++++++++++++------------------
 2 files changed, 118 insertions(+), 80 deletions(-)

diff --git a/test/apply-test.xsl b/test/apply-test.xsl
index 66cece9..5327deb 100644
--- a/test/apply-test.xsl
+++ b/test/apply-test.xsl
@@ -30,14 +30,15 @@
 
   <template mode="f:apply" match="f:ref[ foo:fn0 ]">
     <!-- return something to show that we were called properly -->
-    <sequence select="0" />
+    <foo:applied n="0" />
   </template>
 
 
   <template mode="f:apply" match="f:ref[ foo:fn1 ]">
     <param name="arg1" />
 
-    <sequence select="string($arg1)" />
+    <foo:applied n="1" />
+    <sequence select="$arg1" />
   </template>
 
 
@@ -45,7 +46,8 @@
     <param name="arg1" />
     <param name="arg2" />
 
-    <sequence select="concat($arg1, $arg2)" />
+    <foo:applied n="2" />
+    <sequence select="$arg1, $arg2" />
   </template>
 
 
@@ -54,7 +56,8 @@
     <param name="arg2" />
     <param name="arg3" />
 
-    <sequence select="concat($arg1, $arg2, $arg3)" />
+    <foo:applied n="3" />
+    <sequence select="$arg1, $arg2, $arg3" />
   </template>
 
 
@@ -64,7 +67,8 @@
     <param name="arg3" />
     <param name="arg4" />
 
-    <sequence select="concat($arg1, $arg2, $arg3, $arg4)" />
+    <foo:applied n="4" />
+    <sequence select="$arg1, $arg2, $arg3, $arg4" />
   </template>
 
 
@@ -75,8 +79,9 @@
     <param name="arg4" />
     <param name="arg5" />
 
-    <sequence select="concat($arg1, $arg2, $arg3, $arg4,
-                        $arg5)" />
+    <foo:applied n="5" />
+    <sequence select="$arg1, $arg2, $arg3, $arg4,
+                        $arg5" />
   </template>
 
 
@@ -88,8 +93,9 @@
     <param name="arg5" />
     <param name="arg6" />
 
-    <sequence select="concat($arg1, $arg2, $arg3, $arg4,
-                        $arg5, $arg6)" />
+    <foo:applied n="6" />
+    <sequence select="$arg1, $arg2, $arg3, $arg4,
+                        $arg5, $arg6" />
   </template>
 
 
@@ -102,8 +108,9 @@
     <param name="arg6" />
     <param name="arg7" />
 
-    <sequence select="concat($arg1, $arg2, $arg3, $arg4,
-                        $arg5, $arg6, $arg7)" />
+    <foo:applied n="7" />
+    <sequence select="$arg1, $arg2, $arg3, $arg4,
+                        $arg5, $arg6, $arg7" />
   </template>
 
 
@@ -117,7 +124,8 @@
     <param name="arg7" />
     <param name="arg8" />
 
-    <sequence select="concat($arg1, $arg2, $arg3, $arg4,
-                        $arg5, $arg6, $arg7, $arg8)" />
+    <foo:applied n="8" />
+    <sequence select="$arg1, $arg2, $arg3, $arg4,
+                        $arg5, $arg6, $arg7, $arg8" />
   </template>
 </stylesheet>
diff --git a/test/apply.xspec b/test/apply.xspec
index 90e644b..285268b 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -26,28 +26,21 @@
              xmlns:foo="http://www.lovullo.com/_junk"
              stylesheet="apply-test.xsl">
 
+  <variable name="args">
+    <foo:args>
+      <foo:arg1 />
+      <foo:arg2 />
+      <foo:arg3 />
+      <foo:arg4 />
+      <foo:arg5 />
+      <foo:arg6 />
+      <foo:arg7 />
+      <foo:arg8 />
+    </foo:args>
+  </variable>
+
   <scenario label="f:apply">
-    <scenario label="applied to a function reference element">
-      <variable name="arg"
-                select="'foo'" />
-
-      <call function="f:apply">
-        <param name="fnref">
-          <f:ref>
-            <foo:fn1 />
-          </f:ref>
-        </param>
-        <param name="arg1" select="$arg" />
-      </call>
-
-      <!-- our test appliaction template simply echoes back its only
-           argument -->
-      <expect label="applies application template with mode f:apply"
-              test="$x:result = ($arg)" />
-    </scenario>
-
-
-    <scenario label="applying">
+    <scenario label="applied to complete argument list of">
       <scenario label="nullary function">
         <call function="f:apply">
           <param name="fnref">
@@ -55,8 +48,9 @@
           </param>
         </call>
 
-        <expect label="passes each argument"
-                test="$x:result = 0" />
+        <!-- technically it applies a template -->
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 0 ]" />"
       </scenario>
 
 
@@ -65,11 +59,12 @@
           <param name="fnref">
             <f:ref><foo:fn1 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
+          <param name="arg1" select="$args/foo:arg1" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '1'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 1 ]
+                      and $x:result[ 2 ] is $args/foo:arg1" />
       </scenario>
 
 
@@ -78,12 +73,14 @@
           <param name="fnref">
             <f:ref><foo:fn2 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '12'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 2 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2" />
       </scenario>
 
 
@@ -92,13 +89,16 @@
           <param name="fnref">
             <f:ref><foo:fn3 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '123'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 3 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3" />
       </scenario>
 
 
@@ -107,14 +107,18 @@
           <param name="fnref">
             <f:ref><foo:fn4 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
-          <param name="arg4" select="4" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
+          <param name="arg4" select="$args/foo:arg4" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '1234'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 4 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4" />
       </scenario>
 
 
@@ -123,15 +127,20 @@
           <param name="fnref">
             <f:ref><foo:fn5 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
-          <param name="arg4" select="4" />
-          <param name="arg5" select="5" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
+          <param name="arg4" select="$args/foo:arg4" />
+          <param name="arg5" select="$args/foo:arg5" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '12345'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 5 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4
+                      and $x:result[ 6 ] is $args/foo:arg5" />
       </scenario>
 
 
@@ -140,16 +149,22 @@
           <param name="fnref">
             <f:ref><foo:fn6 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
-          <param name="arg4" select="4" />
-          <param name="arg5" select="5" />
-          <param name="arg6" select="6" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
+          <param name="arg4" select="$args/foo:arg4" />
+          <param name="arg5" select="$args/foo:arg5" />
+          <param name="arg6" select="$args/foo:arg6" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '123456'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 6 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4
+                      and $x:result[ 6 ] is $args/foo:arg5
+                      and $x:result[ 7 ] is $args/foo:arg6" />
       </scenario>
 
 
@@ -158,17 +173,24 @@
           <param name="fnref">
             <f:ref><foo:fn7 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
-          <param name="arg4" select="4" />
-          <param name="arg5" select="5" />
-          <param name="arg6" select="6" />
-          <param name="arg7" select="7" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
+          <param name="arg4" select="$args/foo:arg4" />
+          <param name="arg5" select="$args/foo:arg5" />
+          <param name="arg6" select="$args/foo:arg6" />
+          <param name="arg7" select="$args/foo:arg7" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '1234567'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 7 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4
+                      and $x:result[ 6 ] is $args/foo:arg5
+                      and $x:result[ 7 ] is $args/foo:arg6
+                      and $x:result[ 8 ] is $args/foo:arg7" />
       </scenario>
 
 
@@ -177,18 +199,26 @@
           <param name="fnref">
             <f:ref><foo:fn8 /></f:ref>
           </param>
-          <param name="arg1" select="1" />
-          <param name="arg2" select="2" />
-          <param name="arg3" select="3" />
-          <param name="arg4" select="4" />
-          <param name="arg5" select="5" />
-          <param name="arg6" select="6" />
-          <param name="arg7" select="7" />
-          <param name="arg8" select="8" />
+          <param name="arg1" select="$args/foo:arg1" />
+          <param name="arg2" select="$args/foo:arg2" />
+          <param name="arg3" select="$args/foo:arg3" />
+          <param name="arg4" select="$args/foo:arg4" />
+          <param name="arg5" select="$args/foo:arg5" />
+          <param name="arg6" select="$args/foo:arg6" />
+          <param name="arg7" select="$args/foo:arg7" />
+          <param name="arg8" select="$args/foo:arg8" />
         </call>
 
         <expect label="passes each argument"
-                test="$x:result = '12345678'" />
+                test="$x:result[ 1 ] = foo:applied[ @n = 8 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4
+                      and $x:result[ 6 ] is $args/foo:arg5
+                      and $x:result[ 7 ] is $args/foo:arg6
+                      and $x:result[ 8 ] is $args/foo:arg7
+                      and $x:result[ 9 ] is $args/foo:arg8" />
       </scenario>
     </scenario>
   </scenario>

From b384e5fad1238a737078752fa9bac6cc327ea70a Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 23:43:56 -0500
Subject: [PATCH 06/12] Partial applications apply target function when all
 params are bound

I am aware of the Saxon 9 warning regarding multiple imports of arity.xsl;
I'm going to choose to ignore this, formally in the future.  Each of the
stylesheets is treated like a module.

Michael Kay, Saxon's author, discusses it here:

  http://stackoverflow.com/a/10102298
---
 src/apply/partial.xsl       |  50 ++++++-
 test/apply.xspec            |   2 +-
 test/apply/partial-test.xsl |   4 +
 test/apply/partial.xspec    | 259 ++++++++++++++++++++++++++++++++----
 4 files changed, 281 insertions(+), 34 deletions(-)

diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index e94d904..2208a95 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -26,16 +26,18 @@
 <stylesheet version="2.0"
   xmlns="http://www.w3.org/1999/XSL/Transform"
   xmlns:xs="http://www.w3.org/2001/XMLSchema"
-  xmlns:f="http://www.lovullo.com/hoxsl/apply">
+  xmlns:f="http://www.lovullo.com/hoxsl/apply"
+  xmlns:_f="http://www.lovullo.com/hoxsl/apply/_priv">
 
 <import href="arity.xsl" />
 
 
 <!--
-  Partially apply dynamic function reference FNREF
+  Partially apply dynamic function reference @var{fnref}
 
-  When provided to `f:apply', FNREF will be applied with ARGS as its
-  beginning argments, followed by any arguments to `f:apply'.
+  When provided to @code{f:apply}, @var{fnref} will be applied with
+  @var{args} as its beginning argments, followed by any arguments to
+  `f:apply'.
 
   Note that you usually do not have to invoke this function directly:
   the dynamic function calls will handle currying/partial application
@@ -44,6 +46,10 @@
   Partially applied functions may continue to be partially applied
   until their parameters are exhausted.  This can be used to implement
   currying.
+
+  When destructuring the result of this function, note that the
+  returned function reference may not match @var{fnref} by reference,
+  as it may have been modified.
 -->
 <function name="f:partial" as="item()+">
   <param name="fnref" as="item()+" />
@@ -72,6 +78,10 @@
             select="f:arity( $ref )" />
 
   <choose>
+    <when test="$argn eq $arity">
+      <sequence select="_f:apply-partial( $ref, $argout )" />
+    </when>
+
     <when test="$argn gt $arity">
       <apply-templates mode="f:partial-arity-error-hook"
                        select="$ref">
@@ -157,4 +167,36 @@
                         $argn, ' arguments' ) )" />
 </template>
 
+
+<!--
+  Apply a partial dynamic function application
+
+  This function is called automatically by @code{f:partial} when
+  partial application would otherwise result in the returning of a
+  nullary function.  @emph{It performs no validations} to ensure the
+  integrity of the data.}
+
+  Just as @code{f:apply}, please note that @emph{up to eight arguments
+  are supported}.  This should be enough.
+-->
+<function name="_f:apply-partial">
+  <param name="fnref" as="element(f:ref)" />
+  <param name="args"  as="item()*" />
+
+  <variable name="fn" as="element()"
+            select="$fnref[ 1 ]" />
+
+  <!-- just as `f:apply', we support up to 8 arguments -->
+  <apply-templates select="$fn" mode="f:apply">
+    <with-param name="arg1" select="$args[ 1 ]" />
+    <with-param name="arg2" select="$args[ 2 ]" />
+    <with-param name="arg3" select="$args[ 3 ]" />
+    <with-param name="arg4" select="$args[ 4 ]" />
+    <with-param name="arg5" select="$args[ 5 ]" />
+    <with-param name="arg6" select="$args[ 6 ]" />
+    <with-param name="arg7" select="$args[ 7 ]" />
+    <with-param name="arg8" select="$args[ 8 ]" />
+  </apply-templates>
+</function>
+
 </stylesheet>
diff --git a/test/apply.xspec b/test/apply.xspec
index 285268b..4ccce28 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -50,7 +50,7 @@
 
         <!-- technically it applies a template -->
         <expect label="applies target function"
-                test="$x:result[ 1 ] = foo:applied[ @n = 0 ]" />"
+                test="$x:result[ 1 ] = foo:applied[ @n = 0 ]" />
       </scenario>
 
 
diff --git a/test/apply/partial-test.xsl b/test/apply/partial-test.xsl
index 144d76b..99dfadd 100644
--- a/test/apply/partial-test.xsl
+++ b/test/apply/partial-test.xsl
@@ -29,6 +29,9 @@
   <!-- SUT -->
   <import href="../../src/apply/partial.xsl" />
 
+  <!-- numerous templates for arity tests -->
+  <import href="../apply-test.xsl" />
+
   <!-- generated -->
   <import href="partial-test.xsl.apply" />
 
@@ -53,6 +56,7 @@
     <param name="y" />
     <param name="z" />
 
+    <foo:ternary-applied />
     <sequence select="$x, $y, $z" />
   </function>
 </stylesheet>
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
index 902cc2c..eda5a53 100644
--- a/test/apply/partial.xspec
+++ b/test/apply/partial.xspec
@@ -36,6 +36,10 @@
       <foo:b />
       <foo:c />
       <foo:d />
+      <foo:e />
+      <foo:f />
+      <foo:g />
+      <foo:h />
     </foo:parent>
   </variable>
 
@@ -76,41 +80,252 @@
     </scenario>
 
 
+    <!-- our implementation can be thought of like currying -->
     <scenario label="given arguments for all function params">
       <call function="f:partial">
         <param name="fnref" select="$fnref" />
-        <param name="args"  select="1, 2, 3" />
+        <param name="args"  select="$args/foo:a,
+                                    $args/foo:b,
+                                    $args/foo:c" />
       </call>
 
-      <expect label="returns FNREF as first item in sequence"
-              test="$x:result[ 1 ] = $fnref" />
+      <expect label="applies target function"
+              test="$x:result[ 1 ]
+                    and $x:result[ 1 ] = foo:ternary-applied" />
 
-      <!-- we checked previously for argument values; we assume here
-           that it is working in this case...hopefully that is not
-           wrong! -->
-      <expect label="returns all arguments"
-              test="count( $x:result ) = 4" />
+      <expect label="applies target function with arguments, by reference"
+              test="$x:result[ 2 ] is $args/foo:a
+                    and $x:result[ 3 ] is $args/foo:b
+                    and $x:result[ 4 ] is $args/foo:c" />
     </scenario>
 
 
     <!-- partial applications should behave as their own functions -->
-    <scenario label="partially applying partial application">
+    <scenario label="partially applying partial application, with
+                     fewer arguments than target function arity">
       <call function="f:partial">
-        <param name="fnref" select="f:partial( $fnref, (1, 2) )" />
-        <param name="args"  select="3" />
+        <param name="fnref" select="f:partial( $fnref, $args/foo:a )" />
+        <param name="args"  select="$args/foo:b" />
       </call>
 
       <expect label="returns FNREF as first item in sequence"
               test="$x:result[ 1 ] = $fnref" />
 
       <expect label="returns arguments from both partial applications"
-              test="count( $x:result ) = 4" />
+              test="count( $x:result ) = 3" />
 
       <expect label="arguments are ordered with previous applications
                      first in sequence"
-              test="$x:result[ 2 ] = 1
-                    and $x:result[ 3 ] = 2
-                    and $x:result[ 4 ] = 3" />
+              test="$x:result[ 2 ] is $args/foo:a
+                    and $x:result[ 3 ] is $args/foo:b" />
+    </scenario>
+
+
+    <scenario label="partially applying partial application, with all
+                     arguments">
+      <call function="f:partial">
+        <param name="fnref" select="f:partial( $fnref, ($args/foo:a,
+                                                        $args/foo:b) )" />
+        <param name="args"  select="$args/foo:c" />
+      </call>
+
+      <expect label="applies target function"
+              test="$x:result[ 1 ]
+                    and $x:result[ 1 ] = foo:ternary-applied" />
+
+      <expect label="applies target function with arguments, by reference"
+              test="$x:result[ 2 ] is $args/foo:a
+                    and $x:result[ 3 ] is $args/foo:b
+                    and $x:result[ 4 ] is $args/foo:c" />
+    </scenario>
+
+
+    <!-- let the repitition begin (don't we wish we had macros?
+         ...foreshadowing?) -->
+    <scenario label="completing partial application passes all
+                     arguments to a target">
+      <scenario label="unary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="1"><foo:fn1 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 1 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] is $args/foo:a" />
+      </scenario>
+
+
+      <scenario label="binary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="2"><foo:fn2 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 2 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] is $args/foo:a
+                      and $x:result[ 3 ] is $args/foo:b" />
+      </scenario>
+
+
+      <scenario label="ternary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="3"><foo:fn3 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 3 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] is $args/foo:a
+                      and $x:result[ 3 ] is $args/foo:b
+                      and $x:result[ 4 ] is $args/foo:c" />
+      </scenario>
+
+
+      <scenario label="4-ary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="4"><foo:fn4 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c,
+                                     $args/foo:d" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 4 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c
+                      and $x:result[ 5 ] = $args/foo:d" />
+      </scenario>
+
+
+      <scenario label="5-ary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="5"><foo:fn5 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c,
+                                     $args/foo:d,
+                                     $args/foo:e" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 5 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c
+                      and $x:result[ 5 ] = $args/foo:d
+                      and $x:result[ 6 ] = $args/foo:e" />
+      </scenario>
+
+
+      <scenario label="6-ary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="6"><foo:fn6 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c,
+                                     $args/foo:d,
+                                     $args/foo:e,
+                                     $args/foo:f" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 6 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c
+                      and $x:result[ 5 ] = $args/foo:d
+                      and $x:result[ 6 ] = $args/foo:e
+                      and $x:result[ 7 ] = $args/foo:f" />
+      </scenario>
+
+
+      <scenario label="7-ary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="7"><foo:fn7 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c,
+                                     $args/foo:d,
+                                     $args/foo:e,
+                                     $args/foo:f,
+                                     $args/foo:g" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 7 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c
+                      and $x:result[ 5 ] = $args/foo:d
+                      and $x:result[ 6 ] = $args/foo:e
+                      and $x:result[ 7 ] = $args/foo:f
+                      and $x:result[ 8 ] = $args/foo:g" />
+      </scenario>
+
+
+      <scenario label="8-ary">
+        <call function="f:partial">
+          <param name="fnref">
+            <f:ref arity="8"><foo:fn8 /></f:ref>
+          </param>
+          <param name="args" select="$args/foo:a,
+                                     $args/foo:b,
+                                     $args/foo:c,
+                                     $args/foo:d,
+                                     $args/foo:e,
+                                     $args/foo:f,
+                                     $args/foo:g,
+                                     $args/foo:h" />
+        </call>
+
+        <expect label="applies target function"
+                test="$x:result[ 1 ] = foo:applied[ @n = 8 ]" />
+
+        <expect label="applies target function with arguments, by reference"
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c
+                      and $x:result[ 5 ] = $args/foo:d
+                      and $x:result[ 6 ] = $args/foo:e
+                      and $x:result[ 7 ] = $args/foo:f
+                      and $x:result[ 8 ] = $args/foo:g
+                      and $x:result[ 9 ] = $args/foo:h" />
+      </scenario>
     </scenario>
   </scenario>
 
@@ -202,20 +417,6 @@
       <expect label="returns true()"
               test="$x:result = true()" />
     </scenario>
-
-
-    <!-- we still want to consider all arguments to be a partial
-         application (consider it as producing a nullary
-         function)—otherwise, the abstraction is broken -->
-    <scenario label="given arguments for each parameter">
-      <call function="f:is-partial">
-        <param name="fnref"
-               select="f:partial( foo:ternary(), (1, 2, 3) )" />
-      </call>
-
-      <expect label="returns true()"
-              test="$x:result = true()" />
-    </scenario>
   </scenario>
 
 

From 33788871a9bc9cc9a4464dd24da17ef93d2b7732 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 15:35:35 -0500
Subject: [PATCH 07/12] f:make-ref, f:is-ref, and f:QName added

---
 src/apply.xsl       |  76 ++++++++++++++++++++-
 test/apply-test.xsl |  44 +++++++++---
 test/apply.xspec    | 161 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 271 insertions(+), 10 deletions(-)

diff --git a/src/apply.xsl b/src/apply.xsl
index 5a2b704..f7130b5 100644
--- a/src/apply.xsl
+++ b/src/apply.xsl
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!--
   Dynamic function application
 
@@ -195,4 +195,78 @@
   </message>
 </template>
 
+
+<!--
+  Create a reference to dynamic function @var{name} with arity
+  @var{arity}
+
+  This function @emph{does not} verify that the function @var{name}
+  exists, nor does it verify that the provided @var{arity} is valid
+  for it.  Further, the returned function reference will work
+  @emph{only with dynamic functions}—that is, an application template
+  is needed.  See @file{transform/apply-gen.xsl} for more information
+  and examples.
+-->
+<function name="f:make-ref" as="element( f:ref )">
+  <param name="name"  as="xs:QName" />
+  <param name="arity" as="xs:integer" />
+
+  <variable name="ns"
+            select="namespace-uri-from-QName( $name )" />
+
+  <f:ref arity="{$arity}">
+    <element name="{$name}"
+             namespace="{$ns}" />
+  </f:ref>
+</function>
+
+
+<!--
+  Determines whether @var{fnref} represents a valid dynamic function
+  reference
+
+  This can be used to determine if @var{fnref} is valid as input to
+  other functions, some of which may produce an error if called with
+  an invalid dynamic function reference.
+
+  @i{Implementation details:} To be valid, @var{fnref} must:
+
+  @enumerate
+  @item Be an element of type @code{f:ref};
+  @item Have a numeric @code{@arity}; and
+  @item Have a child target function node.
+  @enumerate
+-->
+<function name="f:is-ref" as="xs:boolean">
+  <param name="fnref" as="item()*" />
+
+  <variable name="ref" select="$fnref[ 1 ]" />
+
+  <!-- for @arity check: note that NaN != NaN -->
+  <sequence select="$ref instance of element( f:ref )
+                    and number( $ref/@arity ) = number( $ref/@arity )
+                    and exists( $ref/*[ 1 ] )" />
+</function>
+
+
+<!--
+  Retrieve the QName of the target dynamic function
+
+  Usually, this would match precisely the QName of the target
+  function.
+
+  @i{Implementation details:} This actually represents the QName of
+  the @emph{application template}, which could differ from the target
+  function name.  One reason this may be the case is to provide a
+  function alias.
+-->
+<function name="f:QName" as="xs:QName?">
+  <param name="fnref" as="element( f:ref )" />
+
+  <variable name="target" as="element()?"
+            select="$fnref/element()[ 1 ]" />
+
+  <sequence select="node-name( $target )" />
+</function>
+
 </stylesheet>
diff --git a/test/apply-test.xsl b/test/apply-test.xsl
index 5327deb..010de9c 100644
--- a/test/apply-test.xsl
+++ b/test/apply-test.xsl
@@ -28,13 +28,25 @@
   <import href="../src/apply.xsl" />
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn0 ]">
+  <!-- catch errors (otherwise, we'd terminate) -->
+  <template mode="f:apply"
+            match="*"
+            priority="2">
+    <foo:unknown-dyn-fun />
+  </template>
+
+
+  <template mode="f:apply"
+            match="f:ref[ foo:fn0 ]"
+            priority="5">
     <!-- return something to show that we were called properly -->
     <foo:applied n="0" />
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn1 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn1 ]"
+            priority="5">
     <param name="arg1" />
 
     <foo:applied n="1" />
@@ -42,7 +54,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn2 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn2 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
 
@@ -51,7 +65,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn3 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn3 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
@@ -61,7 +77,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn4 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn4 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
@@ -72,7 +90,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn5 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn5 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
@@ -85,7 +105,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn6 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn6 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
@@ -99,7 +121,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn7 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn7 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
@@ -114,7 +138,9 @@
   </template>
 
 
-  <template mode="f:apply" match="f:ref[ foo:fn8 ]">
+  <template mode="f:apply"
+            match="f:ref[ foo:fn8 ]"
+            priority="5">
     <param name="arg1" />
     <param name="arg2" />
     <param name="arg3" />
diff --git a/test/apply.xspec b/test/apply.xspec
index 4ccce28..662c5d5 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -26,6 +26,9 @@
              xmlns:foo="http://www.lovullo.com/_junk"
              stylesheet="apply-test.xsl">
 
+  <variable name="foo-uri"
+            select="namespace-uri-for-prefix( 'foo', $args )" />
+
   <variable name="args">
     <foo:args>
       <foo:arg1 />
@@ -222,4 +225,162 @@
       </scenario>
     </scenario>
   </scenario>
+
+
+  <scenario label="f:make-ref constructor">
+    <scenario label="when called with a function QName and arity">
+      <variable name="qname"
+                select="QName( $foo-uri, 'reftest' )" />
+      <variable name="arity"
+                select="2" />
+
+      <call function="f:make-ref">
+        <param name="name"  select="$qname" />
+        <param name="arity" select="$arity" />
+      </call>
+
+      <expect label="produces a dynamic function reference"
+              test="f:is-ref( $x:result )" />
+
+      <expect label="produces provided reference arity"
+              test="f:arity( $x:result ) = $arity" />
+
+      <expect label="produces reference to expected QName"
+              test="f:QName( $x:result ) = $qname" />
+    </scenario>
+
+
+    <scenario label="produces a valid dynamic function reference">
+      <call function="f:apply">
+        <param name="fnref"
+               select="f:make-ref( QName( $foo-uri, 'fn1' ),
+                                   1 )" />
+        <param name="arg1"
+               select="$args/foo:arg1" />
+      </call>
+
+      <expect label="that can be applied using f:apply"
+              test="$x:result[ 1 ] = foo:applied[ @n = 1 ]
+                    and $x:result[ 2 ] is $args/foo:arg1" />
+    </scenario>
+  </scenario>
+
+
+  <scenario label="f:is-ref predicate">
+    <scenario label="given a valid dynamic function reference">
+      <call function="f:is-ref">
+        <param name="fnref"
+               select="f:make-ref( QName( $foo-uri, 'foo' ), 0 )" />
+      </call>
+
+      <expect label="returns true()"
+              select="true()" />
+    </scenario>
+
+
+    <scenario label="given an invalid dynamic function reference">
+      <call function="f:is-ref">
+        <param name="fnref">
+          <foo:bar />
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+
+
+    <scenario label="given a dynamic function reference without arity">
+      <call function="f:is-ref">
+        <param name="fnref">
+          <f:ref>
+            <foo:bar />
+          </f:ref>
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+
+
+    <scenario label="given a dynamic function reference without
+                     integral arity">
+      <call function="f:is-ref">
+        <param name="fnref">
+          <f:ref arity="moo">
+            <foo:bar />
+          </f:ref>
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+
+
+    <scenario label="given a dynamic function reference without target
+                     node">
+      <call function="f:is-ref">
+        <param name="fnref">
+          <f:ref arity="0" />
+        </param>
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+
+
+    <scenario label="given an empty sequence">
+      <call function="f:is-ref">
+        <param name="fnref" select="()" />
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+
+
+    <scenario label="given a non-element">
+      <call function="f:is-ref">
+        <param name="fnref" select="5" />
+      </call>
+
+      <expect label="returns false()"
+              select="false()" />
+    </scenario>
+  </scenario>
+
+
+  <scenario label="f:QName accessor">
+    <scenario label="given a valid dynamic function reference">
+      <variable name="foo-qname"
+                select="QName( $foo-uri, 'foo' )" />
+
+      <call function="f:QName">
+        <param name="fnref"
+               select="f:make-ref( $foo-qname, 0 )" />
+      </call>
+
+      <expect label="returns QName"
+              test="$x:result instance of xs:QName" />
+
+      <expect label="returns QName of target dynamic function"
+              select="$foo-qname" />
+    </scenario>
+
+
+    <scenario label="given a dynamic function reference with no target
+                     node">
+      <call function="f:QName">
+        <param name="fnref">
+          <f:ref arity="5" />
+        </param>
+      </call>
+
+      <expect label="returns empty sequence"
+              select="()" />
+    </scenario>
+  </scenario>
 </description>

From 425f050b03b7cc4e0edd6f362983909d4dfacf69 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 16:17:19 -0500
Subject: [PATCH 08/12] `f:apply' test case now using f:make-ref

That is, in place of manual construction.  This is especially important for
the next commit, which requires an arity datum.
---
 test/apply.xspec | 45 ++++++++++++++++++---------------------------
 1 file changed, 18 insertions(+), 27 deletions(-)

diff --git a/test/apply.xspec b/test/apply.xspec
index 662c5d5..920ca33 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -46,9 +46,8 @@
     <scenario label="applied to complete argument list of">
       <scenario label="nullary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn0 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn0' ), 0 )" />
         </call>
 
         <!-- technically it applies a template -->
@@ -59,9 +58,8 @@
 
       <scenario label="unary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn1 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn1' ), 1 )" />
           <param name="arg1" select="$args/foo:arg1" />
         </call>
 
@@ -73,9 +71,8 @@
 
       <scenario label="binary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn2 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn2' ), 2 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
         </call>
@@ -89,9 +86,8 @@
 
       <scenario label="ternary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn3 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn3' ), 3 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />
@@ -107,9 +103,8 @@
 
       <scenario label="4-ary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn4 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn4' ), 4 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />
@@ -127,9 +122,8 @@
 
       <scenario label="5-ary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn5 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn5' ), 5 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />
@@ -149,9 +143,8 @@
 
       <scenario label="6-ary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn6 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn6' ), 6 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />
@@ -173,9 +166,8 @@
 
       <scenario label="7-ary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn7 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn7' ), 7 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />
@@ -199,9 +191,8 @@
 
       <scenario label="8-ary function">
         <call function="f:apply">
-          <param name="fnref">
-            <f:ref><foo:fn8 /></f:ref>
-          </param>
+          <param name="fnref"
+                 select="f:make-ref( QName( $foo-uri, 'fn8' ), 8 )" />
           <param name="arg1" select="$args/foo:arg1" />
           <param name="arg2" select="$args/foo:arg2" />
           <param name="arg3" select="$args/foo:arg3" />

From 63487afa6786962e40e03743185a245684b82777 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 16:28:29 -0500
Subject: [PATCH 09/12] `f:apply' currying support

Partial application support on all the other `f:apply' functions (other
arities) will be completed in the next commit.
---
 src/apply.xsl    | 13 +++++++------
 test/apply.xspec | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 6 deletions(-)

diff --git a/src/apply.xsl b/src/apply.xsl
index f7130b5..d96db5f 100644
--- a/src/apply.xsl
+++ b/src/apply.xsl
@@ -30,7 +30,7 @@
   xmlns:xs="http://www.w3.org/2001/XMLSchema"
   xmlns:f="http://www.lovullo.com/hoxsl/apply">
 
-<import href="apply/arity.xsl" />
+<import href="apply/partial.xsl" />
 
 
 <function name="f:apply">
@@ -40,18 +40,19 @@
 </function>
 
 
+<!-- WARNING: inconsistent state: only `f:apply#{1,2}' support partial
+     application at the moment -->
+
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref, $arg1 )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
 
diff --git a/test/apply.xspec b/test/apply.xspec
index 920ca33..9262024 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -215,6 +215,54 @@
                       and $x:result[ 9 ] is $args/foo:arg8" />
       </scenario>
     </scenario>
+
+
+    <scenario label="applied to partial argument list">
+      <!-- while this looks comprehensive, this really only tests
+           f:apply#2 -->
+      <scenario label="supports currying">
+        <variable name="fn8"
+                  select="f:make-ref( QName( $foo-uri, 'fn8' ),
+                                      8 )" />
+
+        <call function="f:apply">
+          <!-- @, @ makin' you dizzy? -->
+          <param name="fnref"
+                 select="f:apply(
+                           f:apply(
+                             f:apply(
+                               f:apply(
+                                 f:apply(
+                                   f:apply(
+                                     f:apply(
+                                       $fn8,
+                                       $args/foo:arg1 ),
+                                     $args/foo:arg2 ),
+                                   $args/foo:arg3 ),
+                                 $args/foo:arg4 ),
+                               $args/foo:arg5 ),
+                             $args/foo:arg6 ),
+                           $args/foo:arg7 )" />
+
+          <!-- the final argument that will apply the unary
+               partially applied function to the target 8-ary -->
+          <param name="arg1"
+                 select="$args/foo:arg8" />
+        </call>
+
+        <expect label="applies target function and binds each
+                       argument in proper order"
+                test="$x:result[ 1 ] = foo:applied[ @n = 8 ]
+                      and $x:result[ 2 ] is $args/foo:arg1
+                      and $x:result[ 3 ] is $args/foo:arg2
+                      and $x:result[ 4 ] is $args/foo:arg3
+                      and $x:result[ 5 ] is $args/foo:arg4
+                      and $x:result[ 6 ] is $args/foo:arg5
+                      and $x:result[ 7 ] is $args/foo:arg6
+                      and $x:result[ 8 ] is $args/foo:arg7
+                      and $x:result[ 9 ] is $args/foo:arg8" />
+      </scenario>
+    </scenario>
   </scenario>
 
 

From a351e949103e4650a6647566218668678c029bb8 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Wed, 26 Nov 2014 16:46:02 -0500
Subject: [PATCH 10/12] All `f:apply' functions support partial application

'Tis tasty!
---
 src/apply.xsl       |  86 +++++++--------------
 test/apply-test.xsl |  16 ++++
 test/apply.xspec    | 178 +++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 208 insertions(+), 72 deletions(-)

diff --git a/src/apply.xsl b/src/apply.xsl
index d96db5f..fc184c6 100644
--- a/src/apply.xsl
+++ b/src/apply.xsl
@@ -34,15 +34,12 @@
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
 
-  <apply-templates select="$fnref" mode="f:apply" />
+  <sequence select="f:partial( $fnref, () )" />
 </function>
 
 
-<!-- WARNING: inconsistent state: only `f:apply#{1,2}' support partial
-     application at the moment -->
-
 <function name="f:apply">
   <param name="fnref" as="item()+" />
   <param name="arg1" />
@@ -56,63 +53,50 @@
   <param name="arg1" />
   <param name="arg2" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
   <param name="arg4" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-    <with-param name="arg4" select="$arg4" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3, $arg4) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
   <param name="arg4" />
   <param name="arg5" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-    <with-param name="arg4" select="$arg4" />
-    <with-param name="arg5" select="$arg5" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3, $arg4,
+                                $arg5) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
@@ -120,19 +104,14 @@
   <param name="arg5" />
   <param name="arg6" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-    <with-param name="arg4" select="$arg4" />
-    <with-param name="arg5" select="$arg5" />
-    <with-param name="arg6" select="$arg6" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3, $arg4,
+                                $arg5, $arg6) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
@@ -141,20 +120,14 @@
   <param name="arg6" />
   <param name="arg7" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-    <with-param name="arg4" select="$arg4" />
-    <with-param name="arg5" select="$arg5" />
-    <with-param name="arg6" select="$arg6" />
-    <with-param name="arg7" select="$arg7" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3, $arg4,
+                                $arg5, $arg6, $arg7) )" />
 </function>
 
 
 <function name="f:apply">
-  <param name="fnref" as="element(f:ref)" />
+  <param name="fnref" as="item()+" />
   <param name="arg1" />
   <param name="arg2" />
   <param name="arg3" />
@@ -164,16 +137,9 @@
   <param name="arg7" />
   <param name="arg8" />
 
-  <apply-templates select="$fnref" mode="f:apply">
-    <with-param name="arg1" select="$arg1" />
-    <with-param name="arg2" select="$arg2" />
-    <with-param name="arg3" select="$arg3" />
-    <with-param name="arg4" select="$arg4" />
-    <with-param name="arg5" select="$arg5" />
-    <with-param name="arg6" select="$arg6" />
-    <with-param name="arg7" select="$arg7" />
-    <with-param name="arg8" select="$arg8" />
-  </apply-templates>
+  <sequence select="f:partial( $fnref,
+                               ($arg1, $arg2, $arg3, $arg4,
+                                $arg5, $arg6, $arg7, $arg8) )" />
 </function>
 
 
diff --git a/test/apply-test.xsl b/test/apply-test.xsl
index 010de9c..ca3ee18 100644
--- a/test/apply-test.xsl
+++ b/test/apply-test.xsl
@@ -154,4 +154,20 @@
     <sequence select="$arg1, $arg2, $arg3, $arg4,
                         $arg5, $arg6, $arg7, $arg8" />
   </template>
+
+
+  <function name="foo:arg8-check">
+    <param name="args"   as="item()+" />
+    <param name="result" as="item()+" />
+
+    <sequence select="$result[ 1 ] instance of element( foo:applied )
+                      and $result[ 2 ] is $args[1]
+                      and $result[ 3 ] is $args[2]
+                      and $result[ 4 ] is $args[3]
+                      and $result[ 5 ] is $args[4]
+                      and $result[ 6 ] is $args[5]
+                      and $result[ 7 ] is $args[6]
+                      and $result[ 8 ] is $args[7]
+                      and $result[ 9 ] is $args[8]" />
+  </function>
 </stylesheet>
diff --git a/test/apply.xspec b/test/apply.xspec
index 9262024..7f6ad61 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -218,12 +218,13 @@
 
 
     <scenario label="applied to partial argument list">
+      <variable name="fn8"
+                select="f:make-ref( QName( $foo-uri, 'fn8' ),
+                                    8 )" />
+
       <!-- while this looks comprehensive, this really only tests
            f:apply#2 -->
       <scenario label="supports currying">
-        <variable name="fn8"
-                  select="f:make-ref( QName( $foo-uri, 'fn8' ),
-                                      8 )" />
 
         <call function="f:apply">
           <!-- @, @ makin' you dizzy? -->
@@ -252,15 +253,168 @@
 
         <expect label="applies target function and binds each
                        argument in proper order"
-                test="$x:result[ 1 ] = foo:applied[ @n = 8 ]
-                      and $x:result[ 2 ] is $args/foo:arg1
-                      and $x:result[ 3 ] is $args/foo:arg2
-                      and $x:result[ 4 ] is $args/foo:arg3
-                      and $x:result[ 5 ] is $args/foo:arg4
-                      and $x:result[ 6 ] is $args/foo:arg5
-                      and $x:result[ 7 ] is $args/foo:arg6
-                      and $x:result[ 8 ] is $args/foo:arg7
-                      and $x:result[ 9 ] is $args/foo:arg8" />
+                test="foo:arg8-check( $args/*, $x:result )" />
+      </scenario>
+
+
+      <scenario label="with 1 argument">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg2,
+                                            $args/foo:arg3,
+                                            $args/foo:arg4,
+                                            $args/foo:arg5,
+                                            $args/foo:arg6,
+                                            $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 2 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg3,
+                                            $args/foo:arg4,
+                                            $args/foo:arg5,
+                                            $args/foo:arg6,
+                                            $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 3 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+          <param name="arg3"  select="$args/foo:arg3" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg4,
+                                            $args/foo:arg5,
+                                            $args/foo:arg6,
+                                            $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 4 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+          <param name="arg3"  select="$args/foo:arg3" />
+          <param name="arg4"  select="$args/foo:arg4" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg5,
+                                            $args/foo:arg6,
+                                            $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 5 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+          <param name="arg3"  select="$args/foo:arg3" />
+          <param name="arg4"  select="$args/foo:arg4" />
+          <param name="arg5"  select="$args/foo:arg5" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg6,
+                                            $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 6 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+          <param name="arg3"  select="$args/foo:arg3" />
+          <param name="arg4"  select="$args/foo:arg4" />
+          <param name="arg5"  select="$args/foo:arg5" />
+          <param name="arg6"  select="$args/foo:arg6" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg7,
+                                            $args/foo:arg8 ) )" />
+      </scenario>
+
+
+      <scenario label="with 7 arguments">
+        <call function="f:apply">
+          <param name="fnref" select="$fn8" />
+          <param name="arg1"  select="$args/foo:arg1" />
+          <param name="arg2"  select="$args/foo:arg2" />
+          <param name="arg3"  select="$args/foo:arg3" />
+          <param name="arg4"  select="$args/foo:arg4" />
+          <param name="arg5"  select="$args/foo:arg5" />
+          <param name="arg6"  select="$args/foo:arg6" />
+          <param name="arg7"  select="$args/foo:arg7" />
+        </call>
+
+        <expect label="produces a partial application"
+                test="f:is-partial( $x:result )" />
+
+        <expect label="can complete application with arguments in
+                       proper order"
+                test="foo:arg8-check(
+                        $args/*,
+                        f:apply( $x:result, $args/foo:arg8 ) )" />
       </scenario>
     </scenario>
   </scenario>

From d9f4894546b1b3791caf55c05b79ce005d30560e Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Thu, 27 Nov 2014 00:26:58 -0500
Subject: [PATCH 11/12] README.md updated with mention of partial applications

It does not do it much justice; documentation will come later.  The test
cases are comprehensive.
---
 README.md | 34 +++++++++++++++++++++++++++++++---
 1 file changed, 31 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 150e6ec..996db0b 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,8 @@ functions and XSLT templates that take XSLT as input and produce XSLT
 as output.
 
 The system is fully tested---see the test cases for additional
-documentation as this project gets under way.
+documentation as this project gets under way.  This README will serve
+as an informal manual until official documentation is produced.
 
 
 ## Higher-Order Functions
@@ -25,8 +26,8 @@ proprietary versions of their software.  Others still may wish to
 continue using XSLT 2.0.
 
 There are various approaches/kluges for this problem in earlier
-versions of XSLT; this implementation is motivated by Dimitre
-Novatchev's work on [higher-order functions in FXSL][nova-ho].
+versions of XSLT; the basis of this implementation is motivated by
+Dimitre Novatchev's work on [higher-order functions in FXSL][nova-ho].
 
 For example, consider an implementation of a filter function that
 accepts a node set and a predicate:
@@ -66,6 +67,33 @@ work is needed.  This can be included as part of a build process, and
 the output included within a distribution.
 
 
+### Partial Applications
+Dynamic function applications using `f:apply` are partially applied if
+the number of arguments provided is less than the arity of the target
+function.
+
+```xml
+  <!-- produces a new dynamic function of arity 5 - 3 = 2 -->
+  <variable name="partial"
+            select="f:apply( my:arity5(), 1, 2, 3 )" />
+
+  <!-- consequently, currying is supported -->
+  <variable name="result"
+            select="f:apply( f:apply( $partial, 4 ), 5 )" />
+
+  <!-- equiv = true() -->
+  <variable name="equiv"
+            select="$result
+                    = f:apply( my:arity5(), 1, 2, 3, 4, 5 )
+                    = my:arity5( 1, 2, 3, 4, 5 )" />
+```
+
+The implementation of partial function applications avoids the
+complexity and inaccuracies of [Novatchev's approach][nova-ho] by
+using only sequences, allowing arguments to retain their type and
+context.
+
+
 ## License
 This program is free software: you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the Free

From 162c03750834135f7aa52c8ad70aab8d738d9222 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Thu, 27 Nov 2014 00:34:30 -0500
Subject: [PATCH 12/12] apply-gen TODOs added to header

---
 src/transform/apply-gen.xsl | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/transform/apply-gen.xsl b/src/transform/apply-gen.xsl
index 2f7f032..1591d50 100644
--- a/src/transform/apply-gen.xsl
+++ b/src/transform/apply-gen.xsl
@@ -18,6 +18,13 @@
 
     You should have received a copy of the GNU General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+  TODOs:
+     - Properly handle arity overloading.
+     - Generate functions for partial applications, so long as the target
+       function does not have its arity overloaded (since that would
+       cause currying and partial application of N>1 arguments to
+       potentially yield different results).
 -->
 
 <stylesheet version="2.0"