Page title cleanup.

akkartik · akkartik · commit 5250f59fa1fd · 2013-06-11T02:53:49.000-07:00
diff --git a/_ref/docs/hdr2.html b/_ref/docs/hdr2.html
@@ -1,7 +1,7 @@
 <html dir="ltr">
 <head>
 <meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
-<title>%%TITLE%%</title>
+<title>Arc: %%TITLE%%</title>
 <link rel="stylesheet" type="text/css" href="code.css">
 <link href="http://twitter.github.io/bootstrap/assets/css/bootstrap.css" rel="stylesheet">
 <link href="http://twitter.github.io/bootstrap/assets/css/bootstrap-responsive.css" rel="stylesheet">
diff --git a/_ref/template.arc b/_ref/template.arc
@@ -30,7 +30,7 @@
     (while (= line (readline inf))
       (if (posmatch "%%INDEX%%" line)
         (disp (subst (getlinkindexhtml) "%%INDEX%%" line))
-        (disp (subst links* "%%LINKS%%" (subst (string "Arc: " page*) "%%TITLE%%" line))))
+        (disp (subst links* "%%LINKS%%" (subst page* "%%TITLE%%" line))))
       (prn)
       )
     (close inf)))
diff --git a/ref/anaphoric.html b/ref/anaphoric.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="html.html">HTML generation</a>
 </div>
-<h1 class="links">Arc: Anaphoric operations</h1>
+<h1 class="links">Anaphoric operations</h1>
 Anaphoric operations provide a mechanism to refer back to themselves.
 This can be useful when an expression needs to be used later, as in <code>aif</code>, <code>awhen</code>, or <code>aand</code>.  Anaphoric functions allow a function to refer back to itself recursively, without creating a named function.
 
diff --git a/ref/app.html b/ref/app.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="setforms.html">Internals of places and setforms</a>
 </div>
-<h1 class="links">Arc: App server</h1>
+<h1 class="links">App server</h1>
 The Arc distribution includes a simple application server in <code>app.arc</code>.  The two main features of the app server are account management and improved forms handling.
 
 <h2>Running the server</h2>
diff --git a/ref/assignment.html b/ref/assignment.html
@@ -22,7 +22,7 @@
 <div class="links">Up: <a href="index.html">Contents</a>
 Next: <a href="combining.html">Boolean operations</a>
 </div>
-<h1 class="links">Arc: Assignment</h1>
+<h1 class="links">Assignment</h1>
 The Arc language features a number of assignment functions to update variables and data structures.  Arc also includes the concept of a "place", which specifies the position to be updated.  Places are also known as "generalized variables", as they can be used as variables in many contexts.
 <p>
 This page describes Arc's basic assignment operators as well as the operators that use places to perform updates.
diff --git a/ref/assoc.html b/ref/assoc.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="template.html">Templates</a>
 </div>
-<h1 class="links">Arc: Association lists</h1>
+<h1 class="links">Association lists</h1>
 <h2>Association lists</h2>
 Association lists are a simple key/value data structure, consisting of a list of pairs.  Keys are looked up in the association list by linearly scanning the list, which makes association lists inefficient for large numbers of entries.
 Arc's <a href="table.html">tables</a> are an alternative to association lists.  Some <a href="http://ycombinator.com/arc/tut.txt">advantages</a> of association lists are that they can preserve order and preserve old values.  Also, multiple association lists can share the same tail.
diff --git a/ref/atomic.html b/ref/atomic.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="os.html">Operating system</a>
 </div>
-<h1 class="links">Arc: Atomic operations</h1>
+<h1 class="links">Atomic operations</h1>
 Atomic operations
 <h2>Atomic operations</h2>
 <p><table class='arc'>
diff --git a/ref/combining.html b/ref/combining.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="iteration.html">Iteration</a>
 </div>
-<h1 class="links">Arc: Boolean operations</h1>
+<h1 class="links">Boolean operations</h1>
 <h2>Booleans</h2>
 Arc provides basic Boolean operations.
  Only nil and empty list are false; any other value, including 0 and empty string, is true.  The operations provide short-circuit evaluation, so only the necessary arguments are evaluated, left-to-right.
diff --git a/ref/conditionals.html b/ref/conditionals.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="evaluation.html">Evaluation</a>
 </div>
-<h1 class="links">Arc: Conditionals</h1>
+<h1 class="links">Conditionals</h1>
 The fundamental conditional operator in Arc is <code>if</code>.  It is similar to the Lisp <code>if</code>, except it eliminates the parentheses around the clauses.  For a simple conditional with multiple body statements, <code>when</code> or its opposite <code>unless</code> can be used.
 <p>
 Arc provides several conditionals that assign the test expression to a variable, similar to <code>let</code>.  The <code>iflet</code>, <code>caselet</code>, and <code>whenlet</code> macros are useful if the test expression is used inside the body.
diff --git a/ref/error.html b/ref/error.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="anaphoric.html">Anaphoric operations</a>
 </div>
-<h1 class="links">Arc: Error handling and continuations</h1>
+<h1 class="links">Error handling and continuations</h1>
 <h2>Error handling and continuations</h2>
 Arc provides several operations for error handling and non-linear control flow.
 Since Arc's control flow mechanisms are built on top of MzScheme, see the MzScheme manual on <a href='http://download.plt-scheme.org/doc/mzscheme/mzscheme-Z-H-6.html#node_chap_6'>exceptions and control flow</a> for details.
diff --git a/ref/evaluation.html b/ref/evaluation.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="list.html">List operations</a>
 </div>
-<h1 class="links">Arc: Evaluation</h1>
+<h1 class="links">Evaluation</h1>
 <h2>Evaluation</h2>
 Arc provides several syntax innovations beyond Scheme.
 <h2>Square-bracket anonymous functions</h2>
diff --git a/ref/filesystem.html b/ref/filesystem.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="threading.html">Threads</a>
 </div>
-<h1 class="links">Arc: File system operations</h1>
+<h1 class="links">File system operations</h1>
 Arc has operations to manipulate files and directories.  These operations do not all work on non-Unix systems.  The I/O operations are closely related to MzScheme's <a
 href='http://download.plt-scheme.org/doc/mzscheme/mzscheme-Z-H-11.html#node_chap_11'>I/O
 operations</a>.
diff --git a/ref/fnindex.html b/ref/fnindex.html
@@ -22,7 +22,7 @@
 <div class="links">Previous: <a href="setforms.html">Internals of places and setforms</a>
 Up: <a href="index.html">Contents</a>
 </div>
-<h1 class="links">Arc: Index of Arc functions</h1>
+<h1 class="links">Index of Arc functions</h1>
 The following alphabetical index lists the functions, procedures, macros, and variables in the Arc language, with links to more information.
 <h2>symbols</h2>
 <a href='math.html#%2a'>*</a>
diff --git a/ref/foundation-doc.html b/ref/foundation-doc.html
diff --git a/ref/html.html b/ref/html.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="srv.html">The Arc web server</a>
 </div>
-<h1 class="links">Arc: HTML operations</h1>
+<h1 class="links">HTML operations</h1>
 Arc provides a large number of operations for generating HTML.  The basic operations are <code>gentag</code> to generate a standalone tag such as <code>&lt;img&gt;</code>, and <code>tag</code> to generate an open/close tag pair surrounding something.  In addition, Arc provides special-purpose functions for common HTML operations.
 Arc has many operations to support forms, as well as many table operations, as tables are its primary layout technique.
 <p>
diff --git a/ref/io.html b/ref/io.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="filesystem.html">Filesystem operations</a>
 </div>
-<h1 class="links">Arc: I/O</h1>
+<h1 class="links">I/O</h1>
 Arc has a large variety of I/O operations that support file, string, and network I/O.  Because Arc's I/O system is based on MzScheme, the <a href="http://download.plt-scheme.org/doc/mzscheme/mzscheme-Z-H-11.html">MzScheme I/O documentation</a> provides useful background.
 <p>
 Arc's I/O system is built in layers.  The <a href="/foundation-doc.html">foundation</a> provides basic operations.  On top of this, more functional operations are constructed.  The <code>w/</code> (with/) series of operations are generally the most convenient.
diff --git a/ref/iteration.html b/ref/iteration.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="conditionals.html">Conditionals</a>
 </div>
-<h1 class="links">Arc: Iteration</h1>
+<h1 class="links">Iteration</h1>
 Arc provides a number of macros to iterate over code multiple times.
 <code>while</code>, <code>until</code>, <code>whilet</code>,
 <code>whiler</code>, and <code>loop</code> permit iteration subject to a
diff --git a/ref/list.html b/ref/list.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="macro.html">Macros</a>
 </div>
-<h1 class="links">Arc: List manipulation</h1>
+<h1 class="links">List manipulation</h1>
 <h2>List manipulation</h2>
 As lists are the key data structure in Arc, the language includes a large number of operations on lists and sequences.  Some operations apply only to lists, while others apply to strings and tables.
 <p><table class='arc'>
diff --git a/ref/macro.html b/ref/macro.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="math.html">Math</a>
 </div>
-<h1 class="links">Arc: Macros</h1>
+<h1 class="links">Macros</h1>
 <h2>Macros</h2>
 Arc's macro system is more similar to Lisp than to Scheme; an Arc macro resembles a function that generates code.
 <p>
diff --git a/ref/math.html b/ref/math.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="predicates.html">Predicates</a>
 </div>
-<h1 class="links">Arc: Math operations</h1>
+<h1 class="links">Math operations</h1>
 <h2>Math operations</h2>
 The math operations of Arc are fairly limited.  Many expected
   operations, such as trigonometry, are missing.
diff --git a/ref/networking.html b/ref/networking.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="atomic.html">Atomic operations</a>
 </div>
-<h1 class="links">Arc: Networking</h1>
+<h1 class="links">Networking</h1>
 <h2>Networking</h2>
 Arc's networking functions are limited to those necessary to support a
   web server.  In particular, there is no support for outgoing network
diff --git a/ref/os.html b/ref/os.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="io.html">I/O in the Arc language</a>
 </div>
-<h1 class="links">Arc: Other OS Operations</h1>
+<h1 class="links">Other OS Operations</h1>
 <h2>Other OS Operations</h2>
 The following are miscellaneous operating system operations.
 <p><table class='arc'>
diff --git a/ref/predicates.html b/ref/predicates.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="string.html">String operations</a>
 </div>
-<h1 class="links">Arc: Predicates</h1>
+<h1 class="links">Predicates</h1>
 <h2>Predicates</h2>
 Arc includes multiple predicates.  The dead and ssyntax predicates are
   listed elsewhere.
diff --git a/ref/queue.html b/ref/queue.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="error.html">Error handling</a>
 </div>
-<h1 class="links">Arc: Queue operations</h1>
+<h1 class="links">Queue operations</h1>
 Arc implements a queue datatype, which is useful to add and remove elements in a first-in-first-out order.  The queue datatype provides two advantages over using a plain list.  The queue provides constant-time operations to add and remove elements and to determine the queue length.  The queue also provides atomic access to its contents.
 <p>Internally the queue is implemented by a three-element list.  The first element is the queue's contents as a list.  The second element is a reference to the last element in the list.  The third element is the length of the queue.  By maintaining a reference to the end of the queue, an element can be added to the end of the queue in constant time, without traversing the whole list.  By storing the length explicitly, the length can also be returned in constant time.  For example, the following shows a queue with two elements:
 <pre class="repl">
diff --git a/ref/setforms.html b/ref/setforms.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="fnindex.html">Index</a>
 </div>
-<h1 class="links">Arc: Internals of places and setforms</h1>
+<h1 class="links">Internals of places and setforms</h1>
 Assignment and generalized variables are one of the most interesting parts of the Arc language.  While assignment with <code>=</code> seems straightforward, it is actually remarkably complex and flexible.  This page describes the details and internals of generalized variables, places, and setforms.  For a more introductory guide, see <a href="assignment.html">Arc: Assignment</a>.
 
 <p>
diff --git a/ref/srv.html b/ref/srv.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="app.html">The Arc application server</a>
 </div>
-<h1 class="links">Arc: Web server</h1>
+<h1 class="links">Web server</h1>
 Arc includes a web server with several interesting features, including a continuation-based design.  The web server includes many different operations to create forms and links with associated continuations.
 <p>
 The Arc distribution comes with sample web applications including a new site (<code>news.arc</code>) and a blog (<code>blog.arc</code>).
diff --git a/ref/string.html b/ref/string.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="table.html">Table operations</a>
 </div>
-<h1 class="links">Arc: String operations</h1>
+<h1 class="links">String operations</h1>
 <h2>String operations</h2>
 <p><table class='arc'>
   <tr>
diff --git a/ref/table.html b/ref/table.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="type.html">Type operations</a>
 </div>
-<h1 class="links">Arc: Table operations</h1>
+<h1 class="links">Table operations</h1>
 <h2>Table operations</h2>
 Arc provides support for hash tables.  An entry in the table is
 accessed by treating the table as a function on the key.  For example, to look
diff --git a/ref/template.html b/ref/template.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="tree.html">Trees</a>
 </div>
-<h1 class="links">Arc: Template operations</h1>
+<h1 class="links">Template operations</h1>
 One of the data structures provided by Arc is the template abstraction.  Templates act somewhat like structure definitions.  A template can be instantiated into a table that represents the structure as key-value pairs, where the keys can be considered field names in the structure, and the values are the values of the fields.
  A template defines a structure by defining the allowed keys, potentially with default values.  A template is instantiated into a table by providing key-value pairs; these can override the defaults.
 <p>
diff --git a/ref/threading.html b/ref/threading.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="time.html">Time operations</a>
 </div>
-<h1 class="links">Arc: Threading</h1>
+<h1 class="links">Threading</h1>
 Arc supports multiple threads of execution.  One useful application of threads is to run a long-running process in the "background", for instance Arc's web server:
 <pre class="repl">
 arc> (thread (asv 8000))
diff --git a/ref/time.html b/ref/time.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="assoc.html">Association lists</a>
 </div>
-<h1 class="links">Arc: Time</h1>
+<h1 class="links">Time</h1>
 Arc provides several functions to determine the current time, measure time intervals, and measure the execution time of expressions.  Many of the 
 functions use a system-dependent time base, which is typically the number of seconds since January 1, 1970; see the MzScheme <a href="http://download.plt-scheme.org/doc/mzscheme/mzscheme-Z-H-15.html">time documentation</a> for details.
 <p>
diff --git a/ref/tree.html b/ref/tree.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="queue.html">Queues</a>
 </div>
-<h1 class="links">Arc: Tree operations</h1>
+<h1 class="links">Tree operations</h1>
 One of the datatypes Arc supports is binary trees, built out of cons cells.
 A standard technique in Lisp is to build a binary tree with data at the leaves and cons cells as the interior nodes.
 <p>
diff --git a/ref/type.html b/ref/type.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="variables.html">Variable operations</a>
 </div>
-<h1 class="links">Arc: Type handling</h1>
+<h1 class="links">Type handling</h1>
 Arc has functions to convert types and to determine the type of an object.
 <h2>Type handling</h2>
 <p><table class='arc'>
diff --git a/ref/variables.html b/ref/variables.html
@@ -23,7 +23,7 @@
 Up: <a href="index.html">Contents</a>
 Next: <a href="networking.html">Networking</a>
 </div>
-<h1 class="links">Arc: Variables</h1>
+<h1 class="links">Variables</h1>
 <h2>Variables</h2>
 <p><table class='arc'>
   <tr>

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@`
`30`	`30`	`(while (= line (readline inf))`
`31`	`31`	`(if (posmatch "%%INDEX%%" line)`
`32`	`32`	`(disp (subst (getlinkindexhtml) "%%INDEX%%" line))`
`33`		`- (disp (subst links* "%%LINKS%%" (subst (string "Arc: " page*) "%%TITLE%%" line))))`
	`33`	`+ (disp (subst links* "%%LINKS%%" (subst page* "%%TITLE%%" line))))`
`34`	`34`	`(prn)`
`35`	`35`	`)`
`36`	`36`	`(close inf)))`