1. Pure
Kevin Edelmann

2. “Fun” facts Functional programming language
Syntactically similar to Haskell
Successor to the Q programming language
Dynamically typed

3. No Monads! using system; puts "Hello, world!";
Ironically, this makes Pure less “purely” functional
Then again, Scala allows “direct” printing as well
But it’s also easier to read and use!
using system;
puts "Hello, world!";

4. Rewriting A Pure program is a collection of equations.
Equations are used to symbolically reduce expressions to normal form (no other equations can be applied).
Expressions are evaluated in a leftmost-innermost fashion
Equations are considered from the top-down when matching expressions
Similar to Prolog

5. Simple Rewriting Example
Simple equations look like normal function definitions.
Bottom row shows rewriting steps as applied by Pure.
>square x = x*x;
>square(5+8);
169
square (5+8) => square 13 => 13*13 => 169

6. Pattern Matching > sum [] = 0; > sum (x:xs) = x+sum xs;
Functions can be defined via pattern matching
(As well as in other ways, but nothing we haven’t seen elsewhere)
> sum [] = 0;
> sum (x:xs) = x+sum xs;
> sum (1..30);
465

7. Pattern Matching with Arbitrary Stuff
Pattern matching can match any sort of data
BST Tree generation example:
> nonfix nil;
> insert nil y = bin y nil nil;
> insert (bin x L R) y = bin x (insert L y) R if y<x;
> = bin x L (insert R y) otherwise;
> foldl insert nil [7,3,9,18];
bin 7 (bin 3 nil nil) (bin 9 nil (bin 18 nil nil))

8. Arbitrary Polymorphism
Because Pure is dynamically typed, it supports an arbitrary degree of polymorphism.
Any operation, even those built into Pure, can be extended by equations.
> f + g = \x -> f x + g x if nargs f > 0 && nargs g > 0;
> f - g = \x -> f x - g x if nargs f > 0 && nargs g > 0;
> f x = 2*x+1; g x = x*x; h x = 3;
> map (f+g-h) (1..10);
[1,6,13,22,33,46,61,78,97,118]
> (max-min) 2 5; 3

9. Symbolic Rewriting
In Pure, attempting to evaluate an expression containing one or more undefined variables returns a symbolic evaluation of the result.
In other languages, the compiler gets angry at you.
> square (a+b);
(a+b)*(a+b)
> sum [a,b,c];
a+(b+(c+0))
> map f [a,b+c,x*y];
[2*a+1,2*(b+c)+1,2*(x*y)+1]

10. More Symbolic Rewriting
In Pure, attempting to set two expressions equal to each other is totally okay; it’s just another rewriting rule.
Arbitrary functions and operators are allowed on the left, just as is so on the right.
In other languages, the compiler gets even angrier than the previous slide.
Example including associative and distributive rules for + and *:
> (x+y)*z = x*z+y*z; x*(y+z) = x*y+x*z;
> x+(y+z) = (x+y)+z; x*(y*z) = (x*y)*z;
> square (a+b);
a*a+a*b+b*a+b*b
> sum [a,b,c];
a+b+c+0
> map f [a,b+c,x*y];
[2*a+1,2*b+2*c+1,2*x*y+1]

11. One More Symbolic Rewriting example
(Seriously, this is really cool to me)
Converting logical expressions to disjunctive normal form using
de Morgan’s Laws
Distributive Laws
Associative Laws
> ~~a = a;
> ~(a || b) = ~a && ~b;
> ~(a && b) = ~a || ~b;
> a && (b || c) = a && b || a && c;
> (a || b) && c = a && c || b && c;
> (a && b) && c = a && (b && c);
> (a || b) || c = a || (b || c);
> a || ~(b || (c && ~d));
a||~b&&~c||~b&&d

12. In Summary Pure can do someone’s Algebra homework for them
More importantly, you can control the flow of how an expression is evaluated by first re-writing the expression
You can also use undefined variables to see how Pure will evaluate an input expression (since it will simply output the symbolic version of what it would otherwise calculate)

13. Further Reading/Source

14. ?