Changeset 206f4cf

Timestamp:

May 19, 2025, 3:01:48 PM (4 weeks ago)

Author:

Fangren Yu <f37yu@…>

Branches:

master

Children:

00ad2a0

Parents:

8b3109b

Message:

proofreading fixes

File:

• doc/theses/fangren_yu_MMath/background.tex (modified) (6 diffs)

doc/theses/fangren_yu_MMath/background.tex

@@ -8 +8 @@
 Haskell~\cite{Haskell10} combines ML-style polymorphism, polymorphic data types, and type inference with the notion of type classes, collections of overloadable methods.
 The class/type-class association constrain type arguments by indicating the set of functions that become implicit assertion arguments and specify the implementation of these operations.
-As pointed out \see{\VRef[Figure]{f:ImplicitExplicitTraitInferencing}}, Haskell requires an explicit association between types and constrains (type-class).
+As pointed out \see{\VRef[Figure]{f:ImplicitExplicitTraitInferencing}}, Haskell requires an explicit association between types and constraints (type-class).
 Otherwise, Haskell does not provide general overloading.
 \CFA differs by allowing general overloading and constraining type arguments with traits.
@@ -16 +16 @@
 Selecting among them and understanding how they interact is part of the challenge in \CC program development.
 General overloading is available, subtyping inheritance can be single or multiple, templates are typed macro-expansion over a universal type, which precludes separate compilation.
-Universal template types are constrained using @concept@s~\cite{C++Concepts}, but only as a guideline, as the template expansion can still discover additional constrains.
+Universal template types are constrained using @concept@s~\cite{C++Concepts}, but only as a guideline, as the template expansion can still discover additional constraints.
 Template expansion can result in code bloat and poor error messages.
 Type inferencing is available using \lstinline[language=C++]{auto}, precluding using the return type for overload selection.
-\CFA differs by providing a simplified, uniform facility for polymorphic code, eliminating subtyping polymorphic, and encompassing overloading among parametric functions and universal (generic) types, all of which are separately compilable.
+\CFA differs by providing a simplified, uniform facility for polymorphic code, eliminating subtyping polymorphism, and encompassing overloading among parametric functions and universal (generic) types, all of which are separately compilable.
 Overload resolution uses the return type and arithmetic conversions to make precise function selections versus generating ambiguities, at the cost of type inferencing.
 Both \CFA call-site inferencing and \CC template expansion search in the local environment to satisfy explicit assertions or to find named functions to complete the template, respectively.
@@ -40 +40 @@
 \CFA's path for modernizing works with the existing C type system and runtime, \ie not adding object-oriented types or garbage collection.
 Java~\cite{Java8} has object-oriented subtyping, generic @interface@s that act like traits, which are type checked at compilation and type erased at runtime similar to \CFA's, and general overloading on methods.
-However, in Java, each object carries its own table of method pointers, whereas \CFA passes trait pointers at call-site maintaining a C-compatible layout.
+However, in Java, each class carries its own table of method pointers, and use of interfaces must be pre-declared with the @implements@ keyword, whereas \CFA passes trait pointers at call-site maintaining a C-compatible layout.
 Java is also garbage-collected.
 
@@ -48 +48 @@
 Go's generic types and functions are limited to a small fixed-set provided by the compiler, with no language facility to define more.
 Rust also possesses more powerful abstraction capabilities for writing generic code than Go.
-While Rust's borrow checker provides strong safety guarantees, it is complex and difficult to learn and imposes a distinctly idiomatic programming style different than C.
-\CFA, with its modest safety features, has a comparable type-system to Rust's, while maintaining C backwards compatibility, providing a modernization path for existing C code-bases.
+While Rust's borrow checker provides strong safety guarantees, it is complex and difficult to learn, and imposes a distinctly idiomatic programming style different from C.
+\CFA, with its modest safety features, has a comparable type-system to Rust's that also maintains C backwards compatibility, which provides a modernization path for existing C code-bases.
 
 
@@ -66 +66 @@
 While \CFA has some structured-tuple capabilities, \VRef{s:TupleImplementation}, my analysis suggests this feature might be removed.
 
-An alternative to a tuple type is of variadic (variable argument) functions or type.
+An alternative to tuple types is variadic (variable number of arguments) functions or types.
 C provides variadic functions through @va_list@ objects, but the programmer is responsible for managing the number of arguments and their types;
 thus, the mechanism is type unsafe.
@@ -72 +72 @@
 Tuples are a generalization of @std::pair@ allowing for arbitrary length, fixed-size aggregation of heterogeneous values.
 Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.
-\CC{17} proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.
+\CC{17} proposes \emph{structured bindings}~\cite{Sutter15} to eliminate pre-declaring variables and the use of @std::tie@ for binding the results.
 This extension requires the use of @auto@ to infer the types of the new variables; hence, complicated expressions with a nonobvious type must be documented with some other mechanism.
 Furthermore, structured bindings are not a full replacement for @std::tie@, as it always declares new variables.
 Java's variadic functions appear similar to C's but are type safe using homogeneous arrays.
-\CFA's heterogeneous variadic-functions \see{\VPageref{p:VariadicFunctions}} provide a type-safe version of C variadic, although limited in features, which fits into the overall \CFA type-system design.
+\CFA's heterogeneous variadic functions \see{\VPageref{p:VariadicFunctions}} provide a type-safe version of C variadic, although limited in features, which fits into the overall \CFA type-system design.