CppCon 2020 Template Metaprogramming: Type Traits Part 1 Jody Hagins jhagins@maystreet.com coachhagins@gmail.com ## CppCon 2020 Template Metaprogramming: Type Traits Introduction ## I ntended Audience Not necessarily beginner to C++, but beginner to traditional template metaprogramming techniques • Type traits part of standard library for ~10 years ## I ntended Audience • Beginner/Intermediate • Gentle Not necessarily beginner to C++, but beginner to traditional template metaprogramming techniques • Type traits part of standard library for ~10 years • Fundamentals have been in use for ~20 years ## I

Promise, Deferred) • Deliver to a queue • Callback registry (e.g. POSIX signals) Regardless of which type of interface is used, asynchronous functions by definition interact differently with their callers; action="/myform" method="POST">' ' type="text" name="message"/> ' ' type="submit" value="Submit"/> ' ' ) ) def post(self): self.set_header("Content-Type", "text/plain") self.write("You wrote " + self.get_body_argument("message")) Since the HTML form

PropertyNotWritableException issue (SPR-11502) optimized handling of @Bean method override regression with return type narrowing on JDK 8 (SPR-11718) prevented double evaluation of method arguments in SpEL (SPR-11445) handle NoClassDefFoundError for TestExecution Listeners consistently (SPR-11347) * fixed @Bean meta-annotation detection when using ASM (SPR-10488) * provide access to SimpleTriggerFactoryBean property startTime enabled ServletTestExecutionListener by default in abstract base test classes (SPR-11340) * fixed type comparison in ReflectionHelper.]}\).]}\).]}\).]}\).]}\).]}\).]}\.]}\.]}\ * improved logging and exception

springframework.org Changes in version 2.0.1 (23.11.2006) ## General * included classes in the "test.annotation" and "test.jpa" packages (tiger mock directory) in the Spring API javadoc Package to depend on beans that in turn get advised by the same aspect * added @Order annotation support for @AspectJ style aspects, as alternative to implementing the Ordered interface * redesigned Package org.springframework.beans * fixed BeanWrapperImpl to correctly determine generic type for each key in a chain (e.g. "myMap[myKey][myInnerKey]") * introduced PatternEditor for

through a SerializedBeanFactoryReference * DefaultListableBeanFactory's getBean(name, type) attempts type conversion if necessary * DefaultListableBeanFactory allows for init methods to register further listener beans * optimized @Bean error messages for static factory methods as well as for argument * type mismatches * modified expression parsing to pass full TypeDescriptor context through to * ConversionService abstraction * added mode="proxy"/"aspectj" and proxy-target-class options to task:annotation-driven * JDBC bundle uses local ClassLoader as bean ClassLoader for "sql-error-codes.xml"

couldn't determine the type of the target bean (avoid NPE) * "scoped-proxy" tag works for non-Singleton FactoryBeans as well, leveraging the BeanFactory's improved type check * factored out TypeConverter * BeanWrapperImpl converts nested collection value (e.g. List within Map) to declared generic type, if applicable * BeanWrapperImpl's TypeMismatchException mentions the specific element that failed failed in case of a (generic) collection * BeanWrapperImpl assigns a given array directly if component type matches and no matching custom editors registered * added default editor for JDK 1.4's

manipulated like any other value. The standard example is the type of lists of a given length $ ^{1} $ , Vect n a, where a is the element type and n is the length of the list and can be an arbitrary term contain values, and where those values describe properties, for example the length of a list, the type of a function can begin to describe its own properties. Take for example the concatenation of two list's length is the sum of the lengths of the two input lists. We can therefore give the following type to the app function, which concatenates vectors: app : Vect n a -> Vect m a -> Vect (n + m)

Tokens 19 1.3 Syntax grammar 23 1.4 Documentation comments 42 2 Type system 43 Glossary 43 Introduction 44 2.1 Type kinds 45 2.1.1 Built-in types 46 kotlin.Any 46 kotlin.Nothing 46 types 48 2.1.3 Type parameters ..... 50 Function type parameters ..... 51 Mixed-site variance ..... 51 Declaration-site variance ..... 52 Use-site variance ..... 54 2.1.4 Type capturing .... . 55 2.1.5 Type containment ..... 60 2.1.6 Function types ..... 61 Suspending function types ..... 62 2.1.7 Flexible types ..... 63 Dynamic type ..... 64 Platform types ..... 64 2.1.8 Nullable

6 An Example: Abstract Syntax 36 4 Theorem Proving in Lean 38 4.1 Assertions in Dependent Type Theory 38 4.2 Propositions as Types 39 4.3 Induction and Calculation 42 4.4 Axioms 45 Lean is an implementation of a logical foundation known as dependent type theory. Specifically, it implements a version of dependent type theory known as the Calculus of Inductive Constructions. The CIC is expression has a type. The type of expression indicates what sort of object the expression denotes. For example, an expression may denote a mathematical object like a natural number, a data type, an assertion

of a certain type. The variable's type is called static type, the location's type is called dynamic type. If the static type is not the same as the dynamic type, it is a super-type or subtype of of the dynamic type. An identifier is a symbol declared as a name for a variable, type, procedure, etc. The region of the program over which a declaration applies is called the scope of the declaration mod nil not notin object of or out proc ptr raise ref return shl shr static template try tuple type using var when while xor yield Some keywords are unused; they are reserved for future developments