Finding the Needle Stack Traces for GHC
|
|
|
- Jasmin Lindsey
- 5 years ago
- Views:
Transcription
1 Finding the Needle Stack Traces for GHC Tristan O.R. Allwood Imperial College Simon Peyton Jones Microsoft Research Susan Eisenbach Imperial College
2 Prelude The adventures of Jake
3 Somewhere nice and sunny... Prelude head :: [a] a head (x:_) = x head [] = error Prelude.head: empty list
4 Jake could not have predicted the terror that was about to strike... >ghc o Main Main.hs >./Main Main: Prelude.head: empty list >
5 Jake tentatively peeked inside Main...
6 As he stared, things started to focus... head head head head
7 Slowly more context appeared... spam head foo head head bar head
8 But then he saw a complication... spam head foo bar head head bar eggs bar bar head
9 If only there was a way...* spam head foo bar head head bar eggs bar bar head Main: Prelude.head: empty list in head, Prelude.hs:12,23 in bar, Main.hs:60,23 in eggs, Main.hs:120,22 in main, Main.hs:5,5
10 If only there was a way...* spam head foo bar To be continued... head bar head eggs bar bar head Main: Prelude.head: empty list in head, Prelude.hs:12,23 in bar, Main.hs:60,23 in eggs, Main.hs:120,22 in main, Main.hs:5,5
11 The Problem
12 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2
13 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
14 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 error Prelude.head: empty list
15 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
16 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
17 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
18 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
19 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list
20 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list Prelude.head: empty list in halffst in main
21 main xs = halffst (mkpair xs) mkpair xs = (head xs, False) halffst tup = (fst tup) / 2 main [] = halffst (mkpair []) = (fst (mkpair [])) / 2 = (fst (head [], False)) / 2 = head [] / 2 = error... / 2 = error Prelude.head: empty list Prelude.head: empty list in halffst in main Prelude.head: empty list in mkpair in main
22 The big idea
23 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)...
24 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)... recip :: Int Int recip = recip_deb emptystack recip_deb :: Stack Int Int recip_deb stack x = if x == 0 then (error_deb stack' Urk foo ) else 1 / x where stack' = push in recip:ex.hs:14,25 bargle_deb stack x =... (recip_deb stack' x)... where stack' = push in bargle:ex.hs:17,32
25 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)... recip :: Int Int recip = recip_deb emptystack recip_deb :: Stack Int Int recip_deb stack x = if x == 0 then (error_deb stack' Urk foo ) else 1 / x where stack' = push in recip:ex.hs:14,25 bargle_deb stack x =... (recip_deb stack' x)... where stack' = push in bargle:ex.hs:17,32
26 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)... recip :: Int Int recip = recip_deb emptystack recip_deb :: Stack Int Int recip_deb stack x = if x == 0 then (error_deb stack' Urk foo ) else 1 / x where stack' = push in recip:ex.hs:14,25 bargle_deb stack x =... (recip_deb stack' x)... where stack' = push in bargle:ex.hs:17,32
27 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)... recip :: Int Int recip = recip_deb emptystack recip_deb :: Stack Int Int recip_deb stack x = if x == 0 then (error_deb stack' Urk foo ) else 1 / x where stack' = push in recip:ex.hs:14,25 stack bargle_deb stack x =... (recip_deb stack' x)... where stack' = push in bargle:ex.hs:17,32
28 recip :: Int Int recip x = if x == 0 then error Urk foo else 1 / x bargle x =... (recip x)... recip :: Int Int recip = recip_deb emptystack recip_deb :: Stack Int Int recip_deb stack x = if x == 0 then (error_deb stack' Urk foo ) else 1 / x where stack' = push in recip:ex.hs:14,25 stack bargle_deb stack x =... (recip_deb stack' x)... where stack' = push in bargle:ex.hs:17,32 stack
29 error error :: [Char] a error m = throwstack (\s ErrorCall (m ++ show s))
30 error error :: [Char] a error m = throwstack (\s ErrorCall (m ++ show s)) module Stack where emptystack :: Stack push :: Location Stack Stack throwstack :: Exception e => (Stack e) a
31 error error :: [Char] a error m = throwstack (\s ErrorCall (m ++ show s)) error :: [Char] a error = error_deb emptystack error_deb :: Stack [Char] a error_deb stack m = throw (ErrorCall (m ++ show stack)) module Stack where emptystack :: Stack push :: Location Stack Stack throwstack :: Exception e => (Stack e) a
32 error error :: [Char] a error m = throwstack (\s ErrorCall (m ++ show s)) error :: [Char] a error = error_deb emptystack error_deb :: Stack [Char] a error_deb stack m = throw (ErrorCall (m ++ show stack)) module Stack where emptystack :: Stack push :: Location Stack Stack throwstack :: Exception e => (Stack e) a
33 User guided Stack Traces
34 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo
35 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo varidinfo :: Var IdInfo varidinfo (GlobalId {idinfo_ = info}) = info varidinfo (LocalId {idinfo_ = info}) = info varidinfo other_var = pprpanic "idinfo" (ppr other_var)
36 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo import GHC.ExplicitCallStack.Annotations { # ANN varidinfo Debug # } varidinfo :: Var IdInfo varidinfo (GlobalId {idinfo_ = info}) = info varidinfo (LocalId {idinfo_ = info}) = info varidinfo other_var = throwstack (\s pprpanic ("idinfo\n" ++ show s) (ppr other_var) :: SomeException)
37 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo in varidinfo, basictypes/var.lhs:238,30 in idinfo, basictypes/id.lhs:168,10 import GHC.ExplicitCallStack.Annotations { # ANN varidinfo Debug # } varidinfo :: Var IdInfo varidinfo (GlobalId {idinfo_ = info}) = info varidinfo (LocalId {idinfo_ = info}) = info varidinfo other_var = throwstack (\s pprpanic ("idinfo\n" ++ show s) (ppr other_var) :: SomeException)
38 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo in varidinfo, basictypes/var.lhs:238,30 in idinfo, basictypes/id.lhs:168,10 in idinlinepragma, basictypes/id.lhs:633,37 import GHC.ExplicitCallStack.Annotations { # ANN varidinfo Debug # } varidinfo :: Var IdInfo varidinfo (GlobalId {idinfo_ = info}) = info varidinfo (LocalId {idinfo_ = info}) = info varidinfo other_var = throwstack (\s pprpanic ("idinfo\n" ++ show s) (ppr other_var) :: SomeException)
39 ghc.exe: panic! (the 'impossible' happened) (GHC version for i386 unknown mingw32): idinfo in varidinfo, basictypes/var.lhs:238,30 in idinfo, basictypes/id.lhs:168,10 in idinlinepragma, basictypes/id.lhs:633,37 in preinlineunconditionally, simplcore/simplutils.lhs:619,12 in simplnonrece, simplcore/simplify.lhs:964,5 in simpllam, simplcore/simplify.lhs:925,13 in simplexprf', simplcore/simplify.lhs:754,5 in simplexprf, simplcore/simplify.lhs:741,5 import GHC.ExplicitCallStack.Annotations { # ANN varidinfo Debug # } varidinfo :: Var IdInfo varidinfo (GlobalId {idinfo_ = info}) = info varidinfo (LocalId {idinfo_ = info}) = info varidinfo other_var = throwstack (\s pprpanic ("idinfo\n" ++ show s) (ppr other_var) :: SomeException)
40 How does StackTrace do the rewriting?
41 Haskell Source GHC Pipeline Parser Back end compiler TypeChecker Core Optimiser Desugarer
42 Haskell Source GHC Pipeline Parser Back end compiler TypeChecker Desugarer Core Optimiser Expr b = Var Id Lit Literal App (Expr b) (Arg b) Lam b (Expr b) Let (Bind b) (Expr b) Case (Expr b) b Type [Alt b] Cast (Expr b) Coercion Note Note (Expr b) Type Type
43 Haskell Source GHC Pipeline Parser Back end compiler TypeChecker Core Optimiser StackTrace Desugarer
44 Equations [ f = e ] f = f_deb emptystack f_deb s = [ e ] s if f_deb is to be made [ f = e ] f = [ e ] emptystack otherwise [ throwstack ] s \f throw (f s) [ x ] s x_deb (push l s) if x_deb exists [ x ] s x otherwise [ e1 e2 ] s [ e1 ] s [ e2 ] s [ \x e ] s \x [ e ] s [ case e1 of p e2 ] s case [ e1 ] s of p [ e2 ] s [ let x = e1 in e2 ] s let x = [ e1 ] s in [ e2 ] s throwstack :: Exception e => (Stack e) a
45 Stacks, stacks, stacks
46 module Stack where emptystack :: Stack push :: Location Stack Stack throwstack :: Exception e => (Stack e) a Stacks, stacks, stacks
47 foo 0 = error End of foo! foo n = bar (n 1) bar n = foo n main = print (foo 1000)
48 >./Main Main: End of foo! in error, Main.hs:16,14 in foo, Main.hs:9,9 foo 0 = error End of foo! foo n = bar (n 1) bar n = foo n main = print (foo 1000) in foo, Main.hs:9,9 in main, Main.hs:6,15
49 >./Main Main: End of foo! in error, Main.hs:16,14 in foo, Main.hs:9,9 foo 0 = error End of foo! foo n = bar (n 1) bar n = foo n main = print (foo 1000) Main: End of foo! in error, Main.hs:16,14 in foo, Main.hs:9,9... in main, Main.hs:6,15 in foo, Main.hs:9,9 in main, Main.hs:6,15
50 Intuition foo:12,4 bar:10,3 baz:20,23 foo:12,4 bang:40,6 bar:10,3 foo:12,4 main:30,1
51 Intuition foo:12,4 bar:10,3 baz:20,23 foo:12,4 bang:40,6 bar:10,3 foo:12,4 main:30,1 foo:12,4 bar:10,3 baz:20,23... bang:40, main:30,1
52 Intuition foo:12,4 bar:10,3 baz:20,23 foo:12,4 bang:40,6 bar:10,3 foo:12,4 main:30,1 foo:12,4 bar:10,3 baz:20,23... bang:40, main:30,1 foo:12,4 bar:10,3 baz:20,23... bang:40,6... main:30,1
53 Properties Any call site in the original stack is in the stack Top of stack to the first... is same as original stack... s only elide call sites that are above them in the stack... s are never adjacent The size of a stack is now statically bounded at twice the number of call sites in the program foo:12,4 bar:10,3 baz:20,23 foo:12,4 bang:40,6 bar:10,3 foo:12,4 main:30,1 Original stack foo:12,4 bar:10,3 baz:20,23... bang:40,6... main:30,1 stack
54 See the paper for... Stack implementation Stack tail hash consing Gory details of how push works
55 See the paper for... Stack implementation Stack tail hash consing Gory details of how push works bar bar... foo bar foo foo foo... main main main main main
56 See the paper for... Stack implementation Stack tail hash consing Gory details of how push works bar foo foo bar foo bar... foo foo bar... bar foo bar main main main main main main
57 But wait, there's more! Tricky cases / open problems: Desugaring recursive polymorphic functions CAFs TypeClasses Bootstrapping this into existence
58 But wait, there's more! Related Work GHCi debugger S. Marlow, J. Iborra, B. Pope, A. Gill HPC A. Gill, C. Runciman JHC's SRCLOC_ANNOTATE J. Meacham HAT M. Wallace, O. Chitil, T. Brehm, C. Runciman GHC Cost Center Stacks P. Sansom, S. Peyton Jones
59 But wait, there's more! Patches, paper, performance results & slides code.haskell.org/explicitcallstackpaper/
60 Epilogue Thank you for listening! Jake recompiled with an explicit Stack Trace > ghc fexplicit callstack all o Main Main.hs./Main Main: Prelude.head: empty list in head, Prelude.hs:12,23 in calibratesensors.hs:20,24 in bar, Main.hs:60,23 in bang, Main.hs:120,22 in main, Main.hs:5,5 After debugging for 3 days straight... And re ran his program to get the trace ICFP Contest 2009 >./Main Simulation running... Success! Satellite intercepted Score: Jake got his program to work!
61
62 Tricky open problems
63 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x
64 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
65 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
66 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
67 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
68 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
69 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple = \dict_num let { dict_eq = geteqdict dict_num f_lcl = \x case (((==) dict_eq) 0 x) of True error Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) f_lcl g = \dict_num case (fg_tuple dict_num) of (f_lcl, g_lcl) g_lcl
70 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple_d = \s dict_num let { dict_eq = geteqdict dict_num s' = push in fg_tuple:blah.hs... s f_lcl = \x case (((==) dict_eq) 0 x) of True error s' Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) f_d = \s dict_num case (fg_tuple_d (f_lcl, g_lcl) f_lcl g_d = \s dict_num case (fg_tuple_d (f_lcl, g_lcl) g_lcl (push in f:... s) dict_num) of (push in g:... s) dict_num) of
71 Desugaring woes f 0 = error Argh! f x = g (x 1) g x = f x fg_tuple_d = \s dict_num let { dict_eq = geteqdict dict_num s' = push in fg_tuple:blah.hs... s f_lcl = \x case (((==) dict_eq) 0 x) of True error s' Argh False g_lcl ((( ) dict_num) x 1) g_lcl = \x f_lcl x } in (f_lcl, g_lcl) error: yikes! in fg_tuple:blah.hs in f:blah.hs in main f_d = \s dict_num case (fg_tuple_d (f_lcl, g_lcl) f_lcl g_d = \s dict_num case (fg_tuple_d (f_lcl, g_lcl) g_lcl (push in f:... s) dict_num) of (push in g:... s) dict_num) of
72 CAFs e = expensive `seq` f main = do print e print e
73 CAFs e = expensive `seq` f main = do print e print e e_deb stack = expensive_deb stack1 `seq` f_deb stack2 where stack1 =... stack2 =...
Simon Peyton Jones Microsoft Research. August 2012
Simon Peyton Jones Microsoft Research August 2012 Typecheck Desugar Source language Intermediate language Haskell Massive language Hundreds of pages of user manual Syntax has dozens of data types 100+
Extended Static Checking for Haskell (ESC/Haskell)
Extended Static Checking for Haskell (ESC/Haskell) Dana N. Xu University of Cambridge advised by Simon Peyton Jones Microsoft Research, Cambridge Program Errors Give Headache! Module UserPgm where f ::
Simon Peyton Jones Microsoft Research August 2013
Simon Peyton Jones Microsoft Research August 2013 reverse :: a. [a] -> [a] xs :: [Bool] foo :: [Bool] foo = reverse xs Instantiate reverse with a unification variable, standing for an as-yet-unknown type.
Work-in-progress: Verifying the Glasgow Haskell Compiler Core language
Work-in-progress: Verifying the Glasgow Haskell Compiler Core language Stephanie Weirich Joachim Breitner, Antal Spector-Zabusky, Yao Li, Christine Rizkallah, John Wiegley May 2018 Verified compilers and
Static Contract Checking for Haskell
Static Contract Checking for Haskell Dana N. Xu INRIA France Work done at University of Cambridge Simon Peyton Jones Microsoft Research Cambridge Joint work with Koen Claessen Chalmers University of Technology
Work-in-progress: "Verifying" the Glasgow Haskell Compiler Core language
Work-in-progress: "Verifying" the Glasgow Haskell Compiler Core language Stephanie Weirich Joachim Breitner, Antal Spector-Zabusky, Yao Li, Christine Rizkallah, John Wiegley June 2018 Let's prove GHC correct
Once Upon a Polymorphic Type
Once Upon a Polymorphic Type Keith Wansbrough Computer Laboratory University of Cambridge kw217@cl.cam.ac.uk http://www.cl.cam.ac.uk/users/kw217/ Simon Peyton Jones Microsoft Research Cambridge 20 January,
Statically Unrolling Recursion to Improve Opportunities for Parallelism
Statically Unrolling Recursion to Improve Opportunities for Parallelism Neil Deshpande Stephen A. Edwards Department of Computer Science, Columbia University, New York Technical Report CUCS-011-12 July
Lambda calculus. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 6
Lambda calculus Advanced functional programming - Lecture 6 Wouter Swierstra and Alejandro Serrano 1 Today Lambda calculus the foundation of functional programming What makes lambda calculus such a universal
CS 360: Programming Languages Lecture 12: More Haskell
CS 360: Programming Languages Lecture 12: More Haskell Geoffrey Mainland Drexel University Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia Administrivia Homework 5 due
Debugging in Haskell
Debugging in Haskell Lasse Folger June 29, 2016 Abstract In this paper we will give an overview on techniques to debug Haskell programs. At first the problems are presented which occur, when debugging
Haskell. : qsort. Haskell Advent Calendar 2016 *2 15. Wnn Hello, world Haskell. qsort. -- qsort :: Ord a => [a] -> [a]
![Haskell. : qsort. Haskell Advent Calendar 2016 *2 15. Wnn Hello, world Haskell. qsort. -- qsort :: Ord a => [a] -> [a]](/thumbs/88/117137658.jpg "Haskell. : qsort. Haskell Advent Calendar 2016 *2 15. Wnn Hello, world Haskell. qsort. -- qsort :: Ord a => [a] -> [a]")
Haskell 2016 12 15 @unnohideyuki * 1 Haskell Advent Calendar 2016 *2 15 Haskell Haskell Haskell Haskell *3 : qsort Wnn Hello, world Haskell qsort -- qsort :: Ord a => [a] -> [a] *1 https://twitter.com/unnohideyuki
Solution sheet 1. Introduction. Exercise 1 - Types of values. Exercise 2 - Constructors
Solution sheet 1 Introduction Please note that there can be other solutions than those listed in this document. This is a literate Haskell file which is available as PDF, as well as literate Haskell source
Optimising Functional Programming Languages. Max Bolingbroke, Cambridge University CPRG Lectures 2010
Optimising Functional Programming Languages Max Bolingbroke, Cambridge University CPRG Lectures 2010 Objectives Explore optimisation of functional programming languages using the framework of equational
Haskell & functional programming, some slightly more advanced stuff. Matteo Pradella
Haskell & functional programming, some slightly more advanced stuff Matteo Pradella pradella@elet.polimi.it IEIIT, Consiglio Nazionale delle Ricerche & DEI, Politecnico di Milano PhD course @ UniMi - Feb
Faster Haskell. Neil Mitchell
Faster Haskell Neil Mitchell www.cs.york.ac.uk/~ndm The Goal Make Haskell faster Reduce the runtime But keep high-level declarative style Full automatic - no special functions Different from foldr/build,
CIS 194: Homework 3. Due Wednesday, February 11, Interpreters. Meet SImPL
CIS 194: Homework 3 Due Wednesday, February 11, 2015 Interpreters An interpreter is a program that takes another program as an input and evaluates it. Many modern languages such as Java 1, Javascript,
LL(k) Parsing. Predictive Parsers. LL(k) Parser Structure. Sample Parse Table. LL(1) Parsing Algorithm. Push RHS in Reverse Order 10/17/2012
Predictive Parsers LL(k) Parsing Can we avoid backtracking? es, if for a given input symbol and given nonterminal, we can choose the alternative appropriately. his is possible if the first terminal of
A Lightweight Interactive Debugger for Haskell
A Lightweight Interactive Debugger for Haskell Simon Marlow Microsoft Research simonmar@microsoft.com José Iborra Universidad Politécnica de Valencia jiborra@dsic.upv.es Bernard Pope The University of
Applicatives Comparisons (2C) Young Won Lim 3/6/18
Comparisons (2C) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
The Worker/Wrapper Transformation
The Worker/Wrapper Transformation Andy Gill 1 Graham Hutton 2 1 Galois, Inc. 2 University of Nottingham February 6, 2008 Andy Gill, Graham Hutton The Worker/Wrapper Transformation February 6, 2008 1 /
Parsing. Zhenjiang Hu. May 31, June 7, June 14, All Right Reserved. National Institute of Informatics
National Institute of Informatics May 31, June 7, June 14, 2010 All Right Reserved. Outline I 1 Parser Type 2 Monad Parser Monad 3 Derived Primitives 4 5 6 Outline Parser Type 1 Parser Type 2 3 4 5 6 What
Compiling Parallel Algorithms to Memory Systems
Compiling Parallel Algorithms to Memory Systems Stephen A. Edwards Columbia University Presented at Jane Street, April 16, 2012 (λx.?)f = FPGA Parallelism is the Big Question Massive On-Chip Parallelism
Introduction to Haskell
Introduction to Haskell Matt Mullins Texas A&M Computing Society October 6, 2009 Matt Mullins (TACS) Introduction to Haskell October 6, 2009 1 / 39 Outline Introduction to Haskell Functional Programming
PROGRAMMING IN HASKELL. Chapter 2 - First Steps
PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 The Hugs System Hugs is an implementation of Haskell 98, and is the most widely used Haskell system; The interactive nature of Hugs makes it well suited
Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell
Advanced Topics in Programming Languages Lecture 2 - Introduction to Haskell Ori Bar El Maxim Finkel 01/11/17 1 History Haskell is a lazy, committee designed, pure functional programming language that
According to Larry Wall (designer of PERL): a language by geniuses! for geniuses. Lecture 7: Haskell. Haskell 98. Haskell (cont) - Type-safe!
Lecture 7: Haskell CSC 131 Fall, 2014 Kim Bruce According to Larry Wall (designer of PERL): a language by geniuses for geniuses He s wrong at least about the latter part though you might agree when we
Logic - CM0845 Introduction to Haskell
Logic - CM0845 Introduction to Haskell Diego Alejandro Montoya-Zapata EAFIT University Semester 2016-1 Diego Alejandro Montoya-Zapata (EAFIT University) Logic - CM0845 Introduction to Haskell Semester
CS 11 Haskell track: lecture 1
CS 11 Haskell track: lecture 1 This week: Introduction/motivation/pep talk Basics of Haskell Prerequisite Knowledge of basic functional programming e.g. Scheme, Ocaml, Erlang CS 1, CS 4 "permission of
Haskell Introduction Lists Other Structures Data Structures. Haskell Introduction. Mark Snyder
Outline 1 2 3 4 What is Haskell? Haskell is a functional programming language. Characteristics functional non-strict ( lazy ) pure (no side effects*) strongly statically typed available compiled and interpreted
CS 360: Programming Languages Lecture 10: Introduction to Haskell
CS 360: Programming Languages Lecture 10: Introduction to Haskell Geoffrey Mainland Drexel University Thursday, February 5, 2015 Adapted from Brent Yorgey s course Introduction to Haskell. Section 1 Administrivia
The Worker/Wrapper Transformation
The Worker/Wrapper Transformation Andy Gill 1 Graham Hutton 2 1 The University of Kansas 2 The University of Nottingham March 26th, 2009 Andy Gill, Graham Hutton The Worker/Wrapper Transformation March
Coercion Quantification
Coercion Quantification Ningning Xie 1 Richard A. Eisenberg 2 22 Sept. 2018 Haskell Implementor s Workshop (HIW 18) 1 The University of Hong Kong 2 Bryn Mawr College 1 Motivation Motivation Our long-term
PROGRAMMING IN HASKELL. Chapter 2 - First Steps
PROGRAMMING IN HASKELL Chapter 2 - First Steps 0 Glasgow Haskell Compiler GHC is the leading implementation of Haskell, and comprises a compiler and interpreter; The interactive nature of the interpreter
Informatics 1 Functional Programming Lecture 4. Lists and Recursion. Don Sannella University of Edinburgh
Informatics 1 Functional Programming Lecture 4 Lists and Recursion Don Sannella University of Edinburgh Part I Lists and Recursion Cons and append Cons takes an element and a list. Append takes two lists.
Multiple-View Tracing for Haskell: a New Hat
Multiple-View Tracing for Haskell: a New Hat Malcolm Wallace, Olaf Chitil, Thorsten Brehm and Colin Runciman University of York, UK {malcolm,olaf,thorsten,colin}@cs.york.ac.uk Abstract Different tracing
Simple Unification-based Type Inference for GADTs
Simple Unification-based Type Inference for GADTs Stephanie Weirich University of Pennsylvania joint work with Dimitrios Vytiniotis, Simon Peyton Jones and Geoffrey Washburn Overview Goal: Add GADTs to
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square)
CS 4240: Compilers and Interpreters Project Phase 1: Scanner and Parser Due Date: October 4 th 2015 (11:59 pm) (via T-square) Introduction This semester, through a project split into 3 phases, we are going
Haskell: From Basic to Advanced. Part 3 A Deeper Look into Laziness
Haskell: From Basic to Advanced Part 3 A Deeper Look into Laziness Haskell is a lazy language Laziness again A particular function argument is only evaluated when it is needed, and if it is needed then
The Typed Racket Guide
The Typed Racket Guide Version 5.3.6 Sam Tobin-Hochstadt and Vincent St-Amour August 9, 2013 Typed Racket is a family of languages, each of which enforce
CS 440: Programming Languages and Translators, Spring 2019 Mon 2/4
Haskell, Part 5 CS 440: Programming Languages and Translators, Spring 2019 Mon 2/4 More Haskell Miscellaneous topics Simple I/O, do blocks, actions Modules data vs type declaration Instances of classtypes
Practical Haskell. An introduction to functional programming. July 21, Practical Haskell. Juan Pedro Villa-Isaza. Introduction.
Practical Practical An introduction to functional programming July 21, 2011 Contents Practical Practical is fun, and that s what it s all about! Even if seems strange to you at first, don t give up. Learning
Where is ML type inference headed?
1 Constraint solving meets local shape inference September 2005 2 Types are good A type is a concise description of the behavior of a program fragment. Typechecking provides safety or security guarantees.
CIS 194: Homework 5. Due Monday, 18 February. Expressions. (2 + 3) 4 would be represented by the value
CIS 194: Homework 5 Due Monday, 18 February Files you should submit: Calc.hs, containing a module of the same name. As we saw in class, Haskell s type classes provide ad-hoc polymorphism, that is, the
2 Haskell. Haskell (629) 59. Haskell. B. Curry. 1.2, 1.3, Haskell 98 [16] 1. Haskell. Haskell. ( Haskell.
![2 Haskell. Haskell (629) 59. Haskell. B. Curry. 1.2, 1.3, Haskell 98 [16] 1. Haskell. Haskell. ( Haskell.](/thumbs/93/112070079.jpg "2 Haskell. Haskell (629) 59. Haskell. B. Curry. 1.2, 1.3, Haskell 98 [16] 1. Haskell. Haskell. ( Haskell.")
(629) 59 Haskell 1 Haskell Haskell Hugs GHC 2 Haskell 2.1 Haskell 1987 FPCA (Functional Programming Languages and Computer Architechture) Programming Language Haskell and Systems Yoshiyuki ONOUE,, Graduate
Typed Racket: Racket with Static Types
Typed Racket: Racket with Static Types Version 5.0.2 Sam Tobin-Hochstadt November 6, 2010 Typed Racket is a family of languages, each of which enforce that programs written in the language obey a type
Haskell 101. (Version 1 (July 18, 2012)) Juan Pedro Villa Isaza
Haskell 101 (Version 1 (July 18, 2012)) Juan Pedro Villa Isaza Haskell 101: Contents Introduction Tutorial Homework Bibliography Haskell 101: Contents Introduction Tutorial Homework Bibliography Haskell
GHCi: Getting started (1A) Young Won Lim 6/3/17
GHCi: Getting started (1A) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Side Effects (3A) Young Won Lim 1/13/18
Side Effects (3A) Copyright (c) 2016-2018 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
Course year Typeclasses and their instances
Course year 2016-2017 Typeclasses and their instances Doaitse Swierstra and Atze Dijkstra with extra s Utrecht University September 29, 2016 1. The basics 2 Overloading versus parametric polymorphism 1
Type families and data kinds
Type families and data kinds AFP Summer School Wouter Swierstra 1 Today How do GADTs work? Kinds beyond * Programming with types 2 Calling functions on vectors Given two vectors xs : Vec a n and ys : Vec
CS457/557 Functional Languages
CS457/557 Functional Languages Spring 2018 Lecture 1: Course Introduction Andrew Tolmach Portland State University (with thanks to Mark P. Jones) 1 Goals of this course Introduce the beautiful ideas of
Arbitrary-rank polymorphism in (GHC) Haskell
Arbitrary-rank polymorphism in (GHC) Haskell CAS 743 Stephen Forrest 20 March 2006 Damas-Milner Type System A Damas-Milner type system (also called Hindley-Milner) is a traditional type system for functional
Transforming Haskell for Tracing
Transforming Haskell for Tracing Olaf Chitil, Colin Runciman, and Malcolm Wallace The University of York, UK Abstract. Hat is a programmer s tool for generating a trace of a computation of a Haskell 98
HERMIT: An Equational Reasoning Model to Implementation Rewrite System for Haskell
HERMIT: An Equational Reasoning Model to Implementation Rewrite System for Haskell Andy Gill HERMIT is joint work with Andrew Farmer, Nick Frisby, Ed Komp, Neil Sculthorpe, Robert Blair, Jan Bracker, Patrick
GADTs. Wouter Swierstra. Advanced functional programming - Lecture 7. Faculty of Science Information and Computing Sciences
GADTs Advanced functional programming - Lecture 7 Wouter Swierstra 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree a) This definition introduces:
Haskell Types COMP360
Haskell Types COMP360 No computer has ever been designed that is ever aware of what it's doing; but most of the time, we aren't either. Marvin Minsky Haskell Programming Assignment A Haskell programming
G Programming Languages - Fall 2012
G22.2110-003 Programming Languages - Fall 2012 Lecture 4 Thomas Wies New York University Review Last week Control Structures Selection Loops Adding Invariants Outline Subprograms Calling Sequences Parameter
CS 320: Concepts of Programming Languages
CS 320: Concepts of Programming Languages Wayne Snyder Computer Science Department Boston University Lecture 08: Type Classes o o Review: What is a type class? Basic Type Classes: Eq, Ord, Enum, Integral,
Midterm 1. CMSC 430 Introduction to Compilers Spring Instructions Total 100. Name: March 14, 2012
Name: Midterm 1 CMSC 430 Introduction to Compilers Spring 2012 March 14, 2012 Instructions This exam contains 8 pages, including this one. Make sure you have all the pages. Write your name on the top of
Behavior-Driven Development in Haskell
Behavior-Driven Development in Haskell a tutorial introduction Simon Hengel Wimdu GmbH simon.hengel@wimdu.com Abstract Several widely used Haskell libraries do not come with automated tests. Test code
CSCE 314 Programming Languages. Functional Parsers
CSCE 314 Programming Languages Functional Parsers Dr. Hyunyoung Lee 1 What is a Parser? A parser is a program that takes a text (set of tokens) and determines its syntactic structure. String or [Token]
Writing code that I'm not smart enough to write. A funny thing happened at Lambda Jam
Writing code that I'm not smart enough to write A funny thing happened at Lambda Jam Background "Let s make a lambda calculator" Rúnar Bjarnason Task: write an interpreter for the lambda calculus Lambda
Haskell An Introduction
Haskell An Introduction What is Haskell? General purpose Purely functional No function can have side-effects IO is done using special types Lazy Strongly typed Polymorphic types Concise and elegant A First
Programming Languages Fall 2013
Programming Languages Fall 2013 Lecture 2: types Prof. Liang Huang huang@qc.cs.cuny.edu Recap of Lecture 1 functional programming vs. imperative programming basic Haskell syntax function definition lazy
Tuples. CMSC 330: Organization of Programming Languages. Examples With Tuples. Another Example
CMSC 330: Organization of Programming Languages OCaml 2 Higher Order Functions Tuples Constructed using (e1,..., en) Deconstructed using pattern matching Patterns involve parens and commas, e.g., (p1,p2,
The List Datatype. CSc 372. Comparative Programming Languages. 6 : Haskell Lists. Department of Computer Science University of Arizona
The List Datatype CSc 372 Comparative Programming Languages 6 : Haskell Lists Department of Computer Science University of Arizona collberg@gmail.com All functional programming languages have the ConsList
Haskell 5.1 INTERACTIVE SESSIONS AND THE RUN-TIME SYSTEM
5 Haskell Haskell is a lazy, functional programming language that was initially designed by a committee in the eighties and nineties. In contrast to many programming languages, it is lazy, meaning that
CIT 3136 Lecture 7. Top-Down Parsing
CIT 3136 Lecture 7 Top-Down Parsing Chapter 4: Top-down Parsing A top-down parsing algorithm parses an input string of tokens by tracing out the steps in a leftmost derivation. Such an algorithm is called
Advances in Programming Languages
T O Y H Advances in Programming Languages APL8: Multiparameter Type Classes, Constructor Classes Ian Stark School of Informatics The University of Edinburgh Thursday 4 February Semester 2 Week 4 E H U
Side Effects (3B) Young Won Lim 11/23/17
Side Effects (3B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
n n Try tutorial on front page to get started! n spring13/ n Stack Overflow!
Announcements n Rainbow grades: HW1-6, Quiz1-5, Exam1 n Still grading: HW7, Quiz6, Exam2 Intro to Haskell n HW8 due today n HW9, Haskell, out tonight, due Nov. 16 th n Individual assignment n Start early!
Lecture #23: Conversion and Type Inference
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). Last modified: Fri Oct 20 10:46:40 2006 CS164:
G Programming Languages Spring 2010 Lecture 4. Robert Grimm, New York University
G22.2110-001 Programming Languages Spring 2010 Lecture 4 Robert Grimm, New York University 1 Review Last week Control Structures Selection Loops 2 Outline Subprograms Calling Sequences Parameter Passing
Background. CMSC 330: Organization of Programming Languages. Useful Information on OCaml language. Dialects of ML. ML (Meta Language) Standard ML
CMSC 330: Organization of Programming Languages Functional Programming with OCaml 1 Background ML (Meta Language) Univ. of Edinburgh, 1973 Part of a theorem proving system LCF The Logic of Computable Functions
Shared Subtypes. Subtyping Recursive Parameterized Algebraic Data Types
Shared Subtypes Subtyping Recursive Parameterized Algebraic Data Types Ki Yung Ahn kya@cs.pdx.edu Tim Sheard sheard@cs.pdx.edu Department of Computer Science Maseeh College of Engineering & Computer Science
Side Effects (3B) Young Won Lim 11/27/17
Side Effects (3B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
Conversion vs. Subtyping. Lecture #23: Conversion and Type Inference. Integer Conversions. Conversions: Implicit vs. Explicit. Object x = "Hello";
Lecture #23: Conversion and Type Inference Administrivia. Due date for Project #2 moved to midnight tonight. Midterm mean 20, median 21 (my expectation: 17.5). In Java, this is legal: Object x = "Hello";
Side Effects (3B) Young Won Lim 11/20/17
Side Effects (3B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later
Compilers CS S-05 Semantic Analysis
Compilers CS414-2003S-05 Semantic Analysis David Galles Department of Computer Science University of San Francisco 05-0: Syntax Errors/Semantic Errors A program has syntax errors if it cannot be generated
Template Haskell based implementation of printf
Lecture 19 Template Haskell based implementation of printf In the last lecture we saw a type class based solution to create functions that take variable number of arguments. Here we give a template haskell
Background Type Classes (1B) Young Won Lim 6/14/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
Chapter 3: Lexing and Parsing
Chapter 3: Lexing and Parsing Aarne Ranta Slides for the book Implementing Programming Languages. An Introduction to Compilers and Interpreters, College Publications, 2012. Lexing and Parsing* Deeper understanding
CSc 372. Comparative Programming Languages. 8 : Haskell Function Examples. Department of Computer Science University of Arizona
1/43 CSc 372 Comparative Programming Languages 8 : Haskell Function Examples Department of Computer Science University of Arizona collberg@gmail.com Copyright c 2013 Christian Collberg Functions over Lists
Background Type Classes (1B) Young Won Lim 6/28/18
Background Type Classes (1B) Copyright (c) 2016-2017 Young W. Lim. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2
CS 360 Programming Languages Interpreters
CS 360 Programming Languages Interpreters Implementing PLs Most of the course is learning fundamental concepts for using and understanding PLs. Syntax vs. semantics vs. idioms. Powerful constructs like
Learn You a Haskell for Great Good!
Learn You a Haskell for Great Good! Contents Chapter 1 Introduction 1.1 About this tutorial 1. 1.2 So what's Haskell? 1. 1.3 What you need to dive in 2. Chapter 2 Starting Out 2.1 Ready, set, go! 4. 2.2
CSCE 314 Programming Languages
CSCE 314 Programming Languages Haskell 101 Dr. Hyunyoung Lee 1 Contents 1. Historical Background of Haskell 2. Lazy, Pure, and Functional Language 3. Using ghc and ghci 4. Functions 5. Haskell Scripts
Let Arguments Go First
Let Arguments Go First Ningning Xie and Bruno C. d. S. Oliveira The University of Hong Kong {nnxie,bruno}@cs.hku.hk Abstract. Bi-directional type checking has proved to be an extremely useful and versatile
Dynamic analysis in the Reduceron. Matthew Naylor and Colin Runciman University of York
Dynamic analysis in the Reduceron Matthew Naylor and Colin Runciman University of York A question I wonder how popular Haskell needs to become for Intel to optimize their processors for my runtime, rather
Quick announcement. Midterm date is Wednesday Oct 24, 11-12pm.
Quick announcement Midterm date is Wednesday Oct 24, 11-12pm. The lambda calculus = ID (λ ID. ) ( ) The lambda calculus (Racket) = ID (lambda (ID) ) ( )
Push/enter vs eval/apply. Simon Marlow Simon Peyton Jones
Push/enter vs eval/apply Simon Marlow Simon Peyton Jones The question Consider the call (f x y). We can either Evaluate f, and then apply it to its arguments, or Push x and y, and enter f Both admit fully-general
A Modular Package Language for Haskell
A Modular Package Language for Haskell Scott Kilpatrick MPI-SWS Joint work with: Derek Dreyer (MPI-SWS) Simon Marlow (Microsoft Research) Simon Peyton Jones (Microsoft Research) University of Pennsylvania
Making a fast curry: push/enter vs. eval/apply for higher-order languages
JFP 16 (4&5): 415 449, 2006. c 2006 Cambridge University Press doi:10.1017/s0956796806005995 Printed in the United Kingdom 415 Making a fast curry: push/enter vs. eval/apply for higher-order languages
Berp. An implementation of Python 3 in Haskell
Berp An implementation of Python 3 in Haskell Outline Demonstration Implementation details Novelties Tricky bits Future work Demonstration The compiler in action. The interpreter in action. Implementation
GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]
![GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]](/thumbs/78/76904283.jpg "GADTs. Wouter Swierstra and Alejandro Serrano. Advanced functional programming - Lecture 7. [Faculty of Science Information and Computing Sciences]")
GADTs Advanced functional programming - Lecture 7 Wouter Swierstra and Alejandro Serrano 1 Today s lecture Generalized algebraic data types (GADTs) 2 A datatype data Tree a = Leaf Node (Tree a) a (Tree
Domain Specific Languages for Small Embedded Systems
Domain Specific Languages for Small Embedded Systems Mark Grebe Department of Electrical Engineering and Computer Science PADL 2016 The University of Kansas April 27, 2018 Small Embedded Systems Small,
Hard deadline: 3/28/15 1:00pm. Using software development tools like source control. Understanding the environment model and type inference.
CS 3110 Spring 2015 Problem Set 3 Version 0 (last modified March 12, 2015) Soft deadline: 3/26/15 11:59pm Hard deadline: 3/28/15 1:00pm Overview In this assignment you will implement several functions
Functional programming Primer I
Functional programming Primer I COS 320 Compiling Techniques Princeton University Spring 2016 Lennart Beringer 1 Characteristics of functional programming Primary notions: functions and expressions (not
Faster production of redex trails: The Hat G-Machine
Faster production of redex trails: The Hat G-Machine Tom Shackell and Colin Runciman Tom.Shackell@cs.york.ac.uk, Colin.Runciman@cs.york.ac.uk University of York, UK Abstract The Hat system provides a method