EXSLT 1.0 Proposed List

Proposed modules for EXSLT 1.0
==============================

* = existing extension
f = extension function
e = extension element
a = extension attribute
o = other extension mechanism
2 = similar XPath 2/XSLT 2 mechanism exists


Module: common
--------------

[*f2] exsl:node-set

      Also TODO: make the coverage of keys over node-sets created "artificially" explicit

[*f2] exsl:object-type

[e2]  exsl:variable

      This is the same as xsl:variable, with the exception that it contains a node-set when the corresponding xsl:variable would contain a tree fragment

[e2]  exsl:param

      This is the same as xsl:param, with the exception that it contains a node-set when the corresponding xsl:param would contain a tree fragment


Module: Resource
----------------

[o2]  res:xhtml

      Output mode for xsl:output, adding features for outputting xhtml following the XHTML compat guidelines

[o]   res:xml

      output method based on xml method, but allowing finer control with
      exsl-specific extension attributes

[a2]  res:c14n

      Attribute for xsl:output, adding features for outputting Canonical XML.  ALlowed only when using exsl:xml or exsl:xhtml output (question: does c14n and XHTML compat guidelines ever conflict?)
      
[a]   res:no-indent-elements

      Attribute of xsl:output, only when using output mode of exsl:xml, selects names of elements to *not* be indented when using indent="yes"

[*e2] exsl:document

      Notice: this is a proposal to move this element from Common to Resource
      module: common really should have as little cruft as possible, and should
      be a no-brainer to implement.  exsl:document is not a no-brainer

[f]   res:document

      This *function* is based on the core XSLT document function, but may only fail by returning a special node set with failure information in a special namespace

[f2]  res:unparsed-text

      An exsl:document function for text files.  Think about error issues (e.g. unparsed-text-available in XSLT 2.0)

[e2]  res:character-map

      a system for declaring sets of character maps for output control
      I think EXSLT's char maps, however should differ from XSL 2.0's in
      allowing code points to be specified explicitly for output charaters
      note: the idea is not to support binary output, but rather text output
      that includes Unicode code points not allowed in XML docs

[a2]  res:use-character-maps

      allowed on xsl:output with any output method defined in EXSLT.  Applies
      declared char map

[a2]  res:byte-order-mark

      Attribute for xsl:output.  Whether or not to emit a BOM.


Module: System
--------------

[o]   Namespace to use with the system-property function for retrieving environment variable values


Module: Dates and Times
-----------------------

[*f2] date:add

[*f2] date:add-duration

[*f2] date:date

[*f2] date:date-time

[*f]  date:day-abbreviation

[*f2] date:day-in-month

[*f]  date:day-in-week

[*f]  date:day-in-year

[*f]  date:day-name

[*f]  date:day-of-week-in-month

[*f2] date:difference

[*f2] date:duration

[*f]  date:format-date

[*f2] date:hour-in-day

[*f]  date:leap-year

[*f2] date:minute-in-hour

[*f]  date:month-abbreviation

[*f2] date:month-in-year

[*f]  date:month-name

[*f]  date:parse-date

[*f2] date:second-in-minute

[*f]  date:seconds

[*f2] date:sum

[*f2] date:time

[*f]  date:week-in-month

[*f]  date:week-in-year

[*f2] date:year

[*e]  date:format-date


Module: Dynamic
---------------

[*f] dyn:closure

[*f] dyn:evaluate

[*f] dyn:map

[*f] dyn:max

[*f] dyn:min

[*f] dyn:sum

[f2] dyn:if

     If the first argument, when converted to a boolean, is true,
     returns the second argument. Otherwise, returns the third
     argument, or if the third argument is not given, returns an
     empty node-set.  (see 4XSLT's f:if)

[f]  dyn:vars

     Return name and values of all variables in scope (see 4XSLT's f:dump-vars)

[f]  dyn:keys

     Return name and value sets of all keys in scope for the context node's document (see 4XSLT's f:dump-keys)


Module: Functions
-----------------

[*e2] func:function

[*e2] func:result

[*e]  func:script

[a]   func:memoize

      Turns on memoization for any func:function on which it's asserted


Module: Math
------------

[*f2] math:abs

[*f]  math:acos

[*f]  math:asin

[*f]  math:atan

[*f]  math:atan2

[*f]  math:constant

[*f]  math:cos

[*f]  math:exp

[*f]  math:highest

[*f]  math:log

[*f]  math:lowest

[*f2] math:max

[*f2] math:min

[*f]  math:power

[*f]  math:sin

[*f]  math:sqrt


Module: Random
--------------

[*f] random:random-sequence


Module: Regular Expressions
---------------------------

[*f2] regexp:match

[*f2] regexp:replace

[*f2] regexp:test

[e2]  regexp:analyze-string

      based on XSLT 2 xsl:analyze-string


Module: Sets
------------

[*f2] set:difference

[*f2] set:distinct

[*f2] set:has-same-node

[*f2] set:intersection

[*f2] set:leading

[*f2] set:trailing

[f2]  set:range

      Returns a node-set consisting of text nodes encapsulating integers
      in the numeric range bounded by the given low and high values.
      (see 4XSLT f:range)

[e2]  exsl:for-each-group

[f2]  exsl:current-group

[f2]  exsl:current-grouping-key

[f2]  exsl:perform-sort


Module: Strings
---------------

[*f]  str:align

[*f2] str:concat

[*f]  str:decode-uri

[*f2] str:encode-uri

[*f]  str:padding

[*f]  str:replace

[*f]  str:split

[*f]  str:tokenize

[f2]  str:ends-with

      Returns true() if a string ends with a substring, false() otherwise
      (see 4XSLT f:ends-with)

[f2]  str:compare

[f2]  str:codepoints-to-string

[f2]  str:string-to-codepoints

[f]   str:string-to-number

      This should be like the POSIX strtol function, in that it should take an optional base argument and treat the string to be converted as being in that base.

      Should this be just one in a conversions module?  Maybe it should work for more than just string argument?


Module: Uris
------------

[f2] uri:base-uri

     returns the base URI of the given node (see 4XSLT f:base-uri)

[f2] uri:resolve-uri

     resolves a relative URI against a base (see 4XSLT f:resolve-uri)


Module: Lexical
---------------

[f]  lex:escape-xml

     Returns the given string with XML markup characters "&", "<" and
     ">" escaped as "&amp;", "&lt;" and "&gt;".  (see 4XSLT f:escape-xml)

[f]  lex:parse-xml

     parses the string-value of the given object as XML
     and returns a node-set whose sole item is the resulting parsed
     document's root node. The XML must be a well-formed document.
     (see 4XSLT f:parse-xml)

[f]  lex:serialize-xml

     takes a node set and turns it into a string
     representing the serialization of the node set, obtained
     by concatenating the serialization of each node in the
     node set in document order.  (see 4XSLT's f:serialize-xml)

[f2] lex:namespace-uri-from-qname

     do we need this, or is it easy enough from namespace axis ops?


Components Slated for Removal
-----------------------------

[*f]  math:random

      Slated for removal in favor of random:random-sequence.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.7 (GNU/Linux)

iD8DBQFD8MjijkcskvOyl78RAgdtAJ4wgyh0O+ckyMbPMK0OU6waKQiBxQCghw78
hFVqE6St4TJKMcpeyE5nE2s=
=wS/f
-----END PGP SIGNATURE-----