From f62e6a8e33451dbfe8097131a261ff10d9c3dc28 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Fri, 28 Nov 2014 02:27:03 -0500
Subject: [PATCH 1/8] Arity test case using f:make-ref

In place of manual specification.
---
 test/apply/arity-test.xsl | 32 ++++++++++++++++++++++++++++++++
 test/apply/arity.xspec    | 14 ++++++++------
 2 files changed, 40 insertions(+), 6 deletions(-)
 create mode 100644 test/apply/arity-test.xsl

diff --git a/test/apply/arity-test.xsl b/test/apply/arity-test.xsl
new file mode 100644
index 0000000..0993c3f
--- /dev/null
+++ b/test/apply/arity-test.xsl
@@ -0,0 +1,32 @@
+<?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/>.
+-->
+
+<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">
+
+  <!-- this imports the SUT, as well as additional functions we need
+       for testing -->
+  <import href="../../src/apply.xsl" />
+</stylesheet>
diff --git a/test/apply/arity.xspec b/test/apply/arity.xspec
index bb94b01..1fe892f 100644
--- a/test/apply/arity.xspec
+++ b/test/apply/arity.xspec
@@ -25,7 +25,11 @@
              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">
+             stylesheet="arity-test.xsl">
+
+  <variable name="foo-uri"
+            select="namespace-uri-for-prefix(
+                      'foo', root(.)/element() )" />
 
 
   <scenario label="f:arity">
@@ -35,11 +39,9 @@
 
       <!-- 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>
+      <variable name="fnref"
+                select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
+                                    $test-arity )" />
 
       <call function="f:arity">
         <param name="fnref"

From c64cefe931b7c2d813075dc47b8f4b66d095c61a Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Sat, 29 Nov 2014 01:16:59 -0500
Subject: [PATCH 2/8] `f:arity' now considers partial applications

---
 src/apply/arity.xsl    | 29 +++++++++++++++++-----------
 src/apply/partial.xsl  | 15 +++++++++------
 test/apply/arity.xspec | 43 +++++++++++++++++++++++++++---------------
 3 files changed, 55 insertions(+), 32 deletions(-)

diff --git a/src/apply/arity.xsl b/src/apply/arity.xsl
index 5e9de23..ad24032 100644
--- a/src/apply/arity.xsl
+++ b/src/apply/arity.xsl
@@ -28,21 +28,28 @@
 
 
 <!--
-  Attempt to retrieve arity of dynamic function
+  Attempt to retrieve arity of dynamic function @var{fnref}
 
-  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.
+  @var{fnref} must be a dynamic function reference satisfying
+  @code{f:is-ref}.  Partially applied function references will have an
+  arity equivalent to the free parameters in the target function.
 -->
-<function name="f:arity" as="xs:decimal">
-  <param name="fnref" as="element(f:ref)" />
+<function name="f:arity" as="xs:integer">
+  <param name="fnref" as="item()+" />
 
-  <sequence select="if ( $fnref/@arity ) then
-                      $fnref/@arity
+  <variable name="ref" as="element( f:ref )"
+            select="$fnref[ 1 ]" />
+
+  <variable name="arity" as="xs:integer"
+            select="$ref/@arity" />
+
+  <variable name="partial" as="xs:integer"
+            select="if ( $ref/@partial ) then
+                      $ref/@partial
                     else
-                      -1" />
+                      0" />
+
+  <sequence select="$arity - $partial" />
 </function>
 
 </stylesheet>
diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index 2208a95..3953377 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -71,12 +71,15 @@
     <sequence select="$args" />
   </variable>
 
-  <variable name="argn" as="xs:decimal"
-            select="count( $argout )" />
-
-  <variable name="arity" as="xs:decimal"
+  <!-- note that, if FNREF is partially applied, then this arity
+       represents the arity of the partially applied function, _not_
+       the target function -->
+  <variable name="arity" as="xs:integer"
             select="f:arity( $ref )" />
 
+  <variable name="argn" as="xs:integer"
+            select="count( $args )" />
+
   <choose>
     <when test="$argn eq $arity">
       <sequence select="_f:apply-partial( $ref, $argout )" />
@@ -87,7 +90,7 @@
                        select="$ref">
         <with-param name="args"  select="$argout" />
         <with-param name="arity" select="$arity" />
-        <with-param name="argn"  select="$argn" />
+        <with-param name="argn"  select="count( $argout )" />
       </apply-templates>
     </when>
 
@@ -96,7 +99,7 @@
         <sequence select="$ref/@*" />
 
         <attribute name="partial"
-                   select="count( $args )" />
+                   select="count( $argout )" />
 
         <sequence select="$ref/*" />
       </f:ref>
diff --git a/test/apply/arity.xspec b/test/apply/arity.xspec
index 1fe892f..a09198f 100644
--- a/test/apply/arity.xspec
+++ b/test/apply/arity.xspec
@@ -31,6 +31,13 @@
             select="namespace-uri-for-prefix(
                       'foo', root(.)/element() )" />
 
+  <variable name="test-arity"
+            select="5" />
+
+  <variable name="test-fn"
+            select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
+                                $test-arity )" />
+
 
   <scenario label="f:arity">
     <scenario label="given a proper function reference">
@@ -39,32 +46,38 @@
 
       <!-- test our format directly; do not rely on the
            apply-gen code -->
-      <variable name="fnref"
-                select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
-                                    $test-arity )" />
-
       <call function="f:arity">
-        <param name="fnref"
-               select="$fnref" />
+        <param name="fnref" select="$test-fn" />
       </call>
 
       <expect label="provides function arity"
-              test="$x:result = $test-arity" />
+              select="$test-arity" />
     </scenario>
 
 
-    <scenario label="given a function reference with no defined arity">
-      <variable name="fnref">
-        <f:ref><foo:bar /></f:ref>
-      </variable>
-
+    <scenario label="given a partially applied function reference">
       <call function="f:arity">
         <param name="fnref"
-               select="$fnref" />
+               select="f:apply( $test-fn, 1, 2 )" />
       </call>
 
-      <expect label="returns -1"
-              test="$x:result = -1" />
+      <expect label="provides arity of the target function minus the
+                     number of bound parameters"
+              select="$test-arity - 2" />
+    </scenario>
+
+
+    <scenario label="given a multiply-partially-applied function reference">
+      <call function="f:arity">
+        <param name="fnref"
+               select="f:apply(
+                         f:apply( $test-fn, 1, 2 ),
+                         3 )" />
+      </call>
+
+      <expect label="provides arity of the target function minus the
+                     number of bound parameters"
+              select="$test-arity - 3" />
     </scenario>
   </scenario>
 </description>

From 5857eed3d6409eefebd026dc6734d8a71ec7b1e5 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Sat, 29 Nov 2014 02:01:40 -0500
Subject: [PATCH 3/8] `arity.xsl' stylesheet combined with ref functions into
 `ref.xsl'

These are strongly related---they operate on the same abstraction.
---
 src/apply.xsl                               |  74 ------
 src/apply/arity.xsl                         |  55 -----
 src/apply/partial.xsl                       |   2 +-
 src/apply/ref.xsl                           | 150 ++++++++++++
 test/apply.xspec                            | 158 -------------
 test/apply/arity.xspec                      |  83 -------
 test/apply/{arity-test.xsl => ref-test.xsl} |   5 +-
 test/apply/ref.xspec                        | 244 ++++++++++++++++++++
 8 files changed, 399 insertions(+), 372 deletions(-)
 delete mode 100644 src/apply/arity.xsl
 create mode 100644 src/apply/ref.xsl
 delete mode 100644 test/apply/arity.xspec
 rename test/apply/{arity-test.xsl => ref-test.xsl} (90%)
 create mode 100644 test/apply/ref.xspec

diff --git a/src/apply.xsl b/src/apply.xsl
index fc184c6..b7c4940 100644
--- a/src/apply.xsl
+++ b/src/apply.xsl
@@ -162,78 +162,4 @@
   </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/src/apply/arity.xsl b/src/apply/arity.xsl
deleted file mode 100644
index ad24032..0000000
--- a/src/apply/arity.xsl
+++ /dev/null
@@ -1,55 +0,0 @@
-<?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 @var{fnref}
-
-  @var{fnref} must be a dynamic function reference satisfying
-  @code{f:is-ref}.  Partially applied function references will have an
-  arity equivalent to the free parameters in the target function.
--->
-<function name="f:arity" as="xs:integer">
-  <param name="fnref" as="item()+" />
-
-  <variable name="ref" as="element( f:ref )"
-            select="$fnref[ 1 ]" />
-
-  <variable name="arity" as="xs:integer"
-            select="$ref/@arity" />
-
-  <variable name="partial" as="xs:integer"
-            select="if ( $ref/@partial ) then
-                      $ref/@partial
-                    else
-                      0" />
-
-  <sequence select="$arity - $partial" />
-</function>
-
-</stylesheet>
diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index 3953377..8a8fcba 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -29,7 +29,7 @@
   xmlns:f="http://www.lovullo.com/hoxsl/apply"
   xmlns:_f="http://www.lovullo.com/hoxsl/apply/_priv">
 
-<import href="arity.xsl" />
+<import href="ref.xsl" />
 
 
 <!--
diff --git a/src/apply/ref.xsl b/src/apply/ref.xsl
new file mode 100644
index 0000000..8c6df09
--- /dev/null
+++ b/src/apply/ref.xsl
@@ -0,0 +1,150 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Dynamic function reference
+
+  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/>.
+
+  A dynamic function reference is a sequence describing a dynamic
+  function to be applied.  It consists of two major parts—the dynamic
+  function reference descriptor and the arguments to bind to its
+  parameters:
+
+  @example
+    (desc[, arg1[, ...argn]])
+  @end example
+
+  The descriptor @var{desc} has the following format:
+
+  @example
+    <f:ref arity="N" [...]>
+      <target />
+    </f:ref>
+  @end example
+
+  where the @var{target} node shares the same QName as the function to
+  be applied, and @var{@arity} is its arity.  The @var{f:ref} node may
+  be decorated with additional attributes depending on its context or
+  constructor.
+-->
+
+<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">
+
+
+<!--
+  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>
+
+
+<!--
+  Attempt to retrieve arity of dynamic function @var{fnref}
+
+  @var{fnref} must be a dynamic function reference satisfying
+  @code{f:is-ref}.  Partially applied function references will have an
+  arity equivalent to the free parameters in the target function.
+-->
+<function name="f:arity" as="xs:integer">
+  <param name="fnref" as="item()+" />
+
+  <variable name="ref" as="element( f:ref )"
+            select="$fnref[ 1 ]" />
+
+  <variable name="arity" as="xs:integer"
+            select="$ref/@arity" />
+
+  <variable name="partial" as="xs:integer"
+            select="if ( $ref/@partial ) then
+                      $ref/@partial
+                    else
+                      0" />
+
+  <sequence select="$arity - $partial" />
+</function>
+
+</stylesheet>
diff --git a/test/apply.xspec b/test/apply.xspec
index 7f6ad61..cbaff69 100644
--- a/test/apply.xspec
+++ b/test/apply.xspec
@@ -418,162 +418,4 @@
       </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>
diff --git a/test/apply/arity.xspec b/test/apply/arity.xspec
deleted file mode 100644
index a09198f..0000000
--- a/test/apply/arity.xspec
+++ /dev/null
@@ -1,83 +0,0 @@
-<?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="arity-test.xsl">
-
-  <variable name="foo-uri"
-            select="namespace-uri-for-prefix(
-                      'foo', root(.)/element() )" />
-
-  <variable name="test-arity"
-            select="5" />
-
-  <variable name="test-fn"
-            select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
-                                $test-arity )" />
-
-
-  <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 -->
-      <call function="f:arity">
-        <param name="fnref" select="$test-fn" />
-      </call>
-
-      <expect label="provides function arity"
-              select="$test-arity" />
-    </scenario>
-
-
-    <scenario label="given a partially applied function reference">
-      <call function="f:arity">
-        <param name="fnref"
-               select="f:apply( $test-fn, 1, 2 )" />
-      </call>
-
-      <expect label="provides arity of the target function minus the
-                     number of bound parameters"
-              select="$test-arity - 2" />
-    </scenario>
-
-
-    <scenario label="given a multiply-partially-applied function reference">
-      <call function="f:arity">
-        <param name="fnref"
-               select="f:apply(
-                         f:apply( $test-fn, 1, 2 ),
-                         3 )" />
-      </call>
-
-      <expect label="provides arity of the target function minus the
-                     number of bound parameters"
-              select="$test-arity - 3" />
-    </scenario>
-  </scenario>
-</description>
diff --git a/test/apply/arity-test.xsl b/test/apply/ref-test.xsl
similarity index 90%
rename from test/apply/arity-test.xsl
rename to test/apply/ref-test.xsl
index 0993c3f..268b805 100644
--- a/test/apply/arity-test.xsl
+++ b/test/apply/ref-test.xsl
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!--
-  Tests arity calculations
+  Tests dynamic function reference
 
   Copyright (C) 2014 LoVullo Associates, Inc.
 
@@ -29,4 +29,7 @@
   <!-- this imports the SUT, as well as additional functions we need
        for testing -->
   <import href="../../src/apply.xsl" />
+
+  <!-- numerous templates for arity tests -->
+  <import href="../apply-test.xsl" />
 </stylesheet>
diff --git a/test/apply/ref.xspec b/test/apply/ref.xspec
new file mode 100644
index 0000000..da2a9df
--- /dev/null
+++ b/test/apply/ref.xspec
@@ -0,0 +1,244 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Tests dynamic function reference
+
+  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="ref-test.xsl">
+
+  <variable name="foo-uri"
+            select="namespace-uri-for-prefix(
+                      'foo', root(.)/element() )" />
+
+  <variable name="test-arity"
+            select="5" />
+
+  <variable name="test-fn"
+            select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
+                                $test-arity )" />
+
+
+  <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">
+      <variable name="arg">
+        <foo:bar />
+      </variable>
+
+      <call function="f:apply">
+        <param name="fnref"
+               select="f:make-ref( QName( $foo-uri, 'fn1' ),
+                                   1 )" />
+        <param name="arg1" select="$arg" />
+      </call>
+
+      <expect label="that can be applied using f:apply"
+              test="$x:result[ 1 ] = foo:applied[ @n = 1 ]
+                    and $x:result[ 2 ] is $arg" />
+    </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>
+
+
+  <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 -->
+      <call function="f:arity">
+        <param name="fnref" select="$test-fn" />
+      </call>
+
+      <expect label="provides function arity"
+              select="$test-arity" />
+    </scenario>
+
+
+    <scenario label="given a partially applied function reference">
+      <call function="f:arity">
+        <param name="fnref"
+               select="f:apply( $test-fn, 1, 2 )" />
+      </call>
+
+      <expect label="provides arity of the target function minus the
+                     number of bound parameters"
+              select="$test-arity - 2" />
+    </scenario>
+
+
+    <scenario label="given a multiply-partially-applied function reference">
+      <call function="f:arity">
+        <param name="fnref"
+               select="f:apply(
+                         f:apply( $test-fn, 1, 2 ),
+                         3 )" />
+      </call>
+
+      <expect label="provides arity of the target function minus the
+                     number of bound parameters"
+              select="$test-arity - 3" />
+    </scenario>
+  </scenario>
+</description>

From bc871435fa67507a207bed5106dcb22e0dd09145 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Sun, 30 Nov 2014 03:28:00 -0500
Subject: [PATCH 4/8] apply-gen now uses `f:make-ref'

We're essentailly macro-expanding the `f:make-ref' call.  :)
---
 src/transform/apply-gen.xsl    | 20 +++++++-----------
 test/transform/apply-gen.xspec | 38 ++++++++++++++++++++++++++++------
 2 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/src/transform/apply-gen.xsl b/src/transform/apply-gen.xsl
index 1591d50..adf5401 100644
--- a/src/transform/apply-gen.xsl
+++ b/src/transform/apply-gen.xsl
@@ -36,6 +36,8 @@
   xmlns:out="http://www.lovullo.com/hoxsl/apply/gen/_out"
   exclude-result-prefixes="#default fgen">
 
+<import href="../apply/ref.xsl" />
+
 <output indent="yes"
         encoding="utf-8" />
 
@@ -119,11 +121,10 @@
        dependencies and simply specify the full namespace URI -->
   <variable name="name-resolv"
             select="resolve-QName( @name, . )" />
-  <variable name="ns-prefix"
-            select="substring-before( @name, ':' )" />
   <variable name="ns"
-            select="namespace-uri-for-prefix(
-                      $ns-prefix, . )" />
+            select="namespace-uri-from-QName( $name-resolv )" />
+  <variable name="ns-prefix"
+            select="prefix-from-QName( $name-resolv )" />
 
   <sequence select="fgen:create-func(
                       ., $name-resolv, $ns-prefix, $ns )" />
@@ -164,15 +165,10 @@
     <namespace name="{$ns-prefix}"
                select="$ns" />
 
-    <f:ref>
-      <attribute name="arity"
-                 select="count( $fnref/xsl:param )" />
+    <variable name="arity"
+              select="count( $fnref/xsl:param )" />
 
-      <!-- represents the function being referenced -->
-      <element name="{$local-name}"
-               namespace="{$ns}">
-      </element>
-    </f:ref>
+    <sequence select="f:make-ref( $name-resolv, $arity )" />
   </out:function>
 </function>
 
diff --git a/test/transform/apply-gen.xspec b/test/transform/apply-gen.xspec
index 51de570..151731c 100644
--- a/test/transform/apply-gen.xspec
+++ b/test/transform/apply-gen.xspec
@@ -184,13 +184,39 @@
 
     <!-- note that this _does not_ test f:arity itself: it is intended
          to test that the arity datum is properly generated -->
-    <scenario label="f:arity">
-      <call function="f:arity">
-        <param name="fnref" select="foo:sub-two()" />
-      </call>
+    <scenario label="constructed dynamic function reference">
+      <variable name="two-result"
+                select="foo:sub-two()" />
 
-      <expect label="is able to determine arity"
-              test="$x:result = 2" />
+      <scenario label="is recognized as">
+        <call function="f:is-ref">
+          <param name="fnref" select="$two-result" />
+        </call>
+
+        <expect label="a dynamic function reference"
+                select="true()" />
+      </scenario>
+
+
+      <scenario label="target QName">
+        <call function="f:QName">
+          <param name="fnref" select="$two-result" />
+        </call>
+
+        <expect label="is the QName of the target function"
+                select="QName( 'http://www.lovullo.com/_junk',
+                               'sub-two' )" />
+      </scenario>
+
+
+      <scenario label="arity">
+        <call function="f:arity">
+          <param name="fnref" select="$two-result" />
+        </call>
+
+        <expect label="is the arity of target function"
+                select="2" />
+      </scenario>
     </scenario>
   </scenario>
 </description>

From cd278c31d441acda3c4f91adec0b77d47ab97366 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Sun, 30 Nov 2014 03:29:46 -0500
Subject: [PATCH 5/8] Partial applications now manipulate fnref arity

Previously, a separate `@partial' attribute was added to the ref and the
`@arity' maintained.  Unfortunately, this coupled `f:arity' with
`f:partial', which is unnecessary, considering that partial application is
supposed to conceptually yield a new function, which should be transparent
to `f:arity'.
---
 src/apply/partial.xsl    |  8 ++++----
 src/apply/ref.xsl        | 10 +++-------
 test/apply/partial.xspec | 33 ++++++++++++++++++---------------
 3 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index 8a8fcba..98700be 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -98,8 +98,9 @@
       <f:ref>
         <sequence select="$ref/@*" />
 
-        <attribute name="partial"
-                   select="count( $argout )" />
+        <!-- the arity of the new partial application -->
+        <attribute name="arity"
+                   select="$arity - $argn" />
 
         <sequence select="$ref/*" />
       </f:ref>
@@ -128,8 +129,7 @@
   <!-- 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" />
+                    and exists( $fnref[ 2 ] )" />
 </function>
 
 
diff --git a/src/apply/ref.xsl b/src/apply/ref.xsl
index 8c6df09..3ea34de 100644
--- a/src/apply/ref.xsl
+++ b/src/apply/ref.xsl
@@ -135,16 +135,12 @@
   <variable name="ref" as="element( f:ref )"
             select="$fnref[ 1 ]" />
 
+  <!-- this implicitly asserts on the type; it should never fail if
+       the system is being used properly -->
   <variable name="arity" as="xs:integer"
             select="$ref/@arity" />
 
-  <variable name="partial" as="xs:integer"
-            select="if ( $ref/@partial ) then
-                      $ref/@partial
-                    else
-                      0" />
-
-  <sequence select="$arity - $partial" />
+  <sequence select="$arity" />
 </function>
 
 </stylesheet>
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
index eda5a53..33e3743 100644
--- a/test/apply/partial.xspec
+++ b/test/apply/partial.xspec
@@ -51,11 +51,9 @@
         <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 reference to original target"
+              test="f:QName( $x:result[ 1 ] )
+                      = f:QName( $fnref )" />
 
       <expect label="returns nothing else"
               test="count( $x:result ) = 1" />
@@ -68,12 +66,13 @@
         <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 target reference as first item in
+                     sequence"
+              test="f:QName( $fnref )
+                      = f:QName( $x:result[ 1 ] )" />
 
+      <!-- FIXME: this breaks the abstraction; use opaque
+           introspection -->
       <expect label="returns each argument, ordered"
               test="$x:result[ 2 ] is $args/foo:a
                     and $x:result[ 3 ] is $args/foo:b" />
@@ -108,8 +107,10 @@
         <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 target reference as first item in
+                     sequence"
+              test="f:QName( $fnref )
+                      = f:QName( $x:result[ 1 ] )" />
 
       <expect label="returns arguments from both partial applications"
               test="count( $x:result ) = 3" />
@@ -406,7 +407,9 @@
 
 
     <!-- caller may extract the function ref from the sequence and
-         assert on that -->
+         assert on that; we are going to explicitly choose to *not*
+         support that behavior, since an fnref acquires meaning as an
+         opaque unit  -->
     <scenario label="given a valid fref, partially applied with N>0
                      arguments, without argument sequence">
       <call function="f:is-partial">
@@ -414,8 +417,8 @@
                select="f:partial( foo:ternary(), (1, 2) )[ 1 ]" />
       </call>
 
-      <expect label="returns true()"
-              test="$x:result = true()" />
+      <expect label="returns false()"
+              select="false()" />
     </scenario>
   </scenario>
 

From 18c1614777e54338eeeff788cb3e1662481393c7 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Sun, 30 Nov 2014 04:34:44 -0500
Subject: [PATCH 6/8] `f:set-args' setter and `f:args' accessor implemented

As operations on dynamic function references become more complex, and since
evolution of the reference structure is planned to evolve, maintaining an
abstraction is vital for both grokking and maintenance.
---
 src/apply/ref.xsl    |  65 ++++++++++++++++-
 test/apply/ref.xspec | 161 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 220 insertions(+), 6 deletions(-)

diff --git a/src/apply/ref.xsl b/src/apply/ref.xsl
index 3ea34de..bb94d73 100644
--- a/src/apply/ref.xsl
+++ b/src/apply/ref.xsl
@@ -104,19 +104,24 @@
 <!--
   Retrieve the QName of the target dynamic function
 
-  Usually, this would match precisely the QName of the target
+  Usually, this will match precisely the QName of the target
   function.
 
+  @var{fnreF} must be a valid dynamic function reference.
+
   @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 )" />
+  <param name="fnref" as="item()+" />
+
+  <variable name="desc" as="element( f:ref )"
+            select="$fnref[ 1 ]" />
 
   <variable name="target" as="element()?"
-            select="$fnref/element()[ 1 ]" />
+            select="$desc/element()[ 1 ]" />
 
   <sequence select="node-name( $target )" />
 </function>
@@ -143,4 +148,58 @@
   <sequence select="$arity" />
 </function>
 
+
+<!--
+  Retrieve a sequence of the partially applied arguments of
+  @var{fnref}
+
+  The resulting sequence may be empty.  @var{fnref} is assumed to be a
+  valid dynamic function reference; you should verify that assumption
+  beforehand.
+-->
+<function name="f:args" as="item()*">
+  <param name="fnref" as="item()+" />
+
+  <sequence select="remove( $fnref, 1 )" />
+</function>
+
+
+<!--
+  Set partially applied arguments of @var{fnref} to @var{args},
+  replacing any existing arguments
+
+  The arity of @var{fnref} will be adjusted relative to the number of
+  items in @var{args} such that the resulting dynamic function
+  reference has the illusion of being its own, new function:
+  increasing the argument count of @var{fnref} will @emph{decrease}
+  the arity of the resulting reference and vice versa.
+
+  @var{fnref} must be a valid dynamic function reference.
+-->
+<function name="f:set-args" as="item()+">
+  <param name="fnref" as="item()+" />
+  <param name="args"  as="item()*" />
+
+  <variable name="desc" as="element( f:ref )"
+            select="$fnref[ 1 ]" />
+
+  <!-- this reference may be partially applied; see below arity
+       adjustment -->
+  <variable name="target-arity" as="xs:double"
+            select="$desc/@arity + count( f:args( $fnref ) )" />
+
+  <f:ref>
+    <sequence select="$desc/@*" />
+
+    <!-- treat partial applications as their own functions (with their
+         own arities) -->
+    <attribute name="arity"
+               select="$target-arity - count( $args )" />
+
+    <sequence select="$desc/*" />
+  </f:ref>
+
+  <sequence select="$args" />
+</function>
+
 </stylesheet>
diff --git a/test/apply/ref.xspec b/test/apply/ref.xspec
index da2a9df..c3e67b1 100644
--- a/test/apply/ref.xspec
+++ b/test/apply/ref.xspec
@@ -38,6 +38,14 @@
             select="f:make-ref( QName( $foo-uri, 'foo:bar' ),
                                 $test-arity )" />
 
+  <variable name="args">
+    <foo:args>
+      <foo:a />
+      <foo:b />
+      <foo:c />
+    </foo:args>
+  </variable>
+
 
   <scenario label="f:make-ref constructor">
     <scenario label="when called with a function QName and arity">
@@ -169,10 +177,11 @@
 
 
   <scenario label="f:QName accessor">
-    <scenario label="given a valid dynamic function reference">
-      <variable name="foo-qname"
-                select="QName( $foo-uri, 'foo' )" />
+    <variable name="foo-qname"
+              select="QName( $foo-uri, 'foo' )" />
 
+    <scenario label="given a valid dynamic function reference with no
+                     argments">
       <call function="f:QName">
         <param name="fnref"
                select="f:make-ref( $foo-qname, 0 )" />
@@ -186,6 +195,22 @@
     </scenario>
 
 
+    <scenario label="given a valid dynamic function reference with
+                     argments">
+      <call function="f:QName">
+        <param name="fnref"
+               select="f:set-args( f:make-ref( $foo-qname, 0 ),
+                                   (1, 2) )" />
+      </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">
@@ -241,4 +266,134 @@
               select="$test-arity - 3" />
     </scenario>
   </scenario>
+
+
+  <scenario label="f:set-args setter">
+    <scenario label="setting empty args on reference with no args">
+      <call function="f:set-args">
+        <param name="fnref" select="$test-fn" />
+        <param name="args"  select="()" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="retains target arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn )" />
+    </scenario>
+
+
+    <scenario label="setting args on reference with no args">
+      <call function="f:set-args">
+        <param name="fnref" select="$test-fn" />
+        <param name="args"  select="(1, 2)" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <!-- the function is now partially applied -->
+      <expect label="reduces arity by number of arguments"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 2" />
+    </scenario>
+
+
+    <scenario label="clearing args on reference with args">
+      <call function="f:set-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn, (1, 2) )" />
+        <param name="args"
+               select="()" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <!-- the function is no longer partially applied -->
+      <expect label="restores target function arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn )" />
+    </scenario>
+
+
+    <scenario label="increasing reference argument count">
+      <call function="f:set-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn, (1, 2) )" />
+        <param name="args"
+               select="(1, 2, 3)" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <!-- the function is no longer partially applied -->
+      <expect label="reduces arity by number of argments"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 3" />
+    </scenario>
+
+
+    <scenario label="decrasing reference argument count">
+      <call function="f:set-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn, (1, 2) )" />
+        <param name="args"
+               select="1" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <!-- the function is no longer partially applied -->
+      <expect label="increases arity by difference in argument count"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 1" />
+    </scenario>
+  </scenario>
+
+
+  <scenario label="f:args accessor">
+    <scenario label="given a new dynamic function reference">
+      <call function="f:args">
+        <param name="fnref" select="$test-fn" />
+      </call>
+
+      <expect label="produces empty argument list"
+              select="()" />
+    </scenario>
+
+
+    <scenario label="after an initial f:set-args">
+      <call function="f:args">
+        <param name="fnref"
+               select="f:set-args( $test-fn, ($args/foo:a,
+                                              $args/foo:b) )" />
+      </call>
+
+      <expect label="returns sequence of arguments by reference"
+              test="$x:result[ 1 ] is $args/foo:a
+                      and $x:result[ 2 ] is $args/foo:b" />
+
+      <expect label="returns no other items"
+              test="count( $x:result ) = 2" />
+    </scenario>
+
+
+    <scenario label="after a f:set-args on an existing argument list">
+      <call function="f:args">
+        <param name="fnref"
+               select="f:set-args(
+                         f:set-args( $test-fn, ($args/foo:a,
+                                                $args/foo:b) ),
+                         ($args/foo:b,
+                          $args/foo:c) )" />
+      </call>
+
+      <expect label="returns sequence of arguments by reference,
+                     discarding previously set arguments"
+              test="$x:result[ 1 ] is $args/foo:b
+                      and $x:result[ 2 ] is $args/foo:c" />
+
+      <expect label="returns no other items"
+              test="count( $x:result ) = 2" />
+    </scenario>
+  </scenario>
 </description>

From c526fa2925a7f6ce8dd825e1f3b6f254f07f3979 Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Mon, 1 Dec 2014 00:34:52 -0500
Subject: [PATCH 7/8] `f:{unshift,push}-args' added

---
 src/apply/ref.xsl    |  32 +++++++++
 test/apply/ref.xspec | 151 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 183 insertions(+)

diff --git a/src/apply/ref.xsl b/src/apply/ref.xsl
index bb94d73..c1a7be4 100644
--- a/src/apply/ref.xsl
+++ b/src/apply/ref.xsl
@@ -174,6 +174,10 @@
   increasing the argument count of @var{fnref} will @emph{decrease}
   the arity of the resulting reference and vice versa.
 
+  @emph{No validations are performed on arity}—if there exist more
+  arguments than the number of target function parameters, no error
+  will be raised.
+
   @var{fnref} must be a valid dynamic function reference.
 -->
 <function name="f:set-args" as="item()+">
@@ -202,4 +206,32 @@
   <sequence select="$args" />
 </function>
 
+
+<!--
+  Pushes @var{args} onto the argument list of @var{fnref}
+
+  This operates just as @code{f:set-args}, but retains existing arguments.
+-->
+<function name="f:push-args" as="item()+">
+  <param name="fnref" as="item()+" />
+  <param name="args"  as="item()*" />
+
+  <sequence select="f:set-args($fnref,
+                               (f:args( $fnref ), $args) )" />
+</function>
+
+
+<!--
+  Unshifts @var{args} onto the argument list of @var{fnref}
+
+  This operates just as @code{f:set-args}, but retains existing arguments.
+-->
+<function name="f:unshift-args" as="item()+">
+  <param name="fnref" as="item()+" />
+  <param name="args"  as="item()*" />
+
+  <sequence select="f:set-args($fnref,
+                               ($args, f:args( $fnref )) )" />
+</function>
+
 </stylesheet>
diff --git a/test/apply/ref.xspec b/test/apply/ref.xspec
index c3e67b1..86d0b2a 100644
--- a/test/apply/ref.xspec
+++ b/test/apply/ref.xspec
@@ -43,6 +43,7 @@
       <foo:a />
       <foo:b />
       <foo:c />
+      <foo:d />
     </foo:args>
   </variable>
 
@@ -396,4 +397,154 @@
               test="count( $x:result ) = 2" />
     </scenario>
   </scenario>
+
+
+  <scenario label="f:push-args mutator">
+    <scenario label="pushing arguments onto empty reference list">
+      <call function="f:push-args">
+        <param name="fnref"
+               select="$test-fn" />
+        <param name="args"
+               select="$args/foo:a,
+                       $args/foo:b" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="reduces arity by number of arguments, relative to
+                     target function"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 2" />
+
+      <expect label="sets arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:a
+                    and f:args( $x:result )[ 2 ] is $args/foo:b" />
+    </scenario>
+
+
+    <scenario label="pushing arguments onto populated reference
+                     list">
+      <call function="f:push-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn,
+                                   ($args/foo:a,
+                                    $args/foo:b) )" />
+        <param name="args"
+               select="$args/foo:c,
+                       $args/foo:d" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="reduces arity by number of arguments, relative to
+                     previous arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 4" />
+
+      <expect label="retains previous arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:a
+                    and f:args( $x:result )[ 2 ] is $args/foo:b" />
+
+      <expect label="pushes new arguments by reference"
+              test="f:args( $x:result )[ 3 ] is $args/foo:c
+                    and f:args( $x:result )[ 4 ] is $args/foo:d" />
+    </scenario>
+
+
+    <scenario label="pushing empty argument list onto populated
+                     reference list">
+      <call function="f:push-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn,
+                                   ($args/foo:a,
+                                    $args/foo:b) )" />
+        <param name="args" select="()" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="retains previous reference arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 2" />
+
+      <expect label="retains previous arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:a
+                    and f:args( $x:result )[ 2 ] is $args/foo:b" />
+    </scenario>
+  </scenario>
+
+
+  <scenario label="f:unshift-args mutator">
+    <scenario label="unshifting arguments onto empty reference list">
+      <call function="f:unshift-args">
+        <param name="fnref"
+               select="$test-fn" />
+        <param name="args"
+               select="$args/foo:a,
+                       $args/foo:b" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="reduces arity by number of arguments, relative to
+                     target function"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 2" />
+
+      <expect label="sets arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:a
+                    and f:args( $x:result )[ 2 ] is $args/foo:b" />
+    </scenario>
+
+
+    <scenario label="unshifting arguments onto populated reference
+                     list">
+      <call function="f:unshift-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn,
+                                   ($args/foo:a,
+                                    $args/foo:b) )" />
+        <param name="args"
+               select="$args/foo:c,
+                       $args/foo:d" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="reduces arity by number of arguments, relative to
+                     previous arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 4" />
+
+      <expect label="retains previous arguments by reference"
+              test="f:args( $x:result )[ 3 ] is $args/foo:a
+                    and f:args( $x:result )[ 4 ] is $args/foo:b" />
+
+      <expect label="unshifts new arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:c
+                    and f:args( $x:result )[ 2 ] is $args/foo:d" />
+    </scenario>
+
+
+    <scenario label="unshifting empty argument list onto populated
+                     reference list">
+      <call function="f:unshift-args">
+        <param name="fnref"
+               select="f:set-args( $test-fn,
+                                   ($args/foo:a,
+                                    $args/foo:b) )" />
+        <param name="args" select="()" />
+      </call>
+
+      <expect label="retains target QName"
+              test="f:QName( $x:result ) = f:QName( $test-fn )" />
+
+      <expect label="retains previous reference arity"
+              test="f:arity( $x:result ) = f:arity( $test-fn ) - 2" />
+
+      <expect label="retains previous arguments by reference"
+              test="f:args( $x:result )[ 1 ] is $args/foo:a
+                    and f:args( $x:result )[ 2 ] is $args/foo:b" />
+    </scenario>
+  </scenario>
 </description>

From 189eb0cdd6429f46453b1282cc540d2b3654fb8f Mon Sep 17 00:00:00 2001
From: Mike Gerwitz <gerwitzm@lovullo.com>
Date: Mon, 1 Dec 2014 01:20:29 -0500
Subject: [PATCH 8/8] Partial applications now defined in terms of ref mutators

---
 src/apply/partial.xsl       | 69 +++++++++++--------------------------
 test/apply/partial-test.xsl |  6 ++--
 test/apply/partial.xspec    | 49 +++++++++++++-------------
 3 files changed, 47 insertions(+), 77 deletions(-)

diff --git a/src/apply/partial.xsl b/src/apply/partial.xsl
index 98700be..e078163 100644
--- a/src/apply/partial.xsl
+++ b/src/apply/partial.xsl
@@ -55,57 +55,32 @@
   <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 ]" />
-
-  <variable name="argout" as="item()*">
-    <!-- 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" />
-  </variable>
-
   <!-- note that, if FNREF is partially applied, then this arity
        represents the arity of the partially applied function, _not_
        the target function -->
   <variable name="arity" as="xs:integer"
-            select="f:arity( $ref )" />
+            select="f:arity( $fnref )" />
 
   <variable name="argn" as="xs:integer"
             select="count( $args )" />
 
   <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">
-        <with-param name="args"  select="$argout" />
-        <with-param name="arity" select="$arity" />
-        <with-param name="argn"  select="count( $argout )" />
+                       select="$fnref">
+        <with-param name="fnref" select="$fnref" />
+        <with-param name="args"  select="$args" />
       </apply-templates>
     </when>
 
     <otherwise>
-      <f:ref>
-        <sequence select="$ref/@*" />
+      <variable name="new-ref"
+                select="f:push-args( $fnref, $args )" />
 
-        <!-- the arity of the new partial application -->
-        <attribute name="arity"
-                   select="$arity - $argn" />
-
-        <sequence select="$ref/*" />
-      </f:ref>
-
-      <sequence select="$argout" />
+      <sequence select="if ( $argn eq $arity ) then
+                          _f:apply-partial( $new-ref )
+                        else
+                          $new-ref" />
     </otherwise>
   </choose>
 </function>
@@ -149,24 +124,18 @@
           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="arity" as="xs:integer"
+            select="f:arity(.)" />
   <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 ),
+                QName( namespace-uri-for-prefix( 'f', . ),
                        'err:PARTIAL_PARAM_OVERFLOW' ),
                 concat( 'Attempted partial application of ',
-                        $fname, '#', $arity, ' with ',
+                        'function of arity ', $arity, ' with ',
                         $argn, ' arguments' ) )" />
 </template>
 
@@ -183,14 +152,16 @@
   are supported}.  This should be enough.
 -->
 <function name="_f:apply-partial">
-  <param name="fnref" as="element(f:ref)" />
-  <param name="args"  as="item()*" />
+  <param name="fnref" as="item()+" />
 
-  <variable name="fn" as="element()"
+  <variable name="args"
+            select="f:args( $fnref )" />
+
+  <variable name="desc" as="element( f:ref )"
             select="$fnref[ 1 ]" />
 
   <!-- just as `f:apply', we support up to 8 arguments -->
-  <apply-templates select="$fn" mode="f:apply">
+  <apply-templates select="$desc" mode="f:apply">
     <with-param name="arg1" select="$args[ 1 ]" />
     <with-param name="arg2" select="$args[ 2 ]" />
     <with-param name="arg3" select="$args[ 3 ]" />
diff --git a/test/apply/partial-test.xsl b/test/apply/partial-test.xsl
index 99dfadd..bdb0422 100644
--- a/test/apply/partial-test.xsl
+++ b/test/apply/partial-test.xsl
@@ -41,8 +41,10 @@
   <template mode="f:partial-arity-error-hook"
             match="f:ref"
             priority="5">
-    <param name="args" as="item()*" />
-    <param name="arity" as="xs:decimal" />
+    <param name="args"  as="item()*" />
+
+    <variable name="arity"
+              select="f:arity(.)" />
 
     <foo:partial-error arity="{$arity}" />
 
diff --git a/test/apply/partial.xspec b/test/apply/partial.xspec
index 33e3743..aca7643 100644
--- a/test/apply/partial.xspec
+++ b/test/apply/partial.xspec
@@ -52,8 +52,7 @@
       </call>
 
       <expect label="returns reference to original target"
-              test="f:QName( $x:result[ 1 ] )
-                      = f:QName( $fnref )" />
+              test="f:QName( $x:result) = f:QName( $fnref )" />
 
       <expect label="returns nothing else"
               test="count( $x:result ) = 1" />
@@ -68,14 +67,12 @@
 
       <expect label="returns target reference as first item in
                      sequence"
-              test="f:QName( $fnref )
-                      = f:QName( $x:result[ 1 ] )" />
+              test="f:QName( $fnref ) = f:QName( $x:result )" />
 
-      <!-- FIXME: this breaks the abstraction; use opaque
-           introspection -->
+      <variable name="rargs" select="f:args( $x:result )" />
       <expect label="returns each argument, ordered"
-              test="$x:result[ 2 ] is $args/foo:a
-                    and $x:result[ 3 ] is $args/foo:b" />
+              test="$rargs[ 1 ] is $args/foo:a
+                    and $rargs[ 2 ] is $args/foo:b" />
     </scenario>
 
 
@@ -92,10 +89,11 @@
               test="$x:result[ 1 ]
                     and $x:result[ 1 ] = foo:ternary-applied" />
 
+      <variable name="rargs" select="f:args( $x:result )" />
       <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" />
+              test="$rargs[ 1 ] is $args/foo:a
+                    and $rargs[ 2 ] is $args/foo:b
+                    and $rargs[ 3 ] is $args/foo:c" />
     </scenario>
 
 
@@ -107,18 +105,17 @@
         <param name="args"  select="$args/foo:b" />
       </call>
 
-      <expect label="returns target reference as first item in
-                     sequence"
-              test="f:QName( $fnref )
-                      = f:QName( $x:result[ 1 ] )" />
+      <expect label="retains target reference"
+              test="f:QName( $fnref ) = f:QName( $x:result )" />
 
       <expect label="returns arguments from both partial applications"
-              test="count( $x:result ) = 3" />
+              test="count( f:args( $x:result ) ) = 2" />
 
+      <variable name="rargs" select="f:args( $x:result )" />
       <expect label="arguments are ordered with previous applications
                      first in sequence"
-              test="$x:result[ 2 ] is $args/foo:a
-                    and $x:result[ 3 ] is $args/foo:b" />
+              test="$rargs[ 1 ] is $args/foo:a
+                    and $rargs[ 2 ] is $args/foo:b" />
     </scenario>
 
 
@@ -193,9 +190,9 @@
                 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" />
+                test="$x:result[ 2 ] = $args/foo:a
+                      and $x:result[ 3 ] = $args/foo:b
+                      and $x:result[ 4 ] = $args/foo:c" />
       </scenario>
 
 
@@ -442,8 +439,7 @@
       <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"
+      <expect label="provides arity of ref"
               test="$x:result[ 1 ]/@arity = 3" />
 
       <expect label="provides each argument of partial application
@@ -465,10 +461,11 @@
                                     $args/foo:d" />
       </call>
 
-      <expect label="produces error with all arguments"
+      <expect label="produces error with arguments of final
+                     application"
               test="exists( foo:partial-error )
-                    and $x:result[ 3 ] is $args/foo:a
-                    and $x:result[ 6 ] is $args/foo:d" />
+                    and $x:result[ 3 ] is $args/foo:c
+                    and $x:result[ 4 ] is $args/foo:d" />
     </scenario>
   </scenario>
 </description>