Index: doc/papers/general/Paper.tex
===================================================================
--- doc/papers/general/Paper.tex	(revision 2a8427c61128cfaed539e695bd10d0c71b358737)
+++ doc/papers/general/Paper.tex	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
@@ -41,6 +41,6 @@
 
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
-\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
-%\newcommand{\TODO}[1]{} % TODO elided
+%\newcommand{\TODO}[1]{\textbf{TODO}: {\itshape #1}} % TODO included
+\newcommand{\TODO}[1]{} % TODO elided
 
 % Default underscore is too low and wide. Cannot use lstlisting "literate" as replacing underscore
@@ -260,5 +260,6 @@
 \Celeven did add @_Generic@ expressions, which can be used in preprocessor macros to provide a form of ad-hoc polymorphism; however, this polymorphism is both functionally and ergonomically inferior to \CFA name overloading. 
 The macro wrapping the generic expression imposes some limitations; as an example, it could not implement the example above, because the variables @max@ would collide with the functions @max@. 
-Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names.
+Ergonomic limitations of @_Generic@ include the necessity to put a fixed list of supported types in a single place and manually dispatch to appropriate overloads, as well as possible namespace pollution from the functions dispatched to, which must all have distinct names. 
+Though name-overloading removes a major use-case for @_Generic@ expressions, \CFA does implement @_Generic@ for backwards-compatibility purposes. \TODO{actually implement that}
 
 % http://fanf.livejournal.com/144696.html
@@ -1984,7 +1985,7 @@
 
 In C, @0@ has the special property that it is the only ``false'' value; by the standard, any value which compares equal to @0@ is false, while any value that compares unequal to @0@ is true. 
-As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to an @&&@, @||@, or ternary operator) can be rewritten as @x != 0@ without changing its semantics.
+As such, an expression @x@ in any boolean context (such as the condition of an @if@ or @while@ statement, or the arguments to @&&@, @||@, or @?:@) can be rewritten as @x != 0@ without changing its semantics.
 The operator overloading feature of \CFA provides a natural means to implement this truth value comparison for arbitrary types, but the C type system is not precise enough to distinguish an equality comparison with @0@ from an equality comparison with an arbitrary integer or pointer. 
-To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that standard C code involving @0@ continues to work properly. 
+To provide this precision, \CFA introduces a new type @zero_t@ as type type of literal @0@ (somewhat analagous to @nullptr_t@ and @nullptr@ in \CCeleven); @zero_t@ can only take the value @0@, but has implicit conversions to the integer and pointer types so that C code involving @0@ continues to work properly. 
 With this addition, the \CFA compiler rewrites @if (x)@ and similar expressions to @if ((x) != 0)@ or the appropriate analogue, and any type @T@ can be made ``truthy'' by defining an operator overload @int ?!=?(T, zero_t)@.
 \CC makes types truthy by adding a conversion to @bool@; prior to the addition of explicit cast operators in \CCeleven this approach had the pitfall of making truthy types transitively convertable to any numeric type; our design for \CFA avoids this issue.
@@ -1993,5 +1994,4 @@
 The addition of @one_t@ allows generic algorithms to handle the unit value uniformly for types where that is meaningful. 
 \TODO{Make this sentence true} In particular, polymorphic functions in the \CFA prelude define @++x@ and @x++@ in terms of @x += 1@, allowing users to idiomatically define all forms of increment for a type @T@ by defining the single function @T & ?+=(T &, one_t)@; analogous overloads for the decrement operators are present as well.
-
 
 \subsection{Integral Suffixes}
Index: src/prelude/builtins.c
===================================================================
--- src/prelude/builtins.c	(revision 2a8427c61128cfaed539e695bd10d0c71b358737)
+++ src/prelude/builtins.c	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
@@ -23,4 +23,18 @@
 void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ ));
 void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ ));
+
+// increment/decrement unification
+
+static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
+T& ++? ( T& x ) { return x += 1; }
+
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
+T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
+
+static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
+T& --? ( T& x ) { return x -= 1; }
+
+static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
+T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
 
 // exponentiation operator implementation
Index: src/tests/.expect/counter.txt
===================================================================
--- src/tests/.expect/counter.txt	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
+++ src/tests/.expect/counter.txt	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
@@ -0,0 +1,2 @@
+45
+42
Index: src/tests/counter.c
===================================================================
--- src/tests/counter.c	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
+++ src/tests/counter.c	(revision 8f13c98e3b81021a6d2d3197832eb1cb7c5339df)
@@ -0,0 +1,40 @@
+// 
+// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+// 
+// counter.c -- 
+// 
+// Author           : Aaron B. Moss
+// Created On       : Thu Feb 22 15:27:00 2018
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Feb 22 15:27:00 2018
+// Update Count     : 1
+// 
+
+// Tests unified increment/decrement builtin functions.
+// Could be extended for other arithmetic unifications
+
+struct counter { int x; };
+
+counter& ?+=?( counter& c, one_t ) { ++c.x; return c; }
+
+counter& ?-=?( counter& c, one_t ) { --c.x; return c; }
+
+int main() {
+    counter c = { 42 };
+    c += 1;
+    ++c;
+    c++;
+    printf("%d\n", c.x);
+    c -= 1;
+    --c;
+    c--;
+    printf("%d\n", c.x);
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// compile-command: "cfa counter.c" //
+// End: //