Changes in doc/user/user.tex [b202dc2:dabc428]

File:

• doc/user/user.tex (modified) (33 diffs)

doc/user/user.tex

@@ -11 +11 @@
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
-%% Last Modified On : Sat Mar 27 09:55:55 2021
-%% Update Count     : 4796
+%% Last Modified On : Tue Apr 20 23:25:56 2021
+%% Update Count     : 4888
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
@@ -66 +66 @@
 % math escape $...$ (dollar symbol)
 \input{common}                                          % common CFA document macros
+\setlength{\gcolumnposn}{3in}
 \CFAStyle                                                                                               % use default CFA format-style
 \lstset{language=CFA}                                                                   % CFA default lnaguage
@@ -2166 +2167 @@
 \section{Enumeration}
 
-An \newterm{enumeration} is a compile-time mechanism to give names to constants.
-There is no runtime manifestation of an enumeration.
-Their purpose is code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
-
-An enumeration defines a type containing a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) with a fixed (©const©) value.
-\begin{cfa}
-enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names
+An \newterm{enumeration} is a compile-time mechanism to alias names to constants, like ©typedef© is a mechanism to alias names to types.
+Its purpose is to define a restricted-value type providing code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
+
+An enumeration type is a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) aliased to a fixed value (constant).
+\begin{cfa}
+enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names & values
 Days days = Mon; // enumeration type declaration and initialization
 \end{cfa}
-The set of enums are injected into the scope of the definition and use the variable namespace.
+The set of enums are injected into the variable namespace at the definition scope.
 Hence, enums may be overloaded with enum/variable/function names.
 \begin{cfa}
@@ -2183 +2183 @@
 double Bar;                     $\C{// overload Foo.Bar, Goo.Bar}\CRT$
 \end{cfa}
-An anonymous enumeration is used to inject enums with specific values into a scope:
+An anonymous enumeration injects enums with specific values into a scope.
 \begin{cfa}
 enum { Prime = 103, BufferSize = 1024 };
 \end{cfa}
-An enumeration is better than using the C \Index{preprocessor}
+An enumeration is better than using C \Index{preprocessor} or constant declarations.
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{4em}}l@{}}
 \begin{cfa}
 #define Mon 0
@@ -2193 +2195 @@
 #define Sun 6
 \end{cfa}
-or C constant declarations
-\begin{cfa}
-const int Mon = 0, ..., Sun = 6;
-\end{cfa}
+&
+\begin{cfa}
+const int Mon = 0,
+                         ...,
+                         Sun = 6;
+\end{cfa}
+\end{tabular}
+\end{cquote}
 because the enumeration is succinct, has automatic numbering, can appear in ©case© labels, does not use storage, and is part of the language type-system.
 Finally, the type of an enum is implicitly or explicitly specified and the constant value can be implicitly or explicitly specified.
@@ -2204 +2210 @@
 \subsection{Enum type}
 
-While an enumeration defines a new set-type of names, its underlying enums can be any ©const© type, and an enum's value comes from this type.
-\CFA provides an automatic conversion from an enum to its base type, \eg comparing/printing an enum compares/prints its value rather than the enum name.
+The type of enums can be any type, and an enum's value comes from this type.
+Because an enum is a constant, it cannot appear in a mutable context, \eg ©Mon = Sun© is disallowed, and has no address (it is an rvalue).
+Therefore, an enum is automatically converted to its constant's base-type, \eg comparing/printing an enum compares/prints its value rather than the enum name;
+there is no mechanism to print the enum name.
+
 The default enum type is ©int©.
 Hence, ©Days© is the set type ©Mon©, ©Tue©, ...\,, ©Sun©, while the type of each enum is ©int© and each enum represents a fixed integral value.
 If no values are specified for an integral enum type, the enums are automatically numbered by one from left to right starting at zero.
 Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
-If a value is specified, numbering continues by one from that value.
-It an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
-
-Other integral types with associated values can be explicitly specified.
+If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
+If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
+
+\CFA allows other integral types with associated values.
 \begin{cfa}
 enum( @char@ ) Letter { A @= 'A'@,  B,  C,  I @= 'I'@,  J,  K };
@@ -2219 +2228 @@
 \end{cfa}
 For enumeration ©Letter©, enum ©A©'s value is explicitly set to ©'A'©, with ©B© and ©C© implicitly numbered with increasing values from ©'A'©, and similarly for enums ©I©, ©J©, and ©K©.
-Note, an enum is an immutable constant, \ie ©A = B© is disallowed;
-by transitivity, an enum's type is implicitly ©const©.
-Hence, a constant/enum cannot appear in a mutuable context nor is a constant/enum addressable (rvalue).
-
-Non-integral enum types have the restriction that all enums \emph{must} be explicitly specified, \ie incrementing by one for the next enum is not done even if supported by the enum type, \eg ©double©.
+
+Non-integral enum types must be explicitly initialized, \eg ©double© is not automatically numbered by one.
 \begin{cfa}
 // non-integral numeric
-enum( double ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+enum( @double@ ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
 // pointer
-enum( char * ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+enum( @char *@ ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
 int i, j, k;
-enum( int * ) ptr { I = &i,  J = &j,  K = &k };
-enum( int & ) ref { I = i,  J = j,  K = k };
+enum( @int *@ ) ptr { I = &i,  J = &j,  K = &k };
+enum( @int &@ ) ref { I = i,  J = j,  K = k };
 // tuple
-enum( [int, int] ) { T = [ 1, 2 ] };
+enum( @[int, int]@ ) { T = [ 1, 2 ] };
 // function
 void f() {...}   void g() {...}
-enum( void (*)() ) funs { F = f,  F = g };
+enum( @void (*)()@ ) funs { F = f,  F = g };
 // aggregate
 struct S { int i, j; };
-enum( S ) s { A = { 3,  4 }, B = { 7,  8 } };
+enum( @S@ ) s { A = { 3,  4 }, B = { 7,  8 } };
 // enumeration
-enum( Letter ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
+enum( @Letter@ ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
 \end{cfa}
 Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
@@ -2253 +2259 @@
 m = Alph;               $\C{// {\color{red}disallowed}}$
 m = 3.141597;   $\C{// {\color{red}disallowed}}$
-d = E;                  $\C{// allowed, conversion to base type}$
-d = m;                  $\C{// {\color{red}disallowed}}$
+d = m;                  $\C{// allowed}$
 d = Alph;               $\C{// {\color{red}disallowed}}$
 Letter l = A;   $\C{// allowed}$
@@ -2263 +2268 @@
 
 A constructor \emph{cannot} be used to initialize enums because a constructor executes at runtime.
-A fallback is to substitute C-style initialization overriding the constructor with ©@=©.
-\begin{cfa}
-enum( struct vec3 ) Axis { Up $@$= { 1, 0, 0 }, Left $@$= ..., Front $@$= ... }
+A fallback is explicit C-style initialization using ©@=©.
+\begin{cfa}
+enum( struct vec3 ) Axis { Up $@$= { 1, 0, 0 }, Left $@$= { 0, 1, 0 }, Front $@$= { 0, 0, 1 } }
 \end{cfa}
 Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
@@ -2274 +2279 @@
 \Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
 \begin{cfa}
-enum( const char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
-enum @/* inferred */@  Name3 { @inline Name@, @inline Name2@, Sue = "Sue", Tom = "Tom" };
+enum( char * ) Name2 { @inline Name@, Jack = "Jack", Jill = "Jill" };
+enum @/* inferred */@  Name3 { @inline Name2@, Sue = "Sue", Tom = "Tom" };
 \end{cfa}
 Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
@@ -2281 +2286 @@
 The enum type for the inheriting type must be the same as the inherited type;
 hence the enum type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for ©Name3©.
-When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important.
+When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important, \eg the placement of ©Sue© and ©Tom© before or after ©inline Name2©.
 
 Specifically, the inheritance relationship for ©Name©s is:
@@ -2301 +2306 @@
 j( Fred );    j( Jill );    j( Sue );    j( 'W' );
 \end{cfa}
-Note, the validity of calls is the same for call by reference as for call by value, and ©const© restrictions are the same as for other types.
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and ©const© restrictions are the same as for other types.
 
 Enums cannot be created at runtime, so inheritence problems, such as contra-variance do not apply.
@@ -2313 +2318 @@
 \begin{cfa}
 // Fred is a subset of char *
-enum char * Fred { A = "A", B = "B", C = "C" };
+enum( char *) Fred { A = "A", B = "B", C = "C" };
 // Jack is a subset of Fred
-enum enum Fred Jack { W = A, Y = C};
+enum( enum Fred ) Jack { W = A, Y = C};
 // Mary is a superset of Fred
 enum Mary { inline Fred, D = "hello" };
@@ -4168 +4173 @@
 
 The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable.
-For ©_Bool© type, the constants are ©true© and ©false©.
+For ©bool© type, the constants are ©true© and ©false©.
 For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
 \begin{itemize}
@@ -4580 +4585 @@
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
 However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
-Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
+Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©bool©.
 
 Why just 0 and 1? Why not other integers? No other integers have special status in C.
@@ -5045 +5050 @@
 \begin{figure}
 \begin{cfa}
-#include <fstream>
-#include <coroutine>
-
-coroutine Fibonacci {
+#include <fstream.hfa>
+#include @<coroutine.hfa>@
+
+@coroutine@ Fibonacci {
         int fn; $\C{// used for communication}$
 };
-void ?{}( Fibonacci * this ) {
-        this->fn = 0;
-}
-void main( Fibonacci * this ) {
+
+void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
         int fn1, fn2; $\C{// retained between resumes}$
-        this->fn = 0; $\C{// case 0}$
-        fn1 = this->fn;
-        suspend(); $\C{// return to last resume}$
-
-        this->fn = 1; $\C{// case 1}$
-        fn2 = fn1;
-        fn1 = this->fn;
-        suspend(); $\C{// return to last resume}$
-
-        for ( ;; ) { $\C{// general case}$
-                this->fn = fn1 + fn2;
-                fn2 = fn1;
-                fn1 = this->fn;
-                suspend(); $\C{// return to last resume}$
-        } // for
-}
-int next( Fibonacci * this ) {
-        resume( this ); $\C{// transfer to last suspend}$
-        return this->fn;
+        fn = 0;  fn1 = fn; $\C{// 1st case}$
+        @suspend;@ $\C{// restart last resume}$
+        fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
+        @suspend;@ $\C{// restart last resume}$
+        for () {
+                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
+                @suspend;@ $\C{// restart last resume}$
+        }
+}
+int next( Fibonacci & fib ) with( fib ) {
+        @resume( fib );@ $\C{// restart last suspend}$
+        return fn;
 }
 int main() {
         Fibonacci f1, f2;
-        for ( int i = 1; i <= 10; i += 1 ) {
-                sout | next( &f1 ) | ' ' | next( &f2 );
-        } // for
-}
-\end{cfa}
+        for ( 10 ) { $\C{// print N Fibonacci values}$
+                sout | next( f1 ) | next( f2 );
+        }
+}
+\end{cfa}
+\vspace*{-5pt}
 \caption{Fibonacci Coroutine}
 \label{f:FibonacciCoroutine}
@@ -5108 +5105 @@
 \begin{figure}
 \begin{cfa}
-#include <fstream>
-#include <kernel>
-#include <monitor>
-#include <thread>
-
-monitor global_t {
-        int value;
-};
-
-void ?{}(global_t * this) {
-        this->value = 0;
-}
-
-static global_t global;
-
-void increment3( global_t * mutex this ) {
-        this->value += 1;
-}
-void increment2( global_t * mutex this ) {
-        increment3( this );
-}
-void increment( global_t * mutex this ) {
-        increment2( this );
-}
+#include <fstream.hfa>
+#include @<thread.hfa>@
+
+@monitor@ AtomicCnt { int counter; };
+void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
+int inc( AtomicCnt & @mutex@ c, int inc = 1 ) with(c) { return counter += inc; }
+int dec( AtomicCnt & @mutex@ c, int dec = 1 ) with(c) { return counter -= dec; }
+forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
+        ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
+        void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
+}
+
+AtomicCnt global; $\C{// shared}$
 
 thread MyThread {};
-
-void main( MyThread* this ) {
-        for(int i = 0; i < 1_000_000; i++) {
-                increment( &global );
+void main( MyThread & ) {
+        for ( i; 100_000 ) {
+                inc( global );
+                dec( global );
         }
 }
-int main(int argc, char* argv[]) {
-        processor p;
+int main() {
+        enum { Threads = 4 };
+        processor p[Threads - 1]; $\C{// + starting processor}$
         {
-                MyThread f[4];
+                MyThread t[Threads];
         }
-        sout | global.value;
+        sout | global; $\C{// print 0}$
 }
 \end{cfa}
 \caption{Atomic-Counter Monitor}
-\caption{f:AtomicCounterMonitor}
+\label{f:AtomicCounterMonitor}
 \end{figure}
 
@@ -7320 +7307 @@
 [ int, long double ] remquo( long double, long double );
 
-float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
-double div( double, double, int * );
-long double div( long double, long double, int * );
 [ int, float ] div( float, float );
 [ int, double ] div( double, double );
@@ -7383 +7367 @@
 long double _Complex log( long double _Complex );
 
-float log2( float );$\indexc{log2}$
+int log2( unsigned int );$\indexc{log2}$
+long int log2( unsigned long int );
+long long int log2( unsigned long long int )
+float log2( float );
 double log2( double );
 long double log2( long double );
@@ -7565 +7552 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+// n / align * align
+signed char floor( signed char n, signed char align );
+unsigned char floor( unsigned char n, unsigned char align );
+short int floor( short int n, short int align );
+unsigned short int floor( unsigned short int n, unsigned short int align );
+int floor( int n, int align );
+unsigned int floor( unsigned int n, unsigned int align );
+long int floor( long int n, long int align );
+unsigned long int floor( unsigned long int n, unsigned long int align );
+long long int floor( long long int n, long long int align );
+unsigned long long int floor( unsigned long long int n, unsigned long long int align );
+
+// (n + (align - 1)) / align
+signed char ceiling_div( signed char n, char align );
+unsigned char ceiling_div( unsigned char n, unsigned char align );
+short int ceiling_div( short int n, short int align );
+unsigned short int ceiling_div( unsigned short int n, unsigned short int align );
+int ceiling_div( int n, int align );
+unsigned int ceiling_div( unsigned int n, unsigned int align );
+long int ceiling_div( long int n, long int align );
+unsigned long int ceiling_div( unsigned long int n, unsigned long int align );
+long long int ceiling_div( long long int n, long long int align );
+unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align );
+
+// floor( n + (n % align != 0 ? align - 1 : 0), align )
+signed char ceiling( signed char n, signed char align );
+unsigned char ceiling( unsigned char n, unsigned char align );
+short int ceiling( short int n, short int align );
+unsigned short int ceiling( unsigned short int n, unsigned short int align );
+int ceiling( int n, int align );
+unsigned int ceiling( unsigned int n, unsigned int align );
+long int ceiling( long int n, long int align );
+unsigned long int ceiling( unsigned long int n, unsigned long int align );
+long long int ceiling( long long int n, long long int align );
+unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
+
 float floor( float );$\indexc{floor}$
 double floor( double );
@@ -7667 +7690 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
-        int64_t tv; $\C{// nanoseconds}$
+        int64_t tn; $\C{// nanoseconds}$
 };
 
 void ?{}( Duration & dur );
 void ?{}( Duration & dur, zero_t );
+void ?{}( Duration & dur, timeval t )
+void ?{}( Duration & dur, timespec t )
 
 Duration ?=?( Duration & dur, zero_t );
+Duration ?=?( Duration & dur, timeval t )
+Duration ?=?( Duration & dur, timespec t )
 
 Duration +?( Duration rhs );
@@ -7695 +7722 @@
 Duration ?%=?( Duration & lhs, Duration rhs );
 
-_Bool ?==?( Duration lhs, Duration rhs );
-_Bool ?!=?( Duration lhs, Duration rhs );
-_Bool ?<? ( Duration lhs, Duration rhs );
-_Bool ?<=?( Duration lhs, Duration rhs );
-_Bool ?>? ( Duration lhs, Duration rhs );
-_Bool ?>=?( Duration lhs, Duration rhs );
-
-_Bool ?==?( Duration lhs, zero_t );
-_Bool ?!=?( Duration lhs, zero_t );
-_Bool ?<? ( Duration lhs, zero_t );
-_Bool ?<=?( Duration lhs, zero_t );
-_Bool ?>? ( Duration lhs, zero_t );
-_Bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, zero_t );
+bool ?!=?( Duration lhs, zero_t );
+bool ?<? ( Duration lhs, zero_t );
+bool ?<=?( Duration lhs, zero_t );
+bool ?>? ( Duration lhs, zero_t );
+bool ?>=?( Duration lhs, zero_t );
+
+bool ?==?( Duration lhs, Duration rhs );
+bool ?!=?( Duration lhs, Duration rhs );
+bool ?<? ( Duration lhs, Duration rhs );
+bool ?<=?( Duration lhs, Duration rhs );
+bool ?>? ( Duration lhs, Duration rhs );
+bool ?>=?( Duration lhs, Duration rhs );
 
 Duration abs( Duration rhs );
@@ -7734 +7761 @@
 int64_t ?`w( Duration dur );
 
+double ?`dns( Duration dur );
+double ?`dus( Duration dur );
+double ?`dms( Duration dur );
+double ?`ds( Duration dur );
+double ?`dm( Duration dur );
+double ?`dh( Duration dur );
+double ?`dd( Duration dur );
+double ?`dw( Duration dur );
+
 Duration max( Duration lhs, Duration rhs );
 Duration min( Duration lhs, Duration rhs );
+
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
 \end{cfa}
 
@@ -7746 +7784 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timeval & t );
+void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, time_t sec, suseconds_t usec );
 void ?{}( timeval & t, time_t sec );
-void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, Time time );
 
@@ -7754 +7792 @@
 timeval ?+?( timeval & lhs, timeval rhs );
 timeval ?-?( timeval & lhs, timeval rhs );
-_Bool ?==?( timeval lhs, timeval rhs );
-_Bool ?!=?( timeval lhs, timeval rhs );
+bool ?==?( timeval lhs, timeval rhs );
+bool ?!=?( timeval lhs, timeval rhs );
 \end{cfa}
 
@@ -7766 +7804 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timespec & t );
+void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec );
 void ?{}( timespec & t, time_t sec );
-void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, Time time );
 
@@ -7774 +7812 @@
 timespec ?+?( timespec & lhs, timespec rhs );
 timespec ?-?( timespec & lhs, timespec rhs );
-_Bool ?==?( timespec lhs, timespec rhs );
-_Bool ?!=?( timespec lhs, timespec rhs );
+bool ?==?( timespec lhs, timespec rhs );
+bool ?!=?( timespec lhs, timespec rhs );
 \end{cfa}
 
@@ -7797 +7835 @@
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
-        uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
+        uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
 };
 
 void ?{}( Time & time );
 void ?{}( Time & time, zero_t );
+void ?{}( Time & time, timeval t );
+void ?{}( Time & time, timespec t );
 
 Time ?=?( Time & time, zero_t );
-
-void ?{}( Time & time, timeval t );
 Time ?=?( Time & time, timeval t );
-
-void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, timespec t );
 
@@ -7818 +7854 @@
 Time ?-?( Time lhs, Duration rhs );
 Time ?-=?( Time & lhs, Duration rhs );
-_Bool ?==?( Time lhs, Time rhs );
-_Bool ?!=?( Time lhs, Time rhs );
-_Bool ?<?( Time lhs, Time rhs );
-_Bool ?<=?( Time lhs, Time rhs );
-_Bool ?>?( Time lhs, Time rhs );
-_Bool ?>=?( Time lhs, Time rhs );
+bool ?==?( Time lhs, Time rhs );
+bool ?!=?( Time lhs, Time rhs );
+bool ?<?( Time lhs, Time rhs );
+bool ?<=?( Time lhs, Time rhs );
+bool ?>?( Time lhs, Time rhs );
+bool ?>=?( Time lhs, Time rhs );
+
+int64_t ?`ns( Time t );
 
 char * yy_mm_dd( Time time, char * buf );
-char * ?`ymd( Time time, char * buf ) { // short form
-        return yy_mm_dd( time, buf );
-} // ymd
+char * ?`ymd( Time time, char * buf ); // short form
 
 char * mm_dd_yy( Time time, char * buf );
-char * ?`mdy( Time time, char * buf ) { // short form
-        return mm_dd_yy( time, buf );
-} // mdy
+char * ?`mdy( Time time, char * buf ); // short form
 
 char * dd_mm_yy( Time time, char * buf );
-char * ?`dmy( Time time, char * buf ) { // short form
-        return dd_mm_yy( time, buf );;
-} // dmy
+char * ?`dmy( Time time, char * buf ); // short form
 
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
-forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
 \end{cfa}
 
@@ -7867 +7900 @@
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
-struct Clock {
-        Duration offset; $\C{// for virtual clock: contains offset from real-time}$
-        int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
+struct Clock { $\C{// virtual clock}$
+        Duration offset; $\C{// offset from computer real-time}$
 };
 
-void resetClock( Clock & clk );
-void resetClock( Clock & clk, Duration adj );
-void ?{}( Clock & clk );
-void ?{}( Clock & clk, Duration adj );
-
-Duration getResNsec(); $\C{// with nanoseconds}$
-Duration getRes(); $\C{// without nanoseconds}$
-
-Time getTimeNsec(); $\C{// with nanoseconds}$
-Time getTime(); $\C{// without nanoseconds}$
-Time getTime( Clock & clk );
-Time ?()( Clock & clk );
-timeval getTime( Clock & clk );
-tm getTime( Clock & clk );
+void ?{}( Clock & clk ); $\C{// create no offset}$
+void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
+void reset( Clock & clk, Duration adj ); $\C{// change offset}$
+
+Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
+Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
+
+Time timeHiRes(); $\C{// real time with nanoseconds}$
+Time time(); $\C{// real time without nanoseconds}$
+Time time( Clock & clk ); $\C{// real time for given clock}$
+Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
+timeval time( Clock & clk ); $\C{// convert to C time format}$
+tm time( Clock & clk );
+Duration processor(); $\C{// non-monotonic duration of kernel thread}$
+Duration program(); $\C{// non-monotonic duration of program CPU}$
+Duration boot(); $\C{// monotonic duration since computer boot}$
 \end{cfa}
 
@@ -8056 +8090 @@
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
 \end{cfa}
-
-The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
+\VRef[Figure]{f:MultiPrecisionFactorials} shows \CFA and C factorial programs using the GMP interfaces.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
+
+\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
-\multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
 \hline
 \begin{cfa}
@@ -8070 +8105 @@
 
         sout | 0 | fact;
-        for ( unsigned int i = 1; i <= 40; i += 1 ) {
+        for ( i; 40 ) {
                 fact *= i;
                 sout | i | fact;
@@ -8092 +8127 @@
 \end{tabular}
 \end{cquote}
-
-\begin{figure}
+\small
 \begin{cfa}
 Factorial Numbers