Changeset c9c1a7e6 for doc/theses/fangren_yu_MMath/intro.tex

Timestamp:

May 3, 2025, 8:06:20 AM (5 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

f466d6b

Parents:

99a7163 (diff), 57c7e6c4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

doc/theses/fangren_yu_MMath/intro.tex

@@ -35 +35 @@
 \end{quote}
 Overloading allows programmers to use the most meaningful names without fear of name clashes within a program or from external sources, like include files.
-Experience from \CC and \CFA developers shows the type system can implicitly and correctly disambiguates the majority of overloaded names, \ie it is rare to get an incorrect selection or ambiguity, even among hundreds of overloaded (variables and) functions.
+Experience from \CC and \CFA developers shows the type system can implicitly and correctly disambiguate the majority of overloaded names, \ie it is rare to get an incorrect selection or ambiguity, even among hundreds of overloaded (variables and) functions.
 In many cases, a programmer is unaware of name clashes, as they are silently resolved, simplifying the development process.
 
@@ -445 +445 @@
 f( 'A' );                               $\C{// select (2)}\CRT$
 \end{cfa}
-The type system examines each call size and first looks for an exact match and then a best match using conversions.
+The type system examines each call site and first looks for an exact match and then a best match using conversions.
 
 Ada, Scala, and \CFA type-systems also use the return type in resolving a call, to pinpoint the best overloaded name.
-Essentailly, the return types are \emph{reversed curried} into output parameters of the function.
+Essentially, the return types are \emph{reversed curried} into output parameters of the function.
 For example, in many programming languages with overloading, the following functions are ambiguous without using the return type.
 \begin{cfa}
@@ -643 +643 @@
 For example, if a change is made in an initialization expression, it can cascade type changes producing many other changes and/or errors.
 At some point, a variable's type needs to remain constant and the initializing expression needs to be modified or be in error when it changes.
-Often type-inferencing systems allow restricting (\newterm{branding}) a variable or function type, so the complier can report a mismatch with the constant initialization.
+Often type-inferencing systems allow restricting (\newterm{branding}) a variable or function type, so the compiler can report a mismatch with the constant initialization.
 \begin{cfa}
 void f( @int@ x, @int@ y ) {  // brand function prototype
@@ -795 +795 @@
 \end{tabular}
 \end{cquote}
-Traits are implemented by flatten them at use points, as if written in full by the programmer.
+Traits are implemented by flattening them at use points, as if written in full by the programmer.
 Flattening often results in overlapping assertions, \eg operator @+@.
 Hence, trait names play no part in type equivalence.
@@ -857 +857 @@
 \end{tabular}
 \end{cquote}
+\label{s:GenericImplementation}
 \CFA generic types are \newterm{fixed} or \newterm{dynamic} sized.
 Fixed-size types have a fixed memory layout regardless of type parameters, whereas dynamic types vary in memory layout depending on the type parameters.
@@ -1009 +1010 @@
 \end{swift}
 To make a universal function useable, an abstract description is needed for the operations used on the parameters within the function body.
-Type matching these operations can occur by discover using techniques like \CC template expansion, or explicit stating, \eg interfaces, subtyping (inheritance), assertions (traits), type classes, type bounds.
+Type matching these operations can be done by using techniques like \CC template expansion, or explicit stating, \eg interfaces, subtyping (inheritance), assertions (traits), type classes, type bounds.
 The mechanism chosen can affect separate compilation or require runtime type information (RTTI).
 \begin{description}