Simon Peyton Jones Microsoft Research August 2012

Transcription

1 Simon Peyton Jones Microsoft Research August 2012

2 A functional language Purely functional Lazy Statically typed Designed By a committee For research, teaching, and practical use

3 Geeks Practitioners 1,000,000 10, The quick death 1yr 5yr 10yr 15yr

4 Geeks Practitioners 1,000,000 10, The slow death 1 1yr 5yr 10yr 15yr

5 Geeks Practitioners 1,000,000 Threshold of immortality 10, The complete absence of death 1 1yr 5yr 10yr 15yr

6 Geeks Practitioners 1,000,000 10, The committee language 1yr 5yr 10yr 15yr

7 Geeks Practitioners 1,000,000 10,000 I'm already looking at coding problems and my mental perspective is now shifting back and forth between purely OO and more FP styled solutions (blog Mar 2007) Learning Haskell is a great way of training yourself to think functionally so you are ready to take full advantage of C# 3.0 when it comes out (blog Apr 2007) 100 The second life? Java

8 Haskell #20 (#25 in 2008) langpop.com langpop.com Nov 2011

9 Haskell #5 (#6 in 2008) langpop.com Nov 2011

10 1. Keep faith with a few deep, simple principles, and see where they lead Purity Static typing, via parametric polymorphism Execution model ~ lambda calculus 2. Avoid success at all costs People will gladly adapt to the limitations of a great design. Box via Meijer

11 Static typing is by far the most widely-used program verification technology in use today: particularly good cost/benefit ratio Lightweight (so programmers use them) Machine checked (fully automated, every compilation) Ubiquitous (so programmers can t avoid them)

12 Types guarantee the absence of certain classes of errors: well typed programs don t go wrong True + c Seg-faults The static type of a function is a partial specification: its says something (but not too much) about what the function does reverse :: [a] -> [a] Types are a design language; types are the UML of Haskell The BIGGEST MERIT (though seldom mentioned) of types is their support for software maintenance

13 Hammer (cheap, easy to use, limited effectivenes) No types Increasing confidence that the program does what you want The spectrum of confidence Tactical nuclear weapon (expensive, needs a trained user, but very effective indeed) Coq Simple types ML polymorphism Full userguided theorem prover

14 The type errors are getting in my way The massive rise of dynamic languages Tension: increased precision can mean gets in the way more. List -> List Too vague; argument should be a (List Int) List Int -> List Int forall a. List a -> List a Better, but now I need reverseint :: List Int -> List Int reversechar :: List Char -> List Char Aha! This looks cool.

15 Programs that are well typed All programs Programs that work Region of Abysmal Pain

16 Programs that are well typed All programs Programs that work Smaller Region of Abysmal Pain

17 Type families, kind polymorphism etc GADTs Type classes Haskell ML polymorphism + algebraic data types Simple types ML

18 Type families, kind polymorphism etc GADTs Type classes Haskell ML polymorphism + algebraic data types Simple types ML

19 Build on the demonstrated success of static types...by making the type system more expressive...so that more good programs are accepted (and more bad ones rejected)...without losing the Joyful Properties (comprehensible to programmers)

20 Glasgow Haskell Compiler (GHC) Very smart compiler, generates fast code. Open source 22 years old, but still in a state of furious development 1990: 28k lines of Haskell, 43k of C 2012: 140k lines of Haskell, 48k of C Hundreds of 1,000 s of users

21 Haskell the cat (b. 2002)

22 Type classes GADTs Haskell Higher rank, impredicative Type families Kind polymorphism Implementation Type inference Contracts System FC

23 I want you to leave with a real sense of excitement about the power and beauty of types

24 Type signature Higher order Polymorphism (works for any type a) filter :: (a->bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) p x = x : filter p xs otherwise = filter p xs

25 Type signature Higher order Polymorphism (works for any type a) filter :: (a->bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) p x = x : filter p xs otherwise = filter p xs Functions defined by pattern matching Guards distinguish sub-cases f x y rather than f(x,y)

26 Type signature Higher order Polymorphism (works for any type a) filter :: (a->bool) -> [a] -> [a] filter p [] = [] filter p (x:xs) p x = x : filter p xs otherwise = filter p xs data Bool = False True data [a] = [] a:[a] Declare new data types