This is SimpleDoc.info, produced by Macaulay2, version 1.21

SimpleDoc -- simpler documentation for functions and methods
************************************************************

Description
===========

This package provides a simple, human-readable text format for documentation
nodes as an alternative to the classic hypertext list format (Macaulay2Doc),
accepted by the document(List) (Macaulay2Doc),
function.

The new format is accepted by the doc(String), function for writing
either a single or multiple documentation nodes from a string or file and
adheres to the off-side rule (see https://en.wikipedia.org/wiki/off-side_rule
), i.e., using indentation to separate blocks.

Getting started with SimpleDoc
------------------------------

  * Writing documentation in Macaulay2 (Macaulay2Doc)
  * Using SimpleDoc for documentation
  * Using markup in documentation (Text)
  * Using TeX in documentation (Text)

Templates for using the doc(String), method
------------------------------------------------------

  * docExample -- an example of a documentation string
  * docTemplate -- a simple documentation function
  * packageTemplate -- a template for a package

Documentation helpers
---------------------

  * arXiv -- link to an arXiv article
  * stacksProject -- link to a Stacks Project tag
  * wikipedia -- link to a Wikipedia article

Contributors
============

Andrew Hoefel contributed to this package.

Authors
=======

  * Daniel R. Grayson (see https://faculty.math.illinois.edu/~dan/ )
    <dan@math.uiuc.edu>
  * Mike Stillman (see https://pi.math.cornell.edu/~mike/ )
    <mike@math.cornell.edu>
  * Mahrud Sayrafi (see https://math.umn.edu/~mahrud/ ) <mahrud@umn.edu>

Version
=======

This documentation describes version 1.2 of SimpleDoc.

Source code
===========

The source code from which this documentation is derived is in the file
SimpleDoc.m2 (see common/share/Macaulay2/SimpleDoc.m2 ). The auxiliary files
accompanying it are in the directory SimpleDoc/ (see
common/share/Macaulay2/SimpleDoc/ ).

Exports
=======

  * Functions and commands
      * arXiv -- link to an arXiv article
      * doc -- a simple documentation function
      * "multidoc" -- see doc, -- a simple documentation function
      * packageTemplate -- a template for a package
      * simpleDocFrob -- a sample documentation node
      * stacksProject -- link to a Stacks Project tag
      * wikipedia -- link to a Wikipedia article
  * Methods
      * "arXiv(String)" -- see arXiv, -- link to an arXiv article
      * "arXiv(String,String)" -- see arXiv, -- link to an arXiv
        article
      * "doc(String)" -- see doc, -- a simple documentation function
      * "packageTemplate(String)" -- see packageTemplate,
        -- a template for a package
      * "simpleDocFrob(ZZ,Matrix)" -- see simpleDocFrob,
        -- a sample documentation node
      * "stacksProject(String,String)" -- see stacksProject,
        -- link to a Stacks Project tag
      * "wikipedia(String)" -- see wikipedia, -- link to a
        Wikipedia article
      * "wikipedia(String,String)" -- see wikipedia, -- link
        to a Wikipedia article
  * Other things
      * docExample -- an example of a documentation string
      * docTemplate -- a simple documentation function
      * testExample -- an example of a test string

For the programmer
==================

The object SimpleDoc, is a package (Macaulay2Doc).

arXiv -- link to an arXiv article
*********************************

Synopsis
========

  * Usage:
        arXiv ref
        arXiv(ref, title)
  * Inputs:
      * ref, a string (Macaulay2Doc), an arXiv identifier
        "YYMM.NNNNN" or "math/YYMMNNN"
      * title, a string (Macaulay2Doc), the link title, optional
  * Outputs:
      * a markup list (Text), a link to the abstract of the
        article with the given identifier, usable inside a documentation node

Description
===========

+-----------------------------------------------------------------------------+
|i1 : arXiv "1411.5724"                                                       |
|                                                                             |
|o1 = arXiv:1411.5724 (see https://arxiv.org/abs/1411.5724 )                  |
|                                                                             |
|o1 : HREF                                                                    |
+-----------------------------------------------------------------------------+
|i2 : html oo                                                                 |
|                                                                             |
|o2 = <a href="https://arxiv.org/abs/1411.5724">arXiv:1411.5724</a>           |
+-----------------------------------------------------------------------------+
|i3 : arXiv("math/0003033", "Macaulay2 and the geometry of schemes")          |
|                                                                             |
|o3 = Macaulay2 and the geometry of schemes (see https://arxiv.org/abs/math/  |
|                                                                             |
|o3 : HREF                                                                    |
|-----------------------------------------------------------------------------|
|0003033 )                                                                    |
+-----------------------------------------------------------------------------+
|i4 : html oo                                                                 |
|                                                                             |
|o4 = <a href="https://arxiv.org/abs/math/0003033">Macaulay2 and the geometry |
|     of schemes</a>                                                          |
+-----------------------------------------------------------------------------+

See also
========

  * document (Macaulay2Doc) -- create a documentation node
  * stacksProject -- link to a Stacks Project tag
  * wikipedia -- link to a Wikipedia article

Ways to use arXiv :
===================

  * "arXiv(String)"
  * "arXiv(String,String)"

For the programmer
==================

The object arXiv, is a method function (Macaulay2Doc).

doc -- a simple documentation function
**************************************

Synopsis
========

  * Usage:
        doc s
        document s
  * Inputs:
      * s, a string (Macaulay2Doc), a structured source for the
        documentation, either as a string or a filename
  * Consequences:
      * Documentation is created and stored so that after installPackage (Macaulay2Doc),
        is used, see help (Macaulay2Doc),
        and viewHelp (Macaulay2Doc), can be used to access the
        corresponding documentation node(s)

Description
===========

The string s contains a series of sections describing the documentation to be
produced. The first line of each section contains only a keyword that specifies
the purpose of that section. The keywords must all be indented to the same
level, and everything else must be further indented. Lines beginning with white
space followed by two hyphens are ignored and can be used for commenting.

document(String) (missing documentation) is a synonym for doc. For
backwards compatibility, the function multidoc is also a synonym for doc.

Template for documentation strings
==================================

The variable docTemplate is a String (Macaulay2Doc), which can be
cut and pasted into a text file, to be used as a template for writing
documentation for functions and other objects in a package.

+---------------+
|               |
|doc ///        |
|Key            |
|Headline       |
|Usage          |
|Inputs         |
|Outputs        |
|Consequences   |
|  Item         |
|Description    |
|  Text         |
|  Tree         |
|  Code         |
|  Pre          |
|  Example      |
|  CannedExample|
|ExampleFiles   |
|Acknowledgement|
|Contributors   |
|References     |
|Caveat         |
|SeeAlso        |
|Subnodes       |
|///            |
+---------------+

Description of keywords allowed in documentation strings
========================================================

The only keyword which is always required is Key (Macaulay2Doc).
Other valid keywords are:

  * Key (Macaulay2Doc) -- key of a documentation node

    Each line in this section is evaluated as a Macaulay2 expression to yield a
    documentation key. If the key is a string, for instance the title of a
    tutorial, it must be surrounded by quotation marks. Examples for
    documentation keys are given in document(...,Key=>...) (Macaulay2Doc).
  * Headline (Macaulay2Doc) -- headline of a documentation node

    The body of this section should be a single line description of the node.
  * Usage (Macaulay2Doc) -- ways to use a function in a
    documentation node

    The lines of this section present alternative usages of the key.
  * Inputs (Macaulay2Doc) -- inputs for a function in a
    documentation node
    Outputs (Macaulay2Doc), -- outputs for a function in a
    documentation node

    The text in these sections is divided into subsections, each of which
    corresponds to one input or output value. The first line of each subsection
    contains the name of the variable corresponding to it, as referred to in
    the usage line, a colon, and the type of the variable. The name of the
    variable must be a nonempty string of alphanumeric characters or quotation
    marks.  For example, the first line might be s2:String.  The variable name
    and type are both optional.

    For optional inputs, one puts the name of the option, a double arrow, and
    the expected type of value; for example, the first line might be
    Precision=>ZZ. Subsequent lines of the subsection, indented further,
    describe the variable and may include markup.
  * Consequences (Macaulay2Doc) -- side-effects of a
    function in a documentation node

    Each subsection of the this section should start with the keyword Item; the
    text in each item may include markup.
  * Description

    The text in this section occurs in subsections with keywords:

      * Text -- prose containing markup or tex

        The text in this subsection can be separated into paragraphs with blank
        lines. A paragraph, when rendered in HTML, is typically enclosed in an
        HTML <p> tag, except if its top level markup is an instance of
        HypertextContainer (Text), or
        HypertextParagraph (Text).
      * Tree -- classify documentation nodes under headings

        The lines in this section beginning with : or @ are treated as
        subsections. The remaining lines are treated as keys to a documentation
        node and are processed by the TOH (Text), function, producing
        a link followed by the headline. The purpose is to allow a
        classification of the documentation nodes grouped under a subsections.
        Further indentation is treated as further sub-classifications.
      * Example -- examples of the usage

        The text in this subsection consists of lines of Macaulay2 code to be
        used as examples in the documentation node. Output will be generated
        automatically and incorporated into the display.
      * CannedExample -- pre-evaluated example results

        The text in this subsection consists of lines containing an interaction
        with Macaulay2, to displayed as an example.
      * Pre -- preformatted text

        The text in this subsection, with common indentation removed, is
        wrapped with PRE (Text).
      * Code -- custom Macaulay2 code

        The text in this subsection, with common indentation removed, is
        wrapped with parentheses and evaluated; the result is spliced into the
        list of documentation items at the appropriate point before passing the
        list to document (Macaulay2Doc).
  * Synopsis -- prepare documentation for different usages of a function

    Each section with this keyword prepares a standardized synopsis similar to
    the SYNOPSIS (Macaulay2Doc), template of the classic
    document (Macaulay2Doc), command. The text in this section occurs
    in subsections with the following keywords:

      * Heading (Macaulay2Doc) -- similar to the
        Headline (Macaulay2Doc), keyword
      * BaseFunction (Macaulay2Doc) -- the basename of the
        function; see SYNOPSIS(...,BaseFunction=>...) (Macaulay2Doc),
      * Keywords that can be repeated once for each synopsis: Usage (Macaulay2Doc),
        (required), see Inputs (Macaulay2Doc),
        Outputs (Macaulay2Doc), Consequences (Macaulay2Doc),
        and Description (missing documentation).

  * Acknowledgement (Macaulay2Doc) -- acknowledgements
    listed in a documentation node
    Contributors (Macaulay2Doc), -- non-author contributors
    listed in a documentation node
    References (Macaulay2Doc), -- references listed in a
    documentation node

    The text in these sections is parsed and rendered similar to the
    Text, subsection and can be used to acknowledge funding sources,
    collaborators, and non-author contributors, or to provide references.
  * Caveat (Macaulay2Doc) -- warnings or limitations listed in a
    documentation node

    The text in these sections is parsed and rendered similar to the
    Text, subsection and can be used to inform users of potential
    limits of the implementation.
  * SeeAlso (Macaulay2Doc) -- cross-references to other
    documentation nodes

    The lines in this section are parsed as in the Key (Macaulay2Doc),
    section and are displayed as links to other relevant
    documentation nodes.
  * Subnodes (Macaulay2Doc) -- a menu of documentation nodes

    The lines in this section not beginning with a colon are keys giving links
    to the subnodes of the current documentation node. The purpose is to allow
    the documentation of the package to be arranged linearly, as in a book.
    The lines beginning with a colon are subheadings used to classify the
    subnodes.
  * SourceCode (Macaulay2Doc) -- sources displayed in a
    documentation node

    The lines in this section are parsed as a list of functions whose source
    code should be displayed in the documentation.
  * ExampleFiles (Macaulay2Doc) -- data files corresponding
    to a documentation node

    Each line in this section should be the name of a file in the auxiliary
    files directory of the package; the name of that directory is the same as
    the name of the package.  Copies of the corresponding files will be made
    available in the running path of the examples.

Markup keywords allowed in documentation strings
================================================

The markup keywords allowed include many TeX commands, as allowed in TEX (Text),;
for details and examples see html(TEX) (Text),
allowing various mathematical expressions, such as $\PP^3$ or $x_i^{33} + 1/2$,
to be displayed in the html form of the documentation.

Also allowed is a pair of @ characters, enclosing Macaulay2 code to be
executed, yielding appropriate hypertext.  For example

The @TO Key@ section is required.

will include a link to another node of the documentation. This package also
provides a number of helper functions, such as the arXiv,
function, which may be used to succinctly reference e-Prints. See Text,
for other hypertext types.

Note that any Macaulay2 code resulting in a String (Macaulay2Doc),
or Hypertext (Text), may be used inside @...@, but for longer
code it is easier to use the Code keyword described above.

Documenting multiple nodes at once
==================================

If the least indented keyword in the documentation string s is Node, possibly
occurring multiple times, multiple documentation nodes will be prepared.

  * Node

    The text following each such keyword is handled just as by doc,
    resulting in a separate documentation node.

See SimpleDoc/doc.txt (see common/share/Macaulay2/SimpleDoc/doc.txt ) for an
example of how the Node keyword is used in documenting this package.

See also
========

  * document (Macaulay2Doc) -- create a documentation node
  * testExample -- an example of a test string
  * docExample -- an example of a documentation string

Ways to use doc :
=================

  * "doc(String)"

For the programmer
==================

The object doc, is a method function (Macaulay2Doc).

docExample -- an example of a documentation string
**************************************************

Synopsis
========

  * Usage:
        docExample

Description
===========

The variable docExample is a String (Macaulay2Doc), containing an
example of the use of doc(String), to write a documentation page,
visible here.

+-----------------------------------------------------------------------------+
|doc ///                                                                      |
|  Key                                                                        |
|     simpleDocFrob                                                           |
|    (simpleDocFrob, ZZ, Matrix)                                              |
|    [simpleDocFrob, Limit]                                                   |
|  Headline                                                                   |
|    a sample documentation node                                              |
|  Usage                                                                      |
|    x = simpleDocFrob(n,M)                                                   |
|  Inputs                                                                     |
|    n:ZZ         -- positive                                                 |
|    M:Matrix     -- which is square                                          |
|    Limit => ZZ  -- as an @TO Option@                                        |
|     multiline descriptions                                                  |
|     are sometimes useful                                                    |
|  Outputs                                                                    |
|    x:Matrix                                                                 |
|      A block diagonal matrix with {\tt n}                                   |
|      copies of {\tt M} along the diagonal                                   |
|  Consequences                                                               |
|   Item                                                                      |
|    The first side effect of the function, if any, is described here.        |
|   Item                                                                      |
|    The second side effect of the function is described here, and so on.     |
|  Description                                                                |
|   Text                                                                      |
|     Each paragraph of text begins with "Text".  The following               |
|     line starts a sequence of Macaulay2 example input lines.                |
|                                                                             |
|     The output in the following example was automatically generated at the  |
|     of package installation.                                                |
|   Example                                                                   |
|     M = matrix"1,2;3,4";                                                    |
|     simpleDocFrob(3,M)                                                      |
|   Text                                                                      |
|     @SUBSECTION "A new section"@                                            |
|                                                                             |
|     The following example was generated by the documentation author.        |
|   CannedExample                                                             |
|      i1 : 4+                                                                |
|           4                                                                 |
|                                                                             |
|      o1 = 8                                                                 |
|                                                                             |
|      i1000 : 2+2                                                            |
|                                                                             |
|      o1000 = 4                                                              |
|   Text                                                                      |
|     See @ TO "docExample" @ for the code used to create this documentation. |
|                                                                             |
|  Synopsis                                                                   |
|   Heading                                                                   |
|    a different way to use this method                                       |
|   Usage                                                                     |
|    simpleDocFrom_n M                                                        |
|   Inputs                                                                    |
|    :ZZ                                                                      |
|    :Matrix                                                                  |
|   Outputs                                                                   |
|    :Matrix                                                                  |
|   Consequences                                                              |
|    Item                                                                     |
|     There may be specific consequences.                                     |
|   Description                                                               |
|    Text                                                                     |
|     Paragraph specific to this usage.                                       |
|     Itemized lists can be created with the "Tree" keyword:                  |
|    Tree                                                                     |
|     :A heading                                                              |
|       "Macaulay2Doc :: matrix(List)"                                        |
|       :A subheading containing @TT "Hypertext"@                             |
|         ZZ                                                                  |
|         Matrix                                                              |
|     :Another heading                                                        |
|       @TO2 {"Macaulay2Doc :: matrix(List)", "A link with arbitrary headline |
|                                                                             |
|  Acknowledgement                                                            |
|    Acknowledge funding sources or collaborators here.                       |
|  Contributors                                                               |
|    Acknowledge contributors who are not listed as authors here.             |
|  References                                                                 |
|    Provide references for further reading.                                  |
|  Caveat                                                                     |
|    This is not a particularly useful function.                              |
|  SeeAlso                                                                    |
|    matrix                                                                   |
|    "Macaulay2Doc :: directSum(List)"                                        |
|///                                                                          |
|-----------------------------------------------------------------------------|
|time                                                                         |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|"}@.                                                                         |
+-----------------------------------------------------------------------------+

See also
========

  * packageTemplate -- a template for a package
  * testExample -- an example of a test string

For the programmer
==================

The object docExample, is a string (Macaulay2Doc).

packageTemplate -- a template for a package
*******************************************

Synopsis
========

  * Usage:
        packageTemplate name
  * Inputs:
      * name, a string (Macaulay2Doc), the name of the package

Description
===========

This routine returns a barebones package template that can be used to start
writing a package.

+------------------------------------------------------------+
|i1 : print packageTemplate "WonderfulModules"               |
|newPackage(                                                 |
|    "WonderfulModules",                                     |
|    Version => "0.1",                                       |
|    Date => "",                                             |
|    Headline => "",                                         |
|    Authors => {{ Name => "", Email => "", HomePage => ""}},|
|    AuxiliaryFiles => false,                                |
|    DebuggingMode => false                                  |
|    )                                                       |
|                                                            |
|export {}                                                   |
|                                                            |
|-* Code section *-                                          |
|                                                            |
|                                                            |
|-* Documentation section *-                                 |
|beginDocumentation()                                        |
|                                                            |
|doc ///                                                     |
|Key                                                         |
|  WonderfulModules                                          |
|Headline                                                    |
|Description                                                 |
|  Text                                                      |
|  Tree                                                      |
|  Example                                                   |
|  CannedExample                                             |
|Acknowledgement                                             |
|Contributors                                                |
|References                                                  |
|Caveat                                                      |
|SeeAlso                                                     |
|Subnodes                                                    |
|///                                                         |
|                                                            |
|doc ///                                                     |
|Key                                                         |
|Headline                                                    |
|Usage                                                       |
|Inputs                                                      |
|Outputs                                                     |
|Consequences                                                |
|  Item                                                      |
|Description                                                 |
|  Text                                                      |
|  Example                                                   |
|  CannedExample                                             |
|  Code                                                      |
|  Pre                                                       |
|ExampleFiles                                                |
|Contributors                                                |
|References                                                  |
|Caveat                                                      |
|SeeAlso                                                     |
|///                                                         |
|                                                            |
|-* Test section *-                                          |
|TEST /// -* [insert short title for this test] *-           |
|-- test code and assertions here                            |
|-- may have as many TEST sections as needed                 |
|///                                                         |
|                                                            |
|end--                                                       |
|                                                            |
|-* Development section *-                                   |
|restart                                                     |
|debug needsPackage "WonderfulModules"                       |
|check "WonderfulModules"                                    |
|                                                            |
|uninstallPackage "WonderfulModules"                         |
|restart                                                     |
|installPackage "WonderfulModules"                           |
|viewHelp "WonderfulModules"                                 |
+------------------------------------------------------------+

See also
========

  * docExample -- an example of a documentation string
  * testExample -- an example of a test string

Ways to use packageTemplate :
=============================

  * "packageTemplate(String)"

For the programmer
==================

The object packageTemplate, is a method function (Macaulay2Doc).

simpleDocFrob -- a sample documentation node
********************************************

Synopsis
========

  * Usage:
        x = simpleDocFrob(n,M)
  * Inputs:
      * n, an integer (Macaulay2Doc), positive;
      * M, a matrix (Macaulay2Doc), which is square;
  * Optional inputs (Macaulay2Doc),:
      * Limit => an integer (Macaulay2Doc), default value 0, as an
        Option (Macaulay2Doc),; multiline descriptions are
        sometimes useful
  * Outputs:
      * x, a matrix (Macaulay2Doc), A block diagonal matrix with
        n copies of M along the diagonal
  * Consequences:
      * The first side effect of the function, if any, is described here.
      * The second side effect of the function is described here, and so on.

Description
===========

Each paragraph of text begins with "Text".  The following line starts a
sequence of Macaulay2 example input lines.

The output in the following example was automatically generated at the time of
package installation.

+-------------------------+
|i1 : M = matrix"1,2;3,4";|
|                         |
|              2        2 |
|o1 : Matrix ZZ  <--- ZZ  |
+-------------------------+
|i2 : simpleDocFrob(3,M)  |
|                         |
|o2 = | 1 2 0 0 0 0 |     |
|     | 3 4 0 0 0 0 |     |
|     | 0 0 1 2 0 0 |     |
|     | 0 0 3 4 0 0 |     |
|     | 0 0 0 0 1 2 |     |
|     | 0 0 0 0 3 4 |     |
|                         |
|              6        6 |
|o2 : Matrix ZZ  <--- ZZ  |
+-------------------------+

A new section
=============

The following example was generated by the documentation author.

+-----------+
|i1 : 4+    |
|     4     |
|           |
|o1 = 8     |
+-----------+
|i1000 : 2+2|
|           |
|o1000 = 4  |
+-----------+

See docExample, for the code used to create this
documentation.

a different way to use this method
==================================

  * Usage:
        simpleDocFrom_n M
  * Inputs:
      * an integer (Macaulay2Doc),
      * a matrix (Macaulay2Doc),
  * Outputs:
      * a matrix (Macaulay2Doc),
  * Consequences:
      * There may be specific consequences.

Paragraph specific to this usage. Itemized lists can be created with the "Tree"
keyword:

A heading
---------

  * matrix(List) (Macaulay2Doc) -- create a matrix from
    a doubly-nested list of ring elements or matrices
  * A subheading containing Hypertext
      * ZZ (Macaulay2Doc) -- the class of all integers
      * Matrix (Macaulay2Doc) -- the class of all matrices

Another heading
---------------

  * A link with arbitrary headline (Macaulay2Doc).

Acknowledgement
===============

Acknowledge funding sources or collaborators here.

Contributors
============

Acknowledge contributors who are not listed as authors here.

References
==========

Provide references for further reading.

Caveat
======

This is not a particularly useful function.

See also
========

  * matrix (Macaulay2Doc) -- make a matrix
  * directSum(List) (Macaulay2Doc) -- direct sum of modules or
    maps

Ways to use simpleDocFrob :
===========================

  * "simpleDocFrob(ZZ,Matrix)"

For the programmer
==================

The object simpleDocFrob, is a method function with options (Macaulay2Doc).

stacksProject -- link to a Stacks Project tag
*********************************************

Synopsis
========

  * Usage:
        stacksProject(tag, description)
  * Inputs:
      * tag, a string (Macaulay2Doc), an alphanumeric Stacks
        Project tag of the form "TTTT"
      * title, a string (Macaulay2Doc), the link title
  * Outputs:
      * a markup list (Text), a link to the Stacks Project
        node with the given tag, usable inside a documentation node

Description
===========

+---------------------------------------------------------------------------+
|i1 : stacksProject("01HR", "Affine schemes")                               |
|                                                                           |
|o1 = Affine schemes (see https://stacks.math.columbia.edu/tag/01HR )       |
|                                                                           |
|o1 : HREF                                                                  |
+---------------------------------------------------------------------------+
|i2 : html oo                                                               |
|                                                                           |
|o2 = <a href="https://stacks.math.columbia.edu/tag/01HR">Affine schemes</a>|
+---------------------------------------------------------------------------+

See also
========

  * document (Macaulay2Doc) -- create a documentation node
  * arXiv -- link to an arXiv article
  * wikipedia -- link to a Wikipedia article

Ways to use stacksProject :
===========================

  * "stacksProject(String,String)"

For the programmer
==================

The object stacksProject, is a method function (Macaulay2Doc).

testExample -- an example of a test string
******************************************

Synopsis
========

  * Usage:
        testExample

Description
===========

The variable testExample is a String (Macaulay2Doc), containing an
example of the use of TEST(String) (Macaulay2Doc), to write a test
case.

+-----------------------------------------------------------------------+
|                                                                       |
|TEST /// -* test for simpleDocFrob *-                                  |
|  assert(simpleDocFrob(2,matrix{{1,2}}) == matrix{{1,2,0,0},{0,0,1,2}})|
|///                                                                    |
+-----------------------------------------------------------------------+

The check (Macaulay2Doc), method executes all package tests defined
this way.

+-----------------------------------------------------------------------------+
|i1 : check SimpleDoc                                                         |
| -- capturing check(0, "SimpleDoc")                                          |
|-----------------------------------------------------------------------------|
|-- 0.205753 seconds elapsed                                                  |
+-----------------------------------------------------------------------------+

See also
========

  * TEST (Macaulay2Doc) -- add a test for a package
  * check (Macaulay2Doc) -- perform tests of a package
  * packageTemplate -- a template for a package
  * docExample -- an example of a documentation string

For the programmer
==================

The object testExample, is a string (Macaulay2Doc).

wikipedia -- link to a Wikipedia article
****************************************

Synopsis
========

  * Usage:
        wikipedia(url, title)
        wikipedia title
  * Inputs:
      * url, a string (Macaulay2Doc), the article's url slug,
        optional
      * title, a string (Macaulay2Doc), a Wikipedia article's
        title
  * Outputs:
      * a markup list (Text), a link to the Wikipedia entry
        with the given title usable inside a documentation node

Description
===========

+-----------------------------------------------------------------------------+
|i1 : wikipedia "Bessel function"                                             |
|                                                                             |
|o1 = Bessel function (see https://en.wikipedia.org/wiki/Bessel_function )    |
|                                                                             |
|o1 : HREF                                                                    |
+-----------------------------------------------------------------------------+
|i2 : html oo                                                                 |
|                                                                             |
|o2 = <a href="https://en.wikipedia.org/wiki/Bessel_function">Bessel          |
|     function</a>                                                            |
+-----------------------------------------------------------------------------+
|i3 : wikipedia("Bessel_function#Definitions", "Bessel function")             |
|                                                                             |
|o3 = Bessel function (see https://en.wikipedia.org/wiki/Bessel_function#     |
|                                                                             |
|o3 : HREF                                                                    |
|-----------------------------------------------------------------------------|
|Definitions )                                                                |
+-----------------------------------------------------------------------------+
|i4 : html oo                                                                 |
|                                                                             |
|o4 = <a href="https://en.wikipedia.org/wiki/Bessel_function#Definitions">    |
|     Bessel function</a>                                                     |
+-----------------------------------------------------------------------------+

See also
========

  * document (Macaulay2Doc) -- create a documentation node
  * arXiv -- link to an arXiv article
  * stacksProject -- link to a Stacks Project tag

Ways to use wikipedia :
=======================

  * "wikipedia(String)"
  * "wikipedia(String,String)"

For the programmer
==================

The object wikipedia, is a method function (Macaulay2Doc).