The Curiously Recurring Pattern of Coupled Types

@bjorn_fahller :: @adishavit
The Curiously Recurring
Coupled Types Pattern
Adi Shavit and Björn Fahller
@adishavit :: @bjorn_fahller

View Slide

Curious API Pattern Examples

View Slide

v1
Vec2D v1{...};
2D Space

View Slide

v1
v2
Vec2D v1{...};
Vec2D v2{...};
2D Space

View Slide

v1
v2
v3
Vec2D v1{...};
Vec2D v2{...};
auto v3 = v1+v2;
2D Space

View Slide

v1
v2
v1 + v2
-v2
Vec2D v1{...};
Vec2D v2{...};
auto v3 = v1+v2;
-v2;
2D Space

View Slide

v1
v2
v1 + v2
-v2
v1 - v2 Vec2D v1{...};
Vec2D v2{...};
auto v3 = v1+v2;
auto v4 = v1-v2;
2D Space

View Slide

v1
v2
v1 + v2
-v2
v1 - v2
2 * v2
Vec2D v1{...};
Vec2D v2{...};
auto v3 = v1+v2;
auto v4 = v1-v2;
auto v5 = 2*v2;
2D Space

View Slide

v1
v2
v1 + v2
-v2
v1 - v2
2 * v2
Vec2D v1{...};
Vec2D v2{...};
auto v3 = v1+v2;
auto v4 = v1-v2;
auto v5 = 2*v2;
v1 * v2
2D Space

View Slide

p1
Position p1{...};
2D Space

View Slide

Position p1{...};
Position p2{...};
p1
p2
2D Space

View Slide

Position p1{...};
Position p2{...};
p2 - p1;
p1
p2
p2 - p1
2D Space

View Slide

Position p1{...};
Position p2{...};
Vec2D v = p2 - p1;
p1
p2
p2 - p1
2D Space

View Slide

Position p1{...};
Position p2{...};
Vec2D v = p2 - p1;
Vec2D v2{...};
v2
p1
p2
p2 - p1
2D Space

View Slide

Position p1{...};
Position p2{...};
Vec2D v = p2 - p1;
Vec2D v2{...};
auto p3 = p1 + v2;
p3
v2
p1
p2
p2 - p1
2D Space

View Slide

Position p1{...};
Position p2{...};
Vec2D v = p2 - p1;
Vec2D v2{...};
auto p3 = p1 + v2;
p3 + p2
p3
v2
p1
p2
p2 - p1
2D Space

View Slide

Do we have time?

View Slide


View Slide


?

View Slide


View Slide


timepoint timepoint duration

View Slide


timepoint timepoint
?

View Slide


timepoint
timepoint
duration

View Slide

Pointer Arithmetic

View Slide

Let’s dive into pointer arithmetics!
A array[] =

View Slide

Pointer arithmetics!
A array[] =
A* p1 =

View Slide

A array[] =
A* p1 =
A* p2 =

View Slide

A array[] =
A* p1 =
A* p2 =
auto d = p2 - p1

View Slide

A array[] =
A* p1 =
A* p2 =
auto d = p2 - p1
auto s = p2 + p1

View Slide

A array[] =
A* p1 =
A* p2 =
auto d = p2 - p1
auto x = p2 - d

View Slide

Are we seeing it yet?

View Slide

Meanwhile on Twitter...

View Slide

The Affine Space
Intuitively:
1. A point: a position specified with coordinate values
○ a.k.a. location, address...
2. A vector: the difference between two points
○ a.k.a. shift, offset, displacement, duration...
If an origin is specified, then a point can be represented by a vector from the origin, however, a point
is still not a vector in coordinate-free concepts.

View Slide

The Affine Space: Definitions
affine space points vectors scalars
vector space
scalar
affine space
v p q
■ p-q=v
■ p+v=q

View Slide

The Affine Space Type API
Point Vector Scalar
Vector operations
Vector + Vector -> Vector
scalar * Vector -> Vector
Vector * Scalar -> Vector
Vector - Vector -> Vector
-Vector -> Vector
Affine operations
Point - Point -> Vector
Point + Vector -> Point
Point - Vector -> Point

View Slide


View Slide

using namespace std::chrono;
auto beg = system_clock::now(); // start time
// ...
auto end = system_clock::now(); // end time
auto dur = end - beg; // total duration
auto almost = beg + dur - 1ms; // just before end
auto next = beg + 2*dur; // twice as long
auto ago = beg - end; // a negative time offset
auto utcnow = utc_clock::now(); // UTC time (C++20)
auto utcnxt = utcnow + 2*dur; // OK: when
auto meh = utcnow - beg; // ???

View Slide

using namespace std::chrono;
auto beg = system_clock::now(); // start time
// ...
auto end = system_clock::now(); // end time
auto dur = end - beg; // total duration
auto almost = beg + dur - 1ms; // just before end
auto next = beg + 2*dur; // twice as long
auto ago = beg - end; // a negative time offset
auto utcnow = utc_clock::now(); // UTC time (C++20)
auto utcnxt = utcnow + 2*dur; // OK: when
auto meh = utcnow - beg; // ERROR!

View Slide

Iterators

View Slide

Iterators
using T = float;
std::vector vec = {0,1,2,3};
auto beg = vec.begin();
auto end = vec.end();
int cnt = end - beg;
auto last = beg + cnt - 1;
int neg = beg - end;
using T = float;
std::set set={0,1,2,3};
auto beg = set.begin();
auto end = set.end();
auto cnt = std::distance(beg, end);
auto last = std::next(beg, cnt - 1);
auto neg = std::distance(end, beg);

View Slide

Counter Examples
using namespace cv;
Point pos = { 0,0 };
Point next_pos = pos + Point{Vec2i{ 42,0 }}; // WAT?
Point dir = next_pos - pos; // Umm..
Point huh = -pos; // Huh?
Point hmm = pos * 2; // Hmmm...

View Slide

Remember the Mars Climate Orbiter
pound-force seconds
newton seconds,

View Slide

An Imaginary GUI library

View Slide

using Size = Vec2D;
class Window {
public:
Window(Point bl, Size size);
...
...
};
Point p1{...};
Point p2{...};
Window w{p1, p2-p1};

View Slide

using Size = Vec2D;
class Window {
public:
void translate(Vec2D offset);
...
};
Point p1{...};
Point p2{...};
w.translate(p2-p1);

View Slide

using Size = Vec2D;
class Window {
public:
void translate(Vec2D offset);
void move_to(Point dst);
};
Point p1{...};
Point p2{...};
w.translate(p2-p1);
w.move_to(p1);

View Slide

Demo
github.com/rollbear/affine_types
gcc.godbolt.org/z/IJLKFG

View Slide

Affine Space Concepts
template
concept Affine_space = Regular and
Vector_space and
requires (P const& p, V const& v) {
{ p - p } -> V;
{ p + v } -> P;
{ p - v } -> P;
} and requires (P& p, V const& v) {
{ p += v } -> P&;
{ p -= v } -> P&;
};
} https://github.com/petter-holmberg/elements

View Slide

The Affine Combination
affine combination
1 ⇒ point
0 ⇒ vector
undefined
barycentric coordinates

View Slide

The Affine Combination
m=(a+b)/2 // midpoint
int a,b m=(a+b)/2
m
int* a; int* b; m=(a+b)/2
m=a+(b-a)/2
½*a+½*b ⇒ ← Affine Combination!
p q r
(p+q+r)/3 CoG = ⅓*p + ⅓*q + ⅓*r ⇒ ⅓ ⅓ ⅓

View Slide

Summary
● about the semantics to help build the types
● strong APIs:
⇔
○ ⇒ A semantically incorrect expression becomes a compilation error
● Affine-space type-relations are very common
● them and math delivers a powerful and consistent API
● : Learn more about the math of types: Abstract Algebra, Category Theory
When in doubt, do what does!

View Slide

Resources
● Affine Space Types: Adi Shavit, blog post (+many links)
○ videocortex.io/2018/Affine-Space-Types/
● Type safe C++ – LOL! :-) Björn Fahller, ACCU 2018
○ youtu.be/SWHvNvY-PHw
● Operator Overloading: History, Principles and Practice, Ben Deane, CppCon 2018
○ youtu.be/zh4EgO13Etg?t=831 (@13:53)
● Compiler Explorer “GUI” code example
○ gcc.godbolt.org/z/IJLKFG

View Slide

@adishavit @bjorn_fahller
@rollbear
@longbeard
The Curiously Recurring Pattern of Coupled Types

View Slide

Why can pointers be subtracted but not added?
What do raw C pointers, STL iterators, std::chrono types, and 2D/3D geometric primitives have in common?
In this talk we will present some curiously coupled data types that frequently occur in your programs, together forming notions that you are already intuitively familiar with. We will shine a light on the mathematical notion of Affine Spaces, and how they guide
stronger design. We will review the properties of affine spaces and show how they improve program semantics, stronger type safety and compile time enforcement of these semantics.
By showing motivational examples, we will introduce you to the mathematical notion of affine spaces. The main focus will then be on how affine space types and their well defined semantics shape expressive APIs.
We will give examples and guidelines for creating your own affine types.
* Show familiar examples of situations of affine space semantics
- pointer arithmetic
- iterators
- chrono
- coordinate systems
* Mathematical definitions/properties
* Describe properties of affine space types
- operators and relations
- [show a Concept for affine space types, tbd]
* Show how to write a simple affine space strong type template.
* Parallels to unit systems

View Slide

The Curiously Recurring Pattern of Coupled Types

The Curiously Recurring Pattern of Coupled Types

Björn Fahller

More Decks by Björn Fahller

Other Decks in Programming

Featured

Transcript