Changeset 5346dce


Ignore:
Timestamp:
Aug 20, 2018, 7:32:05 AM (3 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer
Children:
ae4af81
Parents:
72a5a75
Message:

remove proof corrections

Location:
doc
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • doc/bibliography/pl.bib

    r72a5a75 r5346dce  
    929929    title       = {\textsf{C}$\mathbf{\forall}$ Stack Evaluation Programs},
    930930    year        = 2018,
    931     howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{\textcolor{blue}{Q4: https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}}},
     931    howpublished= {\href{https://cforall.uwaterloo.ca/CFAStackEvaluation.zip}{https://cforall.uwaterloo.ca/\-CFAStackEvaluation.zip}},
    932932    optnote     = {[Accessed May 2018]},
    933933}
  • doc/papers/general/Paper.tex

    r72a5a75 r5346dce  
    196196\author[1]{Robert Schluntz}
    197197\author[1]{Peter A. Buhr}
    198 \author[]{\textcolor{blue}{Q1 AUTHOR NAMES CORRECT}}
    199198\authormark{MOSS \textsc{et al}}
    200199
     
    208207The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems.
    209208This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more.
    210 Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''} years ago, lacks many features that make programming in more modern languages safer and more productive.
     209Nevertheless, C, which was first standardized almost 30 years ago, lacks many features that make programming in more modern languages safer and more productive.
    211210The goal of the \CFA project (pronounced ``C for all'') is to create an extension of C that provides modern safety and productivity features while still ensuring strong backward compatibility with C and its programmers.
    212211Prior projects have attempted similar goals but failed to honor the C programming style;
     
    226225
    227226
     227\vspace*{-10pt}
    228228\section{Introduction}
    229229
    230230The C programming language is a foundational technology for modern computing with millions of lines of code implementing everything from hobby projects to commercial operating systems.
    231231This installation base and the programmers producing it represent a massive software engineering investment spanning decades and likely to continue for decades more.
    232 The TIOBE index~\cite{TIOBE} \textcolor{blue}{CHANGE ``TIOBE'' TO ``The TIOBE index''} ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.
     232The TIOBE index~\cite{TIOBE} ranks the top five most \emph{popular} programming languages as Java 15\%, \Textbf{C 12\%}, \Textbf{\CC 5.5\%}, and Python 5\%, \Csharp 4.5\% = 42\%, where the next 50 languages are less than 4\% each with a long tail.
    233233The top three rankings over the past 30 years are as follows.
    234 \newpage
    235 \textcolor{blue}{MOVE TABLE HERE}
    236234\begin{center}
    237235\setlength{\tabcolsep}{10pt}
     
    246244\lstMakeShortInline@%
    247245\end{center}
    248 
    249246Love it or hate it, C is extremely popular, highly used, and one of the few systems languages.
    250247In many cases, \CC is often used solely as a better C.
    251 Nevertheless, C, which was first standardized almost 30 \textcolor{blue}{CHANGE ``40'' TO ``30''} years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
     248Nevertheless, C, which was first standardized almost 30 years ago~\cite{ANSI89:C}, lacks many features that make programming in more modern languages safer and more productive.
    252249
    253250\CFA (pronounced ``C for all'' and written \CFA or Cforall) is an evolutionary extension of the C programming language that adds modern language features to C, while maintaining source and runtime compatibility in the familiar C programming model.
     
    281278ultimately, a compiler is necessary for advanced features and optimal performance.
    282279% The translator design is based on the \emph{visitor pattern}, allowing multiple passes over the abstract code-tree, which works well for incrementally adding new feature through additional visitor passes.
    283 Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into C code for a C compiler that supports none of these features.
     280Two key translator components are expression analysis, determining expression validity and what operations are required for its implementation, and code generation, dealing with multiple forms of overloading, polymorphism, and multiple return values by converting them into the C code for a C compiler that supports none of these features.
    284281Details of these components are available in chapters 2 and 3 in the work of Bilson~\cite{Bilson03} and form the base for the current \CFA translator.
    285282% @plg2[8]% cd cfa-cc/src; cloc libcfa
     
    345342Section~\ref{sec:libraries} includes a number of examples of how this overloading simplifies \CFA programming relative to C.
    346343Code generation for these overloaded functions and variables is implemented by the usual approach of mangling the identifier names to include a representation of their type, while \CFA decides which overload to apply based on the same ``usual arithmetic conversions'' used in C to disambiguate operator overloads.
    347 \textcolor{blue}{REMOVE ``We have the following as an example''}
     344
    348345\newpage
    349 \textcolor{blue}{UPDATE FOLLOWING PROGRAM EXAMPLE WITH ADJUSTED COMMENTS TO FIT PAGE WIDTH.}
    350346\begin{cfa}
    351347int max = 2147483647;                                           $\C[4in]{// (1)}$
     
    362358In some cases, hundreds of names can be reduced to tens, resulting in a significant cognitive reduction.
    363359In the above, the name @max@ has a consistent meaning, and a programmer only needs to remember the single concept: maximum.
    364 To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler use @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada).
     360To prevent significant ambiguities, \CFA uses the return type in selecting overloads, \eg in the assignment to @m@, the compiler uses @m@'s type to unambiguously select the most appropriate call to function @max@ (as does Ada).
    365361As is shown later, there are a number of situations where \CFA takes advantage of available type information to disambiguate, where other programming languages generate ambiguities.
    366362
     
    380376\label{sec:poly-fns}
    381377
    382 The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name). \textcolor{blue}{REMOVE ``as follows''}
     378The signature feature of \CFA is parametric-polymorphic functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a @forall@ clause (giving the language its name).
    383379\begin{cfa}
    384380`forall( otype T )` T identity( T val ) { return val; }
     
    395391
    396392Since bare polymorphic types provide a restricted set of available operations, \CFA provides a \newterm{type assertion}~\cite[pp.~37-44]{Alphard} mechanism to provide further type information, where type assertions may be variable or function declarations that depend on a polymorphic type variable.
    397 For example, the function @twice@ can be defined using the \CFA syntax for operator overloading. \textcolor{blue}{REMOVE ``as follows''}
     393For example, the function @twice@ can be defined using the \CFA syntax for operator overloading.
    398394\begin{cfa}
    399395forall( otype T `| { T ?+?(T, T); }` ) T twice( T x ) { return x `+` x; }  $\C{// ? denotes operands}$
     
    409405Crucial to the design of a new programming language are the libraries to access thousands of external software features.
    410406Like \CC, \CFA inherits a massive compatible library base, where other programming languages must rewrite or provide fragile interlanguage communication with C.
    411 A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array. \textcolor{blue}{REMOVE ``as follows''}
     407A simple example is leveraging the existing type-unsafe (@void *@) C @bsearch@ to binary search a sorted float array.
    412408\begin{cfa}
    413409void * bsearch( const void * key, const void * base, size_t nmemb, size_t size,
     
    605601To enable interoperation among equivalent instantiations of a generic type, the translator saves the set of instantiations currently in scope and reuses the generated structure declarations where appropriate.
    606602A function declaration that accepts or returns a concrete generic type produces a declaration for the instantiated structure in the same scope, which all callers may reuse.
    607 For example, the concrete instantiation for @pair( const char *, int )@ is \textcolor{blue}{REMOVE ``as follows.''}
     603For example, the concrete instantiation for @pair( const char *, int )@ is
    608604\begin{cfa}
    609605struct _pair_conc0 {
     
    634630If a dynamic generic type is declared to be passed or returned by value from a polymorphic function, the translator can safely assume that the generic type is complete (\ie has a known layout) at any call site, and the offset array is passed from the caller;
    635631if the generic type is concrete at the call site, the elements of this offset array can even be statically generated using the C @offsetof@ macro.
    636 As an example, the body of the second @value@ function is implemented as \textcolor{blue}{REMOVE ``follows.''}
     632As an example, the body of the second @value@ function is implemented as
    637633\begin{cfa}
    638634_assign_T( _retval, p + _offsetof_pair[1] ); $\C{// return *p.second}$
     
    640636\newpage
    641637\noindent
    642 \textcolor{blue}{NO PARAGRAPH INDENT} Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types.
     638Here, @_assign_T@ is passed in as an implicit parameter from @otype T@, and takes two @T *@ (@void *@ in the generated code), a destination and a source, and @_retval@ is the pointer to a caller-allocated buffer for the return value, the usual \CFA method to handle dynamically sized return types.
    643639@_offsetof_pair@ is the offset array passed into @value@;
    644 this array is generated at the call site as \textcolor{blue}{REMOVE ``follows.''}
     640this array is generated at the call site as
    645641\begin{cfa}
    646642size_t _offsetof_pair[] = { offsetof( _pair_conc0, first ), offsetof( _pair_conc0, second ) }
     
    677673
    678674Another useful pattern enabled by reused dtype-static type instantiations is zero-cost \newterm{tag structures}.
    679 Sometimes, information is only used for type checking and can be omitted at runtime. \textcolor{blue}{REMOVE ``As an example, we have the following''}
     675Sometimes, information is only used for type checking and can be omitted at runtime.
    680676\begin{cquote}
    681677\lstDeleteShortInline@%
     
    724720Both approaches are awkward.
    725721% FIX
    726 Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following. \textcolor{blue}{REPLACE ``in \CFA, we have the following'' WITH ``\CFA provides the following''}
     722Alternatively, a programming language can directly support returning multiple values, \eg \CFA provides the following.
    727723\begin{cfa}
    728724[ int, int ] div( int num, int den );           $\C{// return two integers}$
     
    745741As such, \CFA allows assigning multiple values from a function into multiple variables, using a square-bracketed list of lvalue expressions (as above), called a \newterm{tuple}.
    746742
    747 However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following. \textcolor{blue}{REPLACE ``As an example, we have the following'' WITH ``\CFA provides the following''}
     743However, functions also use \newterm{composition} (nested calls), with the direct consequence that MRVFs must also support composition to be orthogonal with single-returning-value functions (SRVFs), \eg, \CFA provides the following.
    748744\begin{cfa}
    749745printf( "%d %d\n", div( 13, 5 ) );                      $\C{// return values seperated into arguments}$
     
    781777printf( "%d %d\n", qr );
    782778\end{cfa}
    783 \CFA also supports \newterm{tuple indexing} to access single components of a tuple expression. \textcolor{blue}{REMOVE ``as follows''}
     779\CFA also supports \newterm{tuple indexing} to access single components of a tuple expression.
    784780\begin{cfa}
    785781[int, int] * p = &qr;                                           $\C{// tuple pointer}$
     
    809805In the call to @f@, @x@ is implicitly flattened so the components of @x@ are passed as two arguments.
    810806In the call to @g@, the values @y@ and @10@ are structured into a single argument of type @[int, int]@ to match the parameter type of @g@.
    811 Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component \textcolor{blue}{CHANGE ``components'' TO ``component''} of @x@ and @y@ are structured into the second argument of type @[int, int]@.
    812 The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs \textcolor{blue}{REMOVE ``and''} with any number of arguments of arbitrarily complex structure.
     807Finally, in the call to @h@, @x@ is flattened to yield an argument list of length 3, of which the first component of @x@ is passed as the first parameter of @h@, and the second component of @x@ and @y@ are structured into the second argument of type @[int, int]@.
     808The flexible structure of tuples permits a simple and expressive function call syntax to work seamlessly with both SRVFs and MRVFs with any number of arguments of arbitrarily complex structure.
    813809
    814810
    815811\subsection{Tuple assignment}
    816812
     813\enlargethispage{-10pt}
    817814An assignment where the left side is a tuple type is called \newterm{tuple assignment}.
    818815There are two kinds of tuple assignment depending on whether the right side of the assignment operator has a tuple type or a nontuple type, called \newterm{multiple} and \newterm{mass assignment}, respectively.
     
    828825Both kinds of tuple assignment have parallel semantics, so that each value on the left and right sides is evaluated before any assignments occur.
    829826As a result, it is possible to swap the values in two variables without explicitly creating any temporary variables or calling a function, \eg, @[x, y] = [y, x]@.
    830 This semantics means mass assignment differs from C cascading
    831 \newpage
    832 assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment.
     827This semantics means mass assignment differs from C cascading assignment (\eg @a = b = c@) in that conversions are applied in each individual assignment, which prevents data loss from the chain of conversions that can happen during a cascading assignment.
    833828For example, @[y, x] = 3.14@ performs the assignments @y = 3.14@ and @x = 3.14@, yielding @y == 3.14@ and @x == 3@, whereas C cascading assignment @y = x = 3.14@ performs the assignments @x = 3.14@ and @y = x@, yielding @3@ in @y@ and @x@.
    834829Finally, tuple assignment is an expression where the result type is the type of the left-hand side of the assignment, just like all other assignment expressions in C.
     
    857852[int, int, int] y = x.[2, 0, 2];                        $\C{// duplicate: [y.0, y.1, y.2] = [x.2, x.0.x.2]}$
    858853\end{cfa}
    859 It is also possible for a member access to contain other member accesses. \textcolor{blue}{REMOVE ``, as follows.''}
     854It is also possible for a member access to contain other member accesses.
    860855\begin{cfa}
    861856struct A { double i; int j; };
     
    969964Since nothing is known about a parameter pack by default, assertion parameters are key to doing anything meaningful.
    970965Unlike variadic templates, @ttype@ polymorphic functions can be separately compiled.
    971 For example, the following is a \textcolor{blue}{CHANGE ``As an example, we have the following'' TO ``For example, the following is a''} generalized @sum@ function.
     966For example, the following is a generalized @sum@ function.
    972967\begin{cfa}
    973968int sum$\(_0\)$() { return 0; }
     
    1003998Unlike C variadic functions, it is unnecessary to hard code the number and expected types.
    1004999Furthermore, this code is extendable for any user-defined type with a @?+?@ operator.
    1005 Summing \textcolor{blue}{REMOVE ``up''} arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators.
     1000Summing arbitrary heterogeneous lists is possible with similar code by adding the appropriate type variables and addition operators.
    10061001
    10071002It is also possible to write a type-safe variadic print function to replace @printf@:
     
    10391034Tuples are implemented in the \CFA translator via a transformation into \newterm{generic types}.
    10401035For each $N$, the first time an $N$-tuple is seen in a scope, a generic type with $N$ type parameters is generated.
    1041 For example, the following \textcolor{blue}{CHANGE ``, as follows:'' TO ``For example, the following''}
     1036For example, the following
    10421037\begin{cfa}
    10431038[int, int] f() {
     
    15191514\end{cfa}
    15201515
    1521 \textcolor{blue}{PARAGRAPH INDENT} Finally, \CFA provides a Java-like  @finally@ clause after the catch clauses.
     1516Finally, \CFA provides a Java-like  @finally@ clause after the catch clauses.
    15221517\begin{cfa}
    15231518try {
     
    16551650
    16561651C declaration syntax is notoriously confusing and error prone.
    1657 For example, many C programmers are confused by a declaration as simple as the following. \textcolor{blue}{CHANGE ``simple a declaration as in'' TO ``declaration as simple as''}
     1652For example, many C programmers are confused by a declaration as simple as the following.
    16581653\begin{cquote}
    16591654\lstDeleteShortInline@%
     
    17091704% Specifically, the character @*@ is used to indicate a pointer, square brackets @[@\,@]@ are used to represent an array or function return value, and parentheses @()@ are used to indicate a function parameter.
    17101705However, unlike C, \CFA type declaration tokens are distributed across all variables in the declaration list.
    1711 For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as \textcolor{blue}{REMOVE ``follows.''}
     1706For instance, variables @x@ and @y@ of type pointer to integer are defined in \CFA as
    17121707\begin{cquote}
    17131708\lstDeleteShortInline@%
     
    19591954Since \CFA in not object oriented, adopting dynamic scoping does not make sense;
    19601955instead, \CFA adopts \CC static nesting, using the member-selection operator ``@.@'' for type qualification, as does Java, rather than the \CC type-selection operator ``@::@'' (see Figure~\ref{f:TypeNestingQualification}).
     1956In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
     1957In the \CFA right example, the types are not hoisted and accessible.
    19611958
    19621959\begin{figure}
     
    20282025\vspace*{-8pt}
    20292026\end{figure}
    2030 
    2031 In the C left example, types @C@, @U@ and @T@ are implicitly hoisted outside of type @S@ into the containing block scope.
    2032 In the \CFA right example, the types are not hoisted and accessible.
    20332027
    20342028
     
    20662060For details of the code-generation placement of implicit constructor and destructor calls among complex executable statements, see section~2.2 in the work of Schlintz~\cite{Schluntz17}.
    20672061
    2068 \CFA also provides syntax for \newterm{initialization} and \newterm{copy}. \textcolor{blue}{REMOVE ``, as follows''}
     2062\CFA also provides syntax for \newterm{initialization} and \newterm{copy}.
    20692063\begin{cfa}
    20702064void ?{}( VLA & vla, int size, char fill = '\0' ) {  $\C{// initialization}$
     
    21312125
    21322126A simple example is allowing the underscore, as in Ada, to separate prefixes, digits, and suffixes in all \CFA constants, \eg @0x`_`1.ffff`_`ffff`_`p`_`128`_`l@, where the underscore is also the standard separator in C identifiers.
    2133 \CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most \textcolor{blue}{Q2 CHANGE ``IDEs'' TO ``integrated development environments (IDEs)''}, which must be extended to deal with this alternate use of the single quote.
     2127\CC uses a single quote as a separator, but it is restricted among digits, precluding its use in the literal prefix or suffix, \eg @0x1.ffff@@`'@@ffffp128l@, and causes problems with most integrated development environments (IDEs), which must be extended to deal with this alternate use of the single quote.
    21342128
    21352129
     
    22032197y = "12345678901234567890123456789"|`mp| + "12345678901234567890123456789"|`mp|;
    22042198\end{cfa}
    2205 Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT \textsf{'}} denotes a postfix-function name and @`@ \textcolor{blue}{USE CHARACTER \lstinline@`@ NOT `} denotes a postfix-function call.
     2199Because \CFA uses a standard function, all types and literals are applicable, as well as overloading and conversions, where @?`@ denotes a postfix-function name and @`@ denotes a postfix-function call.
    22062200}%
    22072201\begin{cquote}
     
    23452339\lstMakeShortInline@%
    23462340\end{cquote}
    2347 The result is a significant reduction in names to access typed constants. \textcolor{blue}{REMOVE ``, as follows.''}
     2341The result is a significant reduction in names to access typed constants.
    23482342\begin{cquote}
    23492343\lstDeleteShortInline@%
     
    23902384\lstMakeShortInline@%
    23912385\end{cquote}
    2392 The result is a significant reduction in names to access math functions. \textcolor{blue}{REMOVE ``, as follows.''}
     2386The result is a significant reduction in names to access math functions.
    23932387\begin{cquote}
    23942388\lstDeleteShortInline@%
     
    24372431\lstMakeShortInline@%
    24382432\end{cquote}
    2439 The result is a significant reduction in names to access the utility functions. \textcolor{blue}{REMOVE ``, as follows.''}
     2433The result is a significant reduction in names to access the utility functions.
    24402434\begin{cquote}
    24412435\lstDeleteShortInline@%
     
    24582452In addition, there are polymorphic functions, like @min@ and @max@, that work on any type with operator @?<?@ or @?>?@.
    24592453
    2460 The following shows one example where \CFA \textcolor{blue}{ADD SPACE} \emph{extends} an existing standard C interface to reduce complexity and provide safety.
     2454The following shows one example where \CFA \emph{extends} an existing standard C interface to reduce complexity and provide safety.
    24612455C/\Celeven provide a number of complex and overlapping storage-management operations to support the following capabilities.
    24622456\begin{list}{}{\itemsep=0pt\parsep=0pt\labelwidth=0pt\leftmargin\parindent\itemindent-\leftmargin\let\makelabel\descriptionlabel}
     
    26492643\label{s:MultiPrecisionIntegers}
    26502644
    2651 \CFA has an interface to the \textcolor{blue}{Q3 CHANGE ``GMP multiprecision'' TO ``GNU multiple precision (GMP)''} signed integers~\cite{GMP}, similar to the \CC interface provided by GMP.
     2645\CFA has an interface to the GNU multiple precision (GMP) signed integers~\cite{GMP}, similar to the \CC interface provided by GMP.
    26522646The \CFA interface wraps GMP functions into operator functions to make programming with multiprecision integers identical to using fixed-sized integers.
    26532647The \CFA type name for multiprecision signed integers is @Int@ and the header file is @gmp@.
     
    27422736Figure~\ref{fig:eval} and Table~\ref{tab:eval} show the results of running the benchmark in Figure~\ref{fig:BenchmarkTest} and its C, \CC, and \CCV equivalents.
    27432737The graph plots the median of five consecutive runs of each program, with an initial warm-up run omitted.
    2744 All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen. \textcolor{blue}{CHANGE ``\CC{}fourteen'' TO ``\CCfourteen''}
    2745 The benchmarks are run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz \textcolor{blue}{REMOVE ``of''} maximum clock frequency.
     2738All code is compiled at \texttt{-O2} by gcc or g++ 6.4.0, with all \CC code compiled as \CCfourteen.
     2739The benchmarks are run on an Ubuntu 16.04 workstation with 16 GB of RAM and a 6-core AMD FX-6300 CPU with 3.5 GHz maximum clock frequency.
    27462740
    27472741\begin{figure}
     
    27702764\end{table}
    27712765
     2766\enlargethispage{-10pt}
    27722767The C and \CCV variants are generally the slowest with the largest memory footprint, due to their less-efficient memory layout and the pointer indirection necessary to implement generic types;
    27732768this inefficiency is exacerbated by the second level of generic types in the pair benchmarks.
     
    28602855Tuples are a generalization of @std::pair@, in that they allow for arbitrary length, fixed-size aggregation of heterogeneous values.
    28612856Operations include @std::get<N>@ to extract values, @std::tie@ to create a tuple of references used for assignment, and lexicographic comparisons.
    2862 \CCseventeen \textcolor{blue}{CHANGE ``\CC{}seventeen TO ``\CCseventeen''} proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.
     2857\CCseventeen proposes \emph{structured bindings}~\cite{Sutter15} to eliminate predeclaring variables and the use of @std::tie@ for binding the results.
    28632858This 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.
    28642859Furthermore, structured bindings are not a full replacement for @std::tie@, as it always declares new variables.
Note: See TracChangeset for help on using the changeset viewer.