Functional Design Explained - David Sankel - CppCon 2015

Functional
Design
Explained
David Sankel - Stellar Science
[email protected]
CppCon 2015
1
Math Engineering
2
Quiz
Are the following two C++ programs the same?
David Sankel Stellar Science 3

Quiz
Are the following two C++ programs the same?
#include <iostream> #include <iostream>
int main( int argc, char** argv ) int main( int argc, char** argv )
{ {
std::cout << “Hello World\n”; std:: cout << “Hello World\n”;
} }

Quiz
Are the following two programs the same?
#include <iostream> #!/usr/bin/env python
int main( int argc, char** argv ) print(“Hello World”)

{
std::cout << “Hello World\n”;
}

Quiz
Are the following two programs the same?
int f( int c ) int f( int c )

{ {
if( false ) int j = 5;
return 45; j += c;
else return j;
return c + 5; }
}

Essence of Programs
Ideally we would like:
• Strong equivalence properties
• Something written down
• A set of rules we can apply to any program
Any ideas of what would be a good essence language?

How about math?
3+2=5
5=3+2

Denotational Semantics
Developed by Dana Scott and Christopher Strachey in late 1960s
Write a mathematical function to convert syntax to meaning (in

math).
μ⟦e₁ + e₂⟧ = μ⟦e₁ ⟧ + μ⟦e₂⟧ where eᵢ is an expression

μ⟦i⟧ = i where i is an integer

What is the meaning of this?
int f( int c )
{
if( false )
return 45;
else
return c + 5;
}

Function Meaning
We could represent a int f( int c )
{
function as a set of pairs
if( false )
As in: return 45;
else
return c + 5;
{ …,(-1,4), (0,5), (1,6),…}
}
Or as a lambda equation: λc. c + 5
Or something else: f(c) = c + 5

Function Meaning
What about this?
int f( int c )
{
for(;;) ;
return 45;
}
…,(-1, ⊥),(0,⊥),(1, ⊥),…
⊥ is “bottom”

The Next 700 Programming
Languages
P. J. Landin wrote in 1966 about his programming language
ISWIM (If you See What I Mean)
f(b+2c) + f(2b-c)
where f(x) = x(x+a)

Why not drop the C++
nonsense and go Haskell?
Quicksort 160,000 ints
0.6
0.4
0.2
0
Haskell C++
Haskell variant with optimizations: 0.41s

C++ variant without optimizations: 0.16s
Languages and Machines

Semantics Discovery
• Discover the mathematical essence of
a problem and derive an
implementation.
• Conal Elliott, various applications of
semantics discovery throughout career.
• See ‘Denotational design with type
class morphisms’.

Ingredients
• Math augmented with some extra constructs can represent
the essence of code.
• Write programs in math.
• C++ straddles more levels of abstraction than any other
language.
• Discover essence of problem using math and derive
implementation.

Functional Design
1. Discover the mathematical essence of the problem and write
it out.
2. Derive an efficient implementation in C++ that has the
interface discovered in #1.

Algebraic Data Types
• Mathematical fundamentals of base types.
• Two types, 1 and 0
• Two ops, ⊕ and ⊗, to compose them

0 Type
0 is the type with no values
struct Zero {
Zero() = delete;
};

1 Type
1 is the type with one value
struct One {};

Product
Given types ‘a’ and ‘b’, the product of ‘a’ and ‘b’ (a ⊗ b) is a type
whose values have an ‘a’ and a ‘b’.
using AAndB = std::pair<A,B>;
using AAndB = std::tuple<A,B>;
struct AAndB {
A a;
B b;
};

Product
Is this an implementation of a ⊗ b?
struct AAndB {
std::unique_ptr<A> a;
std::unique_ptr b;
};

Sum
A ⊕ B is a type whose values are either a value of type ‘A’ or a value of type
‘B’.
struct AOrB {
bool hasA;
union {
A a;
B b;
} contents; // ‘a’ when ‘hasA==true’
// otherwise ‘b’.
};
using AOrB = boost::variant< A, B >;
using AOrB = std::variant< A, B >; // hopefully

Function Type
A → B is a type whose values are pure functions with an input
type A and an return type B.
using FunctionAB = std::function;

Meaning
μ⟦ syntax ⟧ = mathExpression
The meaning of “syntax” is the math expression
μ⟦ expression ⟧ : mathExpression
The type of “expression” is the math expression
μ⟦ int ⟧ = ℤ
μ⟦ 3 ⟧ : ℤ
μ⟦ 3 ⟧ = 3

Some Examples
μ⟦ boost::optional<e₁> ⟧ = μ⟦ e₁ ⟧ ⊕ 1
μ⟦ std::pair<e₁,e₂> ⟧ = μ⟦ e₁ ⟧ ⊗ μ⟦ e₂ ⟧
μ⟦ double ⟧ = ℝ
or maybe
μ⟦ double ⟧ = ℝ ⊕ 1⊕ 1⊕ 1
where the extra states are -∞, +∞, and NaN

What is a movie?

What is a movie?
μ⟦ Movie<e> ⟧ = ℝ → μ⟦ e ⟧
Operations:
μ⟦ always<e> ⟧ : μ⟦ e ⟧ → μ⟦ Movie<e> ⟧
μ⟦ always<e>(a) ⟧ = λ t. μ⟦ a ⟧
μ⟦ snapshot<e> ⟧ : μ⟦Movie<e>⟧ → ℝ → A
μ⟦ snapshot<e>(movie, time) ⟧ = μ⟦ movie ⟧ ( μ⟦ time ⟧ )
μ⟦ transform<A,B> ⟧ : (μ⟦A⟧ → μ⟦B⟧) → μ⟦Movie<A>⟧ → μ⟦Movie⟧
μ⟦ timeMovie ⟧ : μ⟦ Movie<double> ⟧
μ⟦ timeMovie ⟧ = λ t. t

Grey flux movie
auto greyFluxMovie = transform(
[]( double timeInSeconds ) -> Image {
double dummy;
double greyness = std::modf( timeInSeconds, &dummy );
return greyImage( greyness );
, time );

What is a stream?

What is a stream?
Let ‘Action’ be some side-effecting operation.
μ⟦ sink<e> ⟧ = μ⟦ e ⟧ → Action
μ⟦ source<e> ⟧ = (μ⟦ e ⟧ → Action) → Action
template< typename T >

using sink = std::function<void ( const T & )>;
template< typename T >

using source = std::function<void ( sink<T> ) >;

Example source/sink
source<char> consoleInput = []( sink<char> s ) {
int inputChar;
while( (inputChar = std::cin.get()) != EOF ) {
s( static_cast< char >( inputChar ) );
};
sink<char> consoleOutput = []( char c ) {

std::cout.put( c );
};

Connecting Sources and Sinks
μ⟦ connect<e> ⟧ : μ⟦ source<e> ⟧ → μ⟦ sink<e> ⟧ → Action
μ⟦ connect<e>( so, si ) ⟧ = μ⟦ so ⟧( μ⟦ si ⟧ )
template< typename t >

void connect( source<t> so, sink<t> si ) {
so( si );
}
int main( int argc, char** argv ) {

connect( consoleInput, consoleOutput );
}

Transforming Streams
μ⟦ sink<e> ⟧ = μ⟦ e ⟧ → Action
μ⟦ transform<a,b> ⟧ = μ⟦ Sink ⟧ → μ⟦ Sink<a> ⟧

= μ⟦ Sink ⟧ → (μ⟦ a ⟧ → Action)
= μ⟦ Sink ⟧ → μ⟦ a ⟧ → Action
template< typename a, typename b >

using transform = std::function<void ( sink, a ) >;

Application of Transforms
μ⟦ transform<a,b> ⟧ = μ⟦ sink ⟧ → μ⟦ a ⟧ → Action
μ⟦ applyToSink<a,b> ⟧
: μ⟦ transform<a,b> ⟧ → μ⟦ sink ⟧ → μ⟦ sink<a> ⟧
μ⟦ applyToSource<a,b> ⟧
: μ⟦ transform<a,b> ⟧ → μ⟦ source<a> ⟧ → μ⟦ source ⟧
μ⟦ so >> t ⟧ = μ⟦ applyToSource<a,b> ⟧( t, so );
μ⟦ t >> si ⟧ = μ⟦ applyToSink<a,b> ⟧( t, si );
μ⟦ so >> si ⟧ = μ⟦ connect<t> ⟧( so, si );

Tranformers Continued…
transformer<char, std::string> getLines = //…
transformer<std::string, char> unWords = //…
source<string> inputLines = consoleInput >> getLines;

sink<string> wordOutput = unwords >> consoleOutput;
InputLines >> wordOutput;
transformer<char,char> linesToSpaces = getLines >> unwords;

What is command line
processing?

What is command line
processing?
μ⟦ CommandLineProcessor<a> ⟧ = ListOf String → μ⟦ a ⟧ ?
Hrm…
μ⟦ Parser<a,b> ⟧ = ListOf μ⟦ a ⟧ → μ⟦ b ⟧
μ⟦ CommandLineProcessor<a> ⟧ = μ⟦ Parser<String,b> ⟧

Command Line Parsing
struct HelpFlag{};
struct UserFlag{
std::string user;
};
auto flagP = mix(

args(“--help”, HelpFlag()),
args(“--user“ >> stringP,
[]( std::string username ) { return UserFlag{username}; })

Command Line Parsing
struct ListAccounts {};
struct ListJob {
int jobId;
};
struct CommandLineParse {
std::vector< boost::variant< HelpFlag, UserFlag > > globalFlags;
boost::variant< ListAccounts, ListJob > mode;
};
auto parser = flagP

>> (args( “listAccounts”, ListAccounts() ) ||
(args( “listJob” ) >> “--jobId” >> intP( []( int id ) { return ListJob{id};}));

Benefits
• Highly Flexible
• Highly Composible
• Type safe
• Simple

Functional
Design
1. Discover the essence

2. Derive the
implementation
• Beautiful API’s
• Screaming Speed
David Sankel [email protected] Stellar Science 43

Functional Design Explained - David Sankel - CppCon 2015

Uploaded by

Copyright:

Available Formats

Functional Design Explained - David Sankel - CppCon 2015

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Functional Design Explained - David Sankel - CppCon 2015

Uploaded by

Copyright:

Available Formats

Functional

David Sankel Stellar Science 3

#include <iostream> #include <iostream>

David Sankel Stellar Science 4

#include <iostream> #!/usr/bin/env python

int main( int argc, char** argv ) print(“Hello World”)

David Sankel Stellar Science 5

int f( int c ) int f( int c )

David Sankel Stellar Science 6

Any ideas of what would be a good essence language?

David Sankel Stellar Science 7

David Sankel Stellar Science 8

Write a mathematical function to convert syntax to meaning (in

μ⟦e₁ + e₂⟧ = μ⟦e₁ ⟧ + μ⟦e₂⟧ where eᵢ is an expression

David Sankel Stellar Science 9

David Sankel Stellar Science 10

Or as a lambda equation: λc. c + 5

Or something else: f(c) = c + 5

David Sankel Stellar Science 11

…,(-1, ⊥),(0,⊥),(1, ⊥),…

David Sankel Stellar Science 12

David Sankel Stellar Science 13

Haskell variant with optimizations: 0.41s

David Sankel Stellar Science 15

David Sankel Stellar Science 16

David Sankel Stellar Science 17

David Sankel Stellar Science 18

David Sankel Stellar Science 19

David Sankel Stellar Science 20

struct One {};

David Sankel Stellar Science 21

using AAndB = std::pair<A,B>;

using AAndB = std::tuple<A,B>;

David Sankel Stellar Science 22

David Sankel Stellar Science 23

using AOrB = boost::variant< A, B >;

using AOrB = std::variant< A, B >; // hopefully

David Sankel Stellar Science 24

using FunctionAB = std::function<B (A)>;

David Sankel Stellar Science 25

David Sankel Stellar Science 26

David Sankel Stellar Science 27

David Sankel Stellar Science 28

μ⟦ transform<A,B> ⟧ : (μ⟦A⟧ → μ⟦B⟧) → μ⟦Movie<A>⟧ → μ⟦Movie<B>⟧

David Sankel Stellar Science 29

David Sankel Stellar Science 30

David Sankel Stellar Science 31

template< typename T >

template< typename T >

David Sankel Stellar Science 32

sink<char> consoleOutput = []( char c ) {

David Sankel Stellar Science 33

template< typename t >

int main( int argc, char** argv ) {

David Sankel Stellar Science 34

μ⟦ transform<a,b> ⟧ = μ⟦ Sink<b> ⟧ → μ⟦ Sink<a> ⟧

template< typename a, typename b >

David Sankel Stellar Science 35

David Sankel Stellar Science 36

source<string> inputLines = consoleInput >> getLines;