diff --git a/.gitmodules b/.gitmodules
index 1a1a6cc..1434b3e 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -4,3 +4,6 @@
 [submodule "ext/strings"]
 	path = ext/strings
 	url = https://github.com/dylan-lang/strings
+[submodule "documentation/sphinx-extensions"]
+	path = documentation/sphinx-extensions
+	url = https://github.com/dylan-lang/sphinx-extensions
diff --git a/documentation/Makefile b/documentation/Makefile
new file mode 100644
index 0000000..d0c3cbf
--- /dev/null
+++ b/documentation/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = source
+BUILDDIR      = build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
diff --git a/documentation/make.bat b/documentation/make.bat
new file mode 100644
index 0000000..747ffb7
--- /dev/null
+++ b/documentation/make.bat
@@ -0,0 +1,35 @@
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=sphinx-build
+)
+set SOURCEDIR=source
+set BUILDDIR=build
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
+	echo.installed, then set the SPHINXBUILD environment variable to point
+	echo.to the full path of the 'sphinx-build' executable. Alternatively you
+	echo.may add the Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.https://www.sphinx-doc.org/
+	exit /b 1
+)
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O%
+
+:end
+popd
diff --git a/documentation/source/conf.py b/documentation/source/conf.py
new file mode 100644
index 0000000..b5459b3
--- /dev/null
+++ b/documentation/source/conf.py
@@ -0,0 +1,78 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath('../sphinx-extensions/sphinxcontrib'))
+
+import dylan.domain
+import dylan.themes as dylan_themes
+
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'command-line-parser'
+copyright = '2022, Dylan Hackers'
+author = 'Dylan Hackers'
+
+# The full version, including alpha/beta/rc tags
+release = 'v3.2.0'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'dylan.domain',
+    'sphinx.ext.intersphinx'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build']
+
+# This makes it so that each document doesn't have to use
+#   .. default-domain:: dylan
+# but they probably should anyway, so that they can be built separately
+# without depending on this top-level config file.
+primary_domain = 'dylan'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+html_theme = dylan_themes.get_html_theme_default()
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+html_theme_options = dylan_themes.get_html_theme_options_default()
+
+# Add any paths that contain custom themes here, relative to this directory.
+html_theme_path = [dylan_themes.get_html_theme_path()]
+
+# The name for this set of Sphinx documents.  If None, it defaults to
+# "<project> v<release> documentation".
+html_title = "Dylan Library Reference"
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
diff --git a/documentation/source/index.rst b/documentation/source/index.rst
new file mode 100644
index 0000000..8f3544e
--- /dev/null
+++ b/documentation/source/index.rst
@@ -0,0 +1,723 @@
+*******************************
+The command-line-parser Library
+*******************************
+
+.. current-library:: command-line-parser
+.. current-module:: command-line-parser
+
+.. contents::  Contents
+   :local:
+
+
+The *command-line-parser* library provides a facility to parse the
+command line.  It exports two modules:
+
+* *command-line-parser* - Main API module
+* *option-parser-protocol* - For extending the API
+
+
+Overview
+========
+
+Here's a quick list of features to get a sense of what's available:
+
+* Various option types
+
+  * :class:`<flag-option>` for simple ``--boolean`` flags.
+  * :class:`<parameter-option>` for ``--foo=bar`` options.
+  * :class:`<repeated-parameter-option>` options may be repeated: ``-r a -r b``
+  * :class:`<optional-parameter-option>` in which the value is optional:
+    ``--foo`` or ``--foo bar``
+  * :class:`<keyed-option>` fills a table with key/value pairs, for example:
+    ``-Dk1=v1 -Dk2=v2``
+  * :class:`<choice-option>` the value may be chosen from a predefined set.
+  * :class:`<positional-option>` to receive positional arguments.
+
+* Automatic and extensible conversion of arguments to other types. For example,
+  an option with ``type: <integer>`` is automatically converted to integer by
+  the parser.
+* Subcommands
+* Automatic usage and ``--help`` generation.
+* A convenient and readable syntax for creating the command line.
+* Extensibility. Add your own argument converters with :gf:`parse-option-value`
+  or create entirely new option types.
+
+
+Quick Start
+===========
+
+The best way to build a command line parser is with
+:macro:`command-line-definer`, since it is far more concise and readable than
+building one "by hand" with ``make(<command-line-parser>, options: ...)``.  It
+also provides convenient methods to retrieve command-line option values rather
+than accessing them by name, with strings.
+
+.. note:: :macro:`command-line-definer` does not currently support subcommands.
+          If you need subcommands you will have to build the parser by hand for
+          now.
+
+Let's say you want to parse a command line that looks like this::
+
+  frob --name=zoo --debug -r a -r b -r c --choice=foo one two three
+
+The "frob" command accepts a ``--name`` option that takes a value, a boolean
+``--debug`` (or ``--nodebug``) a repeatable ``-r`` option, a ``--choice``
+option that accepts one of several values, and then at least one positional
+argument (here "one", "two", and "three").  Here's what that parser looks like:
+
+.. code-block:: dylan
+
+  define command-line <frob-command-line> ()
+    option frob-name :: <string>,
+      names: #("name"),
+      help: "Name of the frob",
+      kind: <parameter-option>;
+    option frob-debug? :: <boolean>,
+      names: #("debug"),
+      negative-names: #("nodebug"),
+      help: "Enable or disable debugging",
+      kind: <flag-option>;   // This is the default.
+    option frob-radicals :: <sequence>,
+      names: #("r"),
+      kind: <repeated-parameter-option>,
+      variable: "RAD",       // Makes --help show "-r RAD"
+      help: "Free radicals";
+    option frob-choice :: <string>,
+      names: #("choice"),
+      choices: #("foo", "bar", "baz"),
+      default: "foo",
+      help: "Your choice";
+    option frob-filenames :: <sequence>,
+      names: #("filenames"),
+      kind: <positional-option>,
+      repeated?: #t,
+      help: "One or more filenames";
+  end command-line;
+
+Now parse the command line:
+
+.. code-block:: dylan
+
+  block ()
+    let cmd = make(<frob-command-line>, help: "frob things");
+    parse-command-line(cmd, application-arguments());
+    // Now execute your main program code with cmd containing
+    // the parsed argument values.
+    frob(cmd);
+  exception (err :: <abort-command-error>)
+    // This condition is signaled by parse-command-line and also if
+    // your own code calls abort-command().
+    format-err("%s", err);
+    exit-application(err.exit-status);
+  end;
+
+To access the option values simply read the ``<frob-command-line>`` slot
+values. Assuming ``cmd`` is the command parsed above:
+
+.. code-block:: dylan
+
+   for (file in cmd.frob-filenames)
+     if (cmd.frob-debug?)
+       format-out(...);
+     end;
+     ...more...
+   end;
+
+Of course, it is also possible to make a command line parser without the macro
+above, but doing so is much more verbose and requires accessing the option
+values by calling ``get-option-value(cmd, "option-name")``. Briefly, just call
+:drm:`make`, like this:
+
+.. code-block:: dylan
+
+   let cmd
+     = make(<command-line-parser>,
+            help: "a most excellent program",
+            options: list(make(<flag-option>,
+                               names: #("name"),
+                               help: "provide a name"),
+                          ...,
+                          make(<positional-option>,
+                               names: #("filenames"),
+                               repeated?: #t,
+                               help: "one or more filenames")),
+            subcommands: list(make(<my-subcommand>, ...)));
+   parse-command-line(cmd, application-arguments());
+   let filenames = get-option-value(cmd, "filenames");
+   ...etc...
+
+
+Reference
+=========
+
+
+The command-line-parser Module
+------------------------------
+
+.. class:: <command>
+   :abstract:
+   :sealed:
+
+   Abstract superclass of :class:`<command-line-parser>` and
+   :class:`<subcommand>`.
+
+   :keyword options:
+
+      A sequence of :class:`<option>` instances. Note that
+      :class:`<positional-option>` instances must follow all other options, and
+      there may be only a single :class:`<positional-option>` that specifies
+      ``repeated?: #t`` and it must be the last option in the sequence.
+
+   :keyword help:
+
+      Required. A :drm:`<string>` to display when help is requested via the
+      ``--help`` option or the ``help`` subcommand.
+
+.. class:: <subcommand>
+   :open:
+   :abstract:
+
+   A named subcommand. Subcommands have their own set of command-line
+   options. They may not contain other subcommands.
+
+   :superclasses: :class:`<command>`
+
+   :keyword name: Required. The subcommand name, a :drm:`<string>`.
+
+   :description:
+
+      Subclass this for each subcommand you need and implement a method on
+      :gf:`execute-subcommand` for each subclass.
+
+.. class:: <command-line-parser>
+   :open:
+
+   Encapsulates a set of command-line options. May optionally contain a set of
+   subcommands, each of which has its own set of options.
+
+   :superclasses: :class:`<command>`
+
+   :keyword help-option?:
+
+      A boolean specifying whether the parser should automatically add the
+      default help option.  By default, help can be requested via ``--help`` or
+      ``-h``.  If false, no help option will be added to the parser, and you
+      must explicitly handle any request for help yourself. The default is
+      true. See :class:`<help-option>`.
+
+   :keyword help-subcommand?:
+
+      A boolean specifying whether the parser should automatically add the
+      default help subcommand. The default is true if the command-line has any
+      subcommands. Set to false if you prefer to call the subcommand something
+      else (e.g., non-English). See :class:`<help-subcommand>`.
+
+   :keyword subcommands: A sequence of :class:`<subcommand>`.
+
+.. class:: <help-subcommand>
+
+   Implements the ``help`` subcommand. Normally there is no need to use this
+   since the command line parser implements the ``help`` subcommand itself.
+   However, if you wanted to implement the ``help`` subcommand differently, or
+   just give it a different (or an additional) name, this is how to do it:
+
+   .. code-block:: dylan
+
+      define class <my-help-subcommand> (<help-subcommand>) end;
+
+      let p = make(<command-line-parser>,
+                   help-subcommand?: #f,
+                   ...
+                   subcommands: list(make(<my-help-subcommand>,
+                                          names: #("ayuda"))
+                                     ...));
+
+      define method execute-subcommand
+          (parser, sub :: <my-help-subcommand>) => (s :: false-or(<integer>))
+        ...etc...
+      end
+
+.. class:: <command-line-parser-error>
+   :open:
+
+   Superclass of all errors signaled by this library.
+
+   :superclasses: :class:`<format-string-condition>`, :drm:`<error>`
+
+.. class:: <abort-command-error>
+   :sealed:
+
+   Provides a standard way for program code to indicate that the application
+   should exit. Signaled by the command line parser itself after the standard
+   ``--help`` option or ``help`` subcommand have completed, so programs should
+   always handle this at top level.
+
+   :superclasses: :class:`<command-line-parser-error>`
+
+   :keyword status: Required. A status code to pass to
+                    :func:`exit-application`. An :drm:`<integer>`.
+
+   :description:
+
+     This is commonly handled by calling ``exit-application(err.exit-status)``
+     after printing the error.
+
+.. function:: exit-status
+
+   Returns the exit status associated with an error.
+
+   :parameter error: An instance of :class:`<abort-command-error>`
+   :value status: An instance of :drm:`<integer>`
+
+.. class:: <usage-error>
+   :open:
+
+   Signaled when a command-line cannot be parsed.
+
+   :superclasses: :class:`<abort-command-error>`
+
+   :description:
+
+     This is commonly handled by calling ``exit-application(err.exit-status)``.
+     This condition need not be handled specially if the application already
+     handles :class:`<abort-command-error>`.
+
+.. function:: add-option
+
+   Add an option to a command-line parser.
+
+   :signature: add-option (parser option) => ()
+   :parameter parser: An instance of :class:`<command-line-parser>`.
+   :parameter option: An instance of :class:`<option>`.
+   :description:
+
+     If any of the option names specified are already used by other
+     options then :class:`<command-line-parser-error>` is signaled.
+
+.. function:: parse-command-line
+
+   Parses the command line in ``argv`` and side-effects ``parser``
+   accordingly.
+
+   :signature: parse-command-line (parser argv) => ()
+   :parameter parser: An instance of :class:`<command-line-parser>`.
+   :parameter argv: An instance of :drm:`<sequence>`.  Normally the value
+     returned by :func:`application-arguments` is passed here.
+   :description:
+
+     By default, the ``--help`` flag and the "help" subcommand are handled
+     automatically by calling :gf:`print-synopsis` and then signaling
+     :class:`<abort-command-error>`, so the caller should handle that
+     condition.
+
+     If ``argv`` isn't a valid set of options as described by the
+     ``parser`` then :class:`<usage-error>`.
+
+     See `Quick Start`_ for an example.
+
+.. generic-function:: execute-command
+
+   When using subcommands, call this to execute the parsed command line.
+
+   :signature: execute-command (parser) => (false-or(<integer>))
+   :parameter parser: An instance of :class:`<command-line-parser>`.
+
+   :description:
+
+      Call this after calling :gf:`parse-command-line`, if your command-line
+      has subcommands. (If not using subcommands there is no need to call this;
+      just read option values from parser directly.) It determines the
+      subcommand indicated by the user and invokes :gf:`execute-subcommand` on
+      it. The ``help`` subcommand is handled specially.
+
+.. generic-function:: execute-subcommand
+
+   Implement a method on this generic for each subclass of
+   :class:`<subcommand>` you create.
+
+   :signature: execute-subcommand (parser subcommand) => (false-or(<integer>))
+   :parameter parser: An instance of :class:`<command-line-parser>`.
+   :parameter subcommand: An instance of :class:`<subcommand>`.
+
+   :description:
+
+      This is the implementation of your subcommand. Read command-line options
+      from ``subcommand`` and read global options (if any) from ``parser``.
+
+.. generic-function:: print-synopsis
+   :open:
+
+   Display a synopsis of the command line options.
+
+   :signature: print-synopsis (parser subcommand #key stream) => ()
+   :parameter parser: An instance of :class:`<command-line-parser>`.
+   :parameter subcommand: An instance of :class:`<subcommand>` or ``#f``.
+   :parameter #key stream: An instance of :class:`<stream>`.
+
+   :description:
+
+      It is not normally necessary to call this function since the ``--help``
+      option and ``help`` subcommand are handled automatically by the parser.
+
+.. function:: option-present?
+
+   Returns ``#t`` if this option was supplied on the command line.
+
+   :signature: option-present? (option) => (present?)
+   :parameter option: An instance of :class:`<option>`.
+   :value present?: An instance of :drm:`<boolean>`.
+   :description:
+
+     Returns ``#t`` if this option was supplied on the command line. Returns
+     ``#f`` if called before :func:`parse-command-line` has been called on the
+     associated parser, or if the option wasn't supplied on the command line.
+
+.. function:: option-value
+
+   Returns the parsed value of the option supplied on the command line.
+
+   :signature: option-value (option) => (value)
+   :parameter option: An instance of :class:`<option>`.
+   :value value: An instance of :drm:`<object>`.
+   :description:
+
+     Returns the parsed value of the option supplied on the command line.  If
+     no value was supplied on the command line it returns the value specified
+     with ``default:`` when the option was created, which in turn defaults to
+     ``#f``.
+
+     Note that the type of the return value is specified by the ``type:``
+     keyword argument when the option was created and the string supplied on
+     the command line is converted to that type by a method on
+     :gf:`parse-option-value`.
+
+.. function:: get-option-value
+
+   Retrieves an option from a :class:`<command>` by name.
+
+   :signature: get-option-value (parser name) => (value)
+
+   :parameter parser: An instance of :class:`<command>`.
+   :parameter name: An instance of :drm:`<string>`.
+   :value value: An instance of :drm:`<object>`.
+
+.. generic-function:: parse-option-value
+   :open:
+
+   Convert a command line argument from a :drm:`<string>` to the
+   :class:`<option>` type.
+
+   :signature: parse-option-value (argument, type) => (value)
+   :parameter argument: An instance of :drm:`<string>`.
+   :parameter type: An instance of :drm:`<type>`.
+   :value value: An instance of :drm:`<object>`.
+
+   :description:
+
+      Convert a command-line argument (a string) to the type specified in the
+      corresponding :class:`<option>` instance. For example, given the
+      following code, the "version" option's :gf:`option-value` slot would be
+      set to an instance of ``<version>`` by the command line parser so that
+      you don't have to manually do it in your application.
+
+      .. code-block:: dylan
+
+         make(<parameter-option>,
+              names: #("version"),
+              help: "A version specifier. Ex: v1.2.3",
+              type: <version>)
+
+         define method parse-option-value
+             (arg :: <string>, type == <version>)
+          => (v :: <version>)
+           parse-version(arg)
+         end;
+
+      There are predefined methods that convert to :drm:`<number>`,
+      :drm:`<boolean>`, :drm:`<symbol>`, and :drm:`<sequence>`. For
+      :drm:`<boolean>`, valid values are yes/no, on/off, true/false.
+      For :drm:`<sequence>`, strings are simply split around commas,
+      without any attempt to be smart about quoting.
+
+
+Option Classes
+~~~~~~~~~~~~~~
+
+.. class:: <option>
+   :abstract:
+   :open:
+
+   Superclass of all other option types.
+
+   :superclasses: :drm:`<object>`
+
+   :keyword names:
+
+     Names for this option; a sequence of strings.  For convenience a single
+     string may be given if the option only has one name.  Strings of length 1
+     are considered to be short options, i.e., they are prefixed by a single
+     dash on the command line.
+
+     The first name in the list is considered the "canonical" name of the
+     option and is used in various parts of the auto-generated ``--help``
+     message.
+
+   :keyword type:
+
+     The kind of value represented by this option.  That is, the string passed
+     on the command line will be coerced to this type via
+     :gf:`parse-option-value` if a relevant method exists.  Clients may
+     implement methods on that function for their own types to extend the
+     parser.
+
+     Predefined types include :drm:`<integer>`, ``subclass(<float>)``,
+     ``subclass(<sequence>)``.
+
+   :keyword help:
+
+     A string documenting the option.  Displayed in ``--help`` output.
+     Some automatic substitutions are performed:
+
+       1. "%default%" => The string representation of the default value
+          for the option.
+
+       2. "%app%" => The basename of the executable program.
+
+     For example, given this option specification:
+
+     .. code-block:: dylan
+
+        make(<parameter-option>,
+             names: #("v", "version"),
+             help: "Package version [%default%]",
+             default: "latest")
+
+     it will be displayed as::
+
+       --version V   Package version [latest]
+
+   :keyword variable:
+
+     A string to stand in for the option value in ``--help`` output.
+     For example, if the option name is ``--database`` this might be
+     "URL", which would display as::
+
+       --database URL  A database URL.
+
+     When not specified, the first name of the option is used. For example:
+
+     .. code-block:: dylan
+
+        make(<parameter-option>,
+             names: #("n", "name"),
+             help: "A name")
+
+     And on the command-line this will be displayed as::
+
+       -n, --name N   A name
+
+   :keyword default:
+
+     A default value for the option that will be used if the option isn't
+     specified by the user. The default value should be a member of the type
+     specified with the ``type:`` keyword. ``#f`` is the default default value.
+
+.. class:: <flag-option>
+   :sealed:
+
+   Defines a simple flag option, i.e., one that specifies a boolean value.
+
+   :superclasses: :class:`<option>`
+
+   :keyword negative-names:
+
+     Same as ``names``, but specifies the negative forms.
+
+   :description:
+
+     They default to ``#f`` and may exist in both positive and negative forms:
+     ``--foo`` and ``--no-foo``.  In the case of conflicting options, the
+     rightmost takes precedence to allow for abuse of the shell's "alias"
+     command.
+
+     For example, a single instance of this class could be used to specify
+     *all* of the following command-line options::
+
+         -q, -v, --quiet, --verbose
+
+
+.. class:: <parameter-option>
+   :sealed:
+
+   Defines an option that requires a value be specified.
+
+   :superclasses: :class:`<option>`
+
+   :description:
+
+     If the option appears more than once, the rightmost value takes
+     precedence. If the option never appears, these will default to
+     ``#f``.
+
+     Examples::
+
+       -cred, -c=red, -c = red, --color red, --color=red
+
+
+.. class:: <optional-parameter-option>
+   :sealed:
+
+   Similar to :class:`<parameter-option>`, but the parameter is
+   optional.
+
+   :superclasses: :class:`<option>`
+
+   :description:
+
+     The parameter must directly follow the option with no intervening
+     whitespace, or follow an "=" token. The value is ``#f`` if the option
+     never appears, ``#t`` if the option appears but the parameter does
+     not, and the value of the parameter otherwise.
+
+     Examples::
+
+       -z, -z3, -z=3, -z = 3, --zip, --zip=3, --zip = 3
+
+     Invalid examples::
+
+       -z 3, --zip 3, --zip3
+
+.. class:: <repeated-parameter-option>
+   :sealed:
+
+   Similar to :class:`<parameter-option>`, but may appear more than
+   once.
+
+   :superclasses: :class:`<option>`
+
+   :description:
+
+     The final value is a deque of parameter values in the order they
+     appeared on the command line. It defaults to the empty deque.
+
+     Examples::
+
+       -wall, -w=all, -w = all, --warnings all, --warnings=all
+
+
+.. class:: <choice-option>
+   :sealed:
+
+   Similar to :class:`<parameter-option>`, but provides a restricted
+   set of values to choose from.
+
+   :superclasses: :class:`<parameter-option>`
+
+   :keyword choices:
+
+     A sequence of objects (usually strings).  If the value supplied
+     on the command line isn't one of these objects then
+     :class:`<usage-error>` is signaled.  If you supply a sequence of
+     non-string choices you will also need to supply the ``test:``
+     init keyword since all command-line arguments are strings and
+     won't compare equal with the default test, ``=``.
+
+   :keyword test:
+
+     A function to test whether the value supplied on the command line
+     is the same as one of the choices.  The default is ``=``.  Another
+     commonly used value is ``string-equal-ic?``, to ignore case in the
+     comparison.
+
+   :description:
+
+     Example::
+
+       make(<choice-option>,
+            names: #("foo"),
+            help: "a or b",
+            choices: #("a", "b"),
+            test: string-equal-ic?)
+
+
+.. class:: <keyed-option>
+   :sealed:
+
+   Each occurrence of this type of option defines a key => value
+   mapping.
+
+   :superclasses: :class:`<option>`
+
+   :description:
+
+     These are a bit obscure. The best example is gcc's ``-D`` option.
+     The final value is a :class:`<string-table>` containing each specified
+     key, with one of the following values:
+
+     * ``#t``: The user specified "-Dkey"
+     * a string: The user specified "-Dkey=value"
+
+     You can read this with ``element(table, key, default: #f)`` to get a
+     handy lookup table.
+
+     Examples::
+
+       -Dkey, -Dkey=value, -D key = value, --define key = value
+
+.. class:: <positional-option>
+   :sealed:
+
+   Accepts an argument that is passed by possition on the command line.
+
+   :superclasses: :class:`<option>`
+
+   :description:
+
+      If you want your command-line parser to accept positional arguments you
+      must add :class:`<positional-option>` instances to it. Positional options
+      must come after all non-positional options.
+
+      By default, positional options are marked as required but you may pass
+      ``required?: #f`` to make them optional. *Note that it is an error to add
+      a required positional option after an optional positional option since
+      there is no way to parse that unambiguously.*
+
+      A :class:`<positional-option>` may be marked as accepting any number of
+      arguments by passing ``repeated?: #t`` when calling :drm:`make`. An
+      option marked as repeated *must* be the last option in the parser's list
+      of options.
+
+      In this example the command line requires one filename to be passed on
+      the command line, and one or more words after that:
+
+      .. code-block:: dylan
+
+         add-option(parser, make(<positional-option>,
+                                 names: #("filename"),
+                                 help: "A filename"));
+         add-option(parser, make(<positional-option>,
+                                 names: #("words"),
+                                 help: "One or more words",
+                                 repeated?: #t));
+
+         // Usage: app [options] FILENAME WORDS...
+
+.. class:: <help-option>
+   :open:
+
+   The standard ``--help`` option.
+
+   :superclasses: :class:`<flag-option>`
+
+   :description:
+
+      May be subclassed if you want to implement your own help option instead
+      of the default one.
+
+
+The option-parser-protocol Module
+---------------------------------
+
+This module exports an API that can be used to extend the existing command line
+parser without modifying the source in this library.  It shouldn't be common to
+need this and it is likely to be incomplete.  See the source code for details.
diff --git a/documentation/sphinx-extensions b/documentation/sphinx-extensions
new file mode 160000
index 0000000..9abbc14
--- /dev/null
+++ b/documentation/sphinx-extensions
@@ -0,0 +1 @@
+Subproject commit 9abbc14a5cb51391f3ae2fdec004312fb9c4ea72
diff --git a/pkg.json b/dylan-package.json
similarity index 51%
rename from pkg.json
rename to dylan-package.json
index 8a59b7a..dd4ce5d 100644
--- a/pkg.json
+++ b/dylan-package.json
@@ -1,16 +1,15 @@
 {
     "name": "command-line-parser",
     "description": "Parse command line flags and subcommands",
-    "version": "3.1.0",
+    "version": "3.2.0",
     "url": "https://github.com/dylan-lang/command-line-parser",
     "category": "utilities",
     "contact": "dylan-lang@googlegroups.com",
     "keywords": ["cli", "flags"],
-    "deps": [
+    "dependencies": [
         "strings@1.0"
-        # Testworks depends on command-line-parser so we can't depend on it here.
-        # Instead, we rely on it being picked up from the Open Dylan submodule.
-        # https://github.com/dylan-lang/pacman/issues/17
-        # "testworks@2.0"
+    ],
+    "dev-dependencies": [
+        "testworks@2.0"
     ]
 }
diff --git a/ext/strings b/ext/strings
index e646696..d65a723 160000
--- a/ext/strings
+++ b/ext/strings
@@ -1 +1 @@
-Subproject commit e646696389ea62daa9b15c33d1ea891aa1c51200
+Subproject commit d65a723edf769a8809f1ba394a86f76f973f7c9d
diff --git a/ext/testworks b/ext/testworks
index 6cd4ff3..9f9165e 160000
--- a/ext/testworks
+++ b/ext/testworks
@@ -1 +1 @@
-Subproject commit 6cd4ff38af3c7d895e36a5ee25215da8edc0b833
+Subproject commit 9f9165e3f0fb72b0775ca7b7096ad33f1eaab2d4