Changeset 2514d3d7

Timestamp:

Aug 5, 2024, 9:27:42 AM (4 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

94643698

Parents:

7ab24fef

git-author:

Peter A. Buhr <pabuhr@…> (08/05/24 09:26:38)

git-committer:

Peter A. Buhr <pabuhr@…> (08/05/24 09:27:42)

Message:

formatting

Location:

doc/theses/jiada_liang_MMath

Files:

• background.tex (modified) (6 diffs)
• intro.tex (modified) (1 diff)

doc/theses/jiada_liang_MMath/background.tex

@@ -235 +235 @@
 
 \subsection{Function Overloading}
-Function overloading is programming languages feature wherein functions may share the same name, but with different function signatures. In both C++ and \CFA, function names can be overloaded 
+Function overloading is programming languages feature wherein functions may share the same name, but with different function signatures. In both C++ and \CFA, function names can be overloaded
 with different entities as long as they are different in terms of the number and type of parameters.
 
@@ -381 +381 @@
 \end{cfa}
 The @identity@ function accepts a value from any type as an argument and returns that value.
-At the call size, the type parameter @T@ is bounded to @int@ from the argument @42@. 
-
-For polymorphic functions to be useful, the @forall@ clause needs \newterm{type assertion}s that restricts the polymorphic types it accepts. 
+At the call size, the type parameter @T@ is bounded to @int@ from the argument @42@.
+
+For polymorphic functions to be useful, the @forall@ clause needs \newterm{type assertion}s that restricts the polymorphic types it accepts.
 \begin{cfa}
 forall( T @| { void foo( T ); }@ ) void bar( T t ) { @foo( t );@ }
@@ -394 +394 @@
 \subsection{Trait}
 A @forall@ clause can asserts on multiple types and with multiple asserting functions. A common practice in \CFA is to group
-the asserting functions in to a named \newterm{trait}. 
+the asserting functions in to a named \newterm{trait}.
 
 \subsection{Trait}
 
 A @forall@ clause can assert many restrictions on multiple types.
-A common practice is to refactor the assertions into a named \newterm{trait}. 
+A common practice is to refactor the assertions into a named \newterm{trait}.
 \begin{cfa}
 forall(T) trait @Bird@ {
@@ -434 +434 @@
 otherwise, the program becomes littered with many explicit casts, which is not match programmer expectation.
 C is an aggressive language as it provides conversions among almost all of the basic types, even when the conversion is potentially unsafe or not meaningful, \ie @float@ to @bool@.
-C defines the resolution pattern as ``usual arithmetic conversion''~\cite[\S~6.3.1.8]{C11}, in which C looks for a \newterm{common type} between operands, and converts one or both operands to the common type. 
+C defines the resolution pattern as ``usual arithmetic conversion''~\cite[\S~6.3.1.8]{C11}, in which C looks for a \newterm{common type} between operands, and converts one or both operands to the common type.
 Loosely defined, a common type is a the smallest type in terms of size of representation that both operands can be converted into without losing their precision, called a \newterm{widening} or \newterm{safe conversion}.
 
@@ -447 +447 @@
 @safe@ is sum of the degree of safe (widening) conversions.
 \end{enumerate}
-Sum of degree is a method to quantify C's integer and floating-point rank. 
+Sum of degree is a method to quantify C's integer and floating-point rank.
 Every pair of widening conversion types is assigned a \newterm{distance}, and distance between the two same type is 0.
 For example, the distance from @char@ to @int@ is 2, distance from @int@ to @long@ is 1, and distance from @int@ to @long long int@ is 2.
@@ -494 +494 @@
 
 In \CFA, the meaning of a C style cast is determined by its @Cast Cost@. For most cast expression resolution, a cast cost is equal to a conversion cost.
-Cast cost exists as an independent matrix for conversion that cannot happen implcitly, while being possible with an explicit cast. These conversions are often defined to have 
+Cast cost exists as an independent matrix for conversion that cannot happen implcitly, while being possible with an explicit cast. These conversions are often defined to have
 infinite conversion cost and non-infinite cast cost.

doc/theses/jiada_liang_MMath/intro.tex

@@ -299 +299 @@
 \begin{enumerate}
 \item
-overloading: 
+overloading:
 \item
 scoping