Context Navigation

-                      rd0b9247
+                      r9cdfa5fb
 compatibility with C and its programmers.  \CFA is designed to have an
 orthogonal feature-set based closely on the C programming paradigm
+(non-object-oriented) and these features can be added incrementally to an
+existing C code-base allowing programmers to learn \CFA on an as-needed basis.
+(non-object-oriented), and these features can be added incrementally to an
+existing C code-base,
+allowing programmers to learn \CFA on an as-needed basis.
 Only those \CFA features pertaining to this thesis are discussed.
 …
 \CFA adds a reference type to C as an auto-dereferencing pointer.
 They work very similarly to pointers.
 Reference-types are written the same way as a pointer-type but each
+Reference-types are written the same way as pointer-types, but each
 asterisk (@*@) is replaced with a ampersand (@&@);
+this includes cv-qualifiers and multiple levels of reference.
+Generally, references act like pointers with an implicate dereferencing
+this includes cv-qualifiers (\snake{const} and \snake{volatile})
+%\todo{Should I go into even more detail on cv-qualifiers.}
+and multiple levels of reference.
+Generally, references act like pointers with an implicit dereferencing
 operation added to each use of the variable.
 These automatic dereferences may be disabled with the address-of operator
 …
 Mutable references may be assigned to by converting them to a pointer
 with a @&@ and then assigning a pointer to them, as in @&ri = &j;@ above.
-% ???
 \section{Operators}
 …
 For example,
 infixed multiplication is @?*?@, while prefix dereference is @*?@.
 This syntax make it easy to tell the difference between prefix operations
 (such as @++?@) and post-fix operations (@?++@).
+This syntax makes it easy to tell the difference between prefix operations
+(such as @++?@) and postfix operations (@?++@).
 As an example, here are the addition and equality operators for a point type.
 …
+}
 \end{cfa}
 Note that this syntax works effectively but a textual transformation,
+Note that this syntax works effectively as a textual transformation;
 the compiler converts all operators into functions and then resolves them
 normally. This means any combination of types may be used,
 …
 %\subsection{Constructors and Destructors}
 In \CFA, constructors and destructors are operators, which means they are
 functions with special operator names rather than type names in \Cpp.
+functions with special operator names, rather than type names as in \Cpp.
 Both constructors and destructors can be implicity called by the compiler,
 however the operator names allow explicit calls.
 …
 @b@ because of the explicit call and @a@ implicitly.
 @c@ will be initalized with the second constructor.
 Currently, there is no general way to skip initialation.
+Currently, there is no general way to skip initialization.
 % I don't use @= anywhere in the thesis.
 …
 do_twice(i);
 \end{cfa}
 Any object with a type fulfilling the assertion may be passed as an argument to
+Any value with a type fulfilling the assertion may be passed as an argument to
 a @do_twice@ call.
 …
 function. The matched assertion function is then passed as a function pointer
 to @do_twice@ and called within it.
 The global definition of @do_once@ is ignored, however if quadruple took a
+The global definition of @do_once@ is ignored, however if @quadruple@ took a
 @double@ argument, then the global definition would be used instead as it
 would then be a better match.\cite{Moss19}
 To avoid typing long lists of assertions, constraints can be collected into
 convenient a package called a @trait@, which can then be used in an assertion
+a convenient package called a @trait@, which can then be used in an assertion
 instead of the individual constraints.
 \begin{cfa}
 …
 functions and variables, and are usually used to create a shorthand for, and
 give descriptive names to, common groupings of assertions describing a certain
 functionality, like @sumable@, @listable@, \etc.
+functionality, like @summable@, @listable@, \etc.
 Polymorphic structures and unions are defined by qualifying an aggregate type
 with @forall@. The type variables work the same except they are used in field
 declarations instead of parameters, returns, and local variable declarations.
+declarations instead of parameters, returns and local variable declarations.
 \begin{cfa}
 forall(dtype T)
 …
 \section{Control Flow}
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@, @monitor@, @mutex@ parameters, and @thread@.
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@,
+@monitor@, @mutex@ parameters, and @thread@.
 The two features that interact with
 the exception system are @coroutine@ and @thread@; they and their supporting
 …
 \subsection{Coroutine}
 A coroutine is a type with associated functions, where the functions are not
+required to finish execution when control is handed back to the caller. Instead
+required to finish execution when control is handed back to the caller.
+Instead,
 they may suspend execution at any time and be resumed later at the point of
+last suspension. (Generators are stackless and coroutines are stackful.) These
+last suspension.
+Coroutine
 types are not concurrent but share some similarities along with common
+underpinnings, so they are combined with the \CFA threading library. Further
+discussion in this section only refers to the coroutine because generators are
+similar.
+underpinnings, so they are combined with the \CFA threading library.
+% I had mention of generators, but they don't actually matter here.
 In \CFA, a coroutine is created using the @coroutine@ keyword, which is an
 …
 \end{cfa}
 When the main function returns the coroutine halts and can no longer be
+When the main function returns, the coroutine halts and can no longer be
 resumed.
 \subsection{Monitor and Mutex Parameter}
 Concurrency does not guarantee ordering; without ordering results are
+Concurrency does not guarantee ordering; without ordering, results are
 non-deterministic. To claw back ordering, \CFA uses monitors and @mutex@
 (mutual exclusion) parameters. A monitor is another kind of aggregate, where
 …
 @mutex@ parameters.
 A function that requires deterministic (ordered) execution, acquires mutual
+A function that requires deterministic (ordered) execution acquires mutual
 exclusion on a monitor object by qualifying an object reference parameter with
 @mutex@.
+the @mutex@ qualifier.
 \begin{cfa}
 void example(MonitorA & mutex argA, MonitorB & mutex argB);
 …
 \subsection{Thread}
 Functions, generators, and coroutines are sequential so there is only a single
+Functions, generators and coroutines are sequential, so there is only a single
 (but potentially sophisticated) execution path in a program. Threads introduce
 multiple execution paths that continue independently.
 For threads to work safely with objects requires mutual exclusion using
 monitors and mutex parameters. For threads to work safely with other threads,
+monitors and mutex parameters. For threads to work safely with other threads
 also requires mutual exclusion in the form of a communication rendezvous, which
 also supports internal synchronization as for mutex objects. For exceptions,

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 9cdfa5fb for doc/theses/andrew_beach_MMath/existing.tex

Legend:

doc/theses/andrew_beach_MMath/existing.tex

Download in other formats: