The Next Great Functional Programming Language

The Next Great Functional
Programming Language
(OK, not really.)
John A. De Goes — @jdegoes

ML - 1973
Haskell - 19901
OCaml - 19962
2
Or 1987 if you count Caml.
1
Or 1985 if you count Miranda.

Haskellz
144 quadrillion flavors.
!

Our Best FPLs Suffer from
Decades Worth of
Accretion

Individual Features were
Designed, but the FPLs
Came Into Existence

What Would a Designed
FPL Look Like Today?

[This Slide Intentionally Left Blank]

My Ideal FPL
4 Pattern Matching
4 Records
4 Modules
4 Syntax
4 Type Classes
4 Nominative Typing
4 Data
4 Recursion

Pattern Matching
import Lens.Family.Total
import Lens.Family.Stock
total :: Either Char Int -> String -- Same as:
total = _case -- total = case
& on _Left (c -> replicate 3 c ) -- Left c -> replicate 3 c
& on _Right (n -> replicate n '!') -- Right n -> replicate n '!'

Records
val book =
("author" ->> "Benjamin Pierce") ::
("title" ->> "Types and Programming Languages") ::
("id" ->> 262162091) ::
("price" ->> 44.11) ::
HNil
scala> book("author") // Note result type ...
res0: String = Benjamin Pierce
scala> val extended = book + ("inPrint" ->> true) // Add a new field
extended: ... complex type elided ... =
Benjamin Pierce :: Types and Programming Languages :: 262162091 :: 46.11 :: true :: HNil
scala> val noId = extended - "id" // Removed a field
noId: ... complex type elided ... =
Benjamin Pierce :: Types and Programming Languages :: 46.11 :: true :: HNil

Modules
structure ListStack :> STACK =
struct
type t = 'a list
[...]
end

Modules
data Stack f = Stack
{ makeNew :: forall a. f a,
push :: forall a. a -> f a -> f a,
pop :: forall a. f a -> Maybe (Tuple a (f a)) }
doSomeStackStuff :: forall f. Stack f -> Thing

Modules
data Stack f = Stack
{ makeNew :: forall a. f a,
push :: forall a. a -> f a -> f a,
pop :: forall a. f a -> Maybe (Tuple a (f a)) }
data ReservationSystem f = ReservationSystem
(forall g. Stack g -> { ... })

Syntax
Let's stop pretending programs are strings of ASCII
characters.
4 implicits
4 order of function parameters / application
4 compiler errors
4 funky looking operators
4 scopes
4 Haskell-style (fake) modules & imports
4 name clashes
4 information elision
4 ...

Type Classes
Just 'records' with compiler-enforced laws.3
3
Type classes also add an implicitly applied (a : Type) -> TypeClass a function that's piecewise-
defined, but that's just syntax.

Partiality
If it's partial, it's not a &^@#% function.

Nominative Typing
data Email = Email String
data DOMId = DOMId String
data Positive = Positive Float
data Negative = Negative Float
data DressSize = DressSize Float

Nominative Typing
data ??? = ??? String
data ??? = ??? String
data ??? = ??? Float

Let's Stop Pretending
Differences in Names
Actually Matter

Nominative Typing
Let's play a guessing game.
data ??? = ??? -- {v: Float | v > 0}
data ??? = ??? -- {v: Float | v < 0}

Data
Data: Bits-based description.
data Either a b = Left a | Right b
struct either {
int tag;
union {
void *left;
void *right;
};
};

Data
Newbies: addicted to pattern matching.
data List a = Nil | Cons a (List a)
doSomething :: forall a. List a -> Int
doSomething Nil = 0
doSomething (Cons _ l) = 1 + doSomething l

Data
Pros: addicted to folds.
fold :: forall z a. z -> (z -> a -> z) -> List a -> z
fold z _ Nil = z
fold z f (Cons a l) = fold (f z a) l

Data
Folds: Capability-based description.
fold :: forall z a. z -> (z -> a -> z) -> List a -> z
data List a = List (forall z. z -> (z -> a -> z) -> z)

Data
data List a = List (forall z. z -> (z -> a -> z) -> z)
nil = z f -> z
cons a (List as) = z f -> as (f a z) f
Array? Linked List? Vector? Skip List?4
4
Strictly more powerful than a data List (pros & cons).

Recursion
Goto of functional programming.5
f x = if x / 2 > x then g (2 * x) else 42
g x = if x % 1 == 0 then f (g (x + 1)) else h (x - 1)
h x = if x % 1 == 1 then f (x * 2 + 1) else g (x + 1)
5
What's hard for a machine|human to understand is also hard for a human|machine to understand.

Recursion
Coinduction -> State Machines.
type Machine s a b = (s, (s, a) -> (s, b))
6
6
Except this is too weakly typed.

My Ideal FPL
Layered like an onion.
4 Turing incomplete for 99% of program
4 Prove / optimize more
4 Turing complete 'driver'
4 Prove / optimize less
4 Possibly in a different language (e.g. Haskell)

My Ideal FPL
Structured editor.
4 Friendly FP
4 Destroys motivation for most language 'features'

My Ideal FPL
All the things are values.
4 Math functions
4 Abolish incidental complexity
4 Abolish artificial distinctions

My Ideal FPL
Proof search.
4 Turing complete
4 Levels of proof
1. Proven true
2. Evidence for truth but not proven true
3. Proven false (in general or by counterexample)
4 Massive, persistent proof databases
4 Cross-disciplinary research
4 e.g. deep learning to accelerate proof search

My Ideal FPL
Zero cost abstraction.
4 As long as we're shooting for the moon
4 (But genuinely easier w/o recursion/data)

Inspirations
4 Unison Programming Language7
4 LiquidHaskell8
4 Morte9
9
http://www.haskellforall.com/2014/09/morte-intermediate-language-for-super.html
8
http://goto.ucsd.edu/~rjhala/liquid/haskell/blog/
7
http://unisonweb.org

THANK YOU
John A. De Goes — @jdegoes

The Next Great Functional Programming Language

More Related Content

What's hot

Similar to The Next Great Functional Programming Language

More from John De Goes

Recently uploaded

The Next Great Functional Programming Language