Lisp in Huskell

Transcript

1. Lisp in Huskell
2. Huskelldoge
3. By an 100% Haskell dummy
4. What is Lisp, really?
5. (def b 100) ;; defining vars! (def a (fn [c] (+ b c))) ;; defining functions! (a 5 7) ;; executing functions
6. Easy!
7. How do we express it?
8. data LispExpression = LispSymbol String |! ReservedKeyword ReservedKeyword |! LispList [LispExpression] |! LispVector [LispExpression] |! LispNumber Integer |! --LispNumber LispNum |! LispString String |! LispBool Bool |! LispFunction LispFunk |! -- LispFunction [LispExpression] LispExpression |! LispNil! deriving (Generic)
9. Parsing
10. Come on bro, really?
11. Reserved keywords (if, def, fn) parseReserved :: Parser LispExpression! parseReserved = do! res <- try (string "def") <|>! try (string "if") <|>! try (string "fn")! return $ toSexp res
12. Numbers parseNumber :: Parser LispExpression! parseNumber = do! _ <- try (many (string "#d"))! sign <- many (oneOf "-")! num <- many1 (digit)! if (length sign) > 1! then pzero! else return $ (LispNumber . read) $ sign ++ num
13. Booleans parseTrue :: Parser LispExpression! parseTrue = do! res <- try (string "true")! return $ LispBool True! ! parseFalse :: Parser LispExpression! parseFalse = do! res <- try (string "false")! return $ LispBool False
14. Booleans parseReserved :: Parser LispExpression! parseReserved = do! res <- try (string "def") <|>! try (string "if") <|>! try (string "fn")! return $ toSexp res! ! parseTrue :: Parser LispExpression! parseTrue = do! res <- try (string "true")! return $ LispBool True
15. Symbols parseSymbol :: Parser LispExpression! parseSymbol = do! first <- letter <|> symbols! rest <- many (letter <|> digit <|> symbols)! let symbol = first:rest! return $ LispSymbol symbol
16. Lists parens parseList <|>! ! ! ! parseList :: Parser LispExpression! parseList = liftM LispList $ sepBy parseLispExpression whiteSpace
17. Lists parseString :: Parser LispExpression! parseString = do _ <- char '"'! x <- many (noneOf "\"")! _ <- char '"'! return $ LispString x
18. So, let’s see how it werkz
19. (+ 1 1) LispList [LispSymbol "plus", ! LispNumber 1, ! LispNumber 1]
20. Evaluation process
21. Easy-peasy
22. Literals evaluate to their values
23. Numbers - to numbers
24. Strings - to strings
25. Lists - recursively evaluate their values left to right
26. Symbols - to…
27. (def a 1)! (def b 2)! (+ a b)
28. (def a 1)! (def b 2)! (+ a b) What is `a`?
29. Let’s check the Environment
30. Ah ok, a is 1
31. (def a 1)! (def b 2)! (+ a b) What is `b`?
32. Ah ok, b is 1
33. Substitution β-reduction
35. (+ a b)! ! ! ! ! ! (+ 1 1) Becomes
36. (def a 1)! (def b 2)! (def c 3)! (def d 4)! ! (+ a b (* c d))
37. (def a 1)! (def b 2)! (def c 3)! (def d 4)! ! (+ a b (* 4 3))
38. (def a 1)! (def b 2)! (def c 3)! (def d 4)! ! (+ a b 12)
39. (def a 1)! (def b 2)! (def c 3)! (def d 4)! ! (+ 1 2 12)
40. When you see the symbol, look for it in Environment
41. Environment
42. Monad is just a box, right?
43. type Environment k v = H.BasicHashTable k v! type LispEnvironment = (Environment LispExpression LispExpression)!
44. findVar :: LispEnvironment -> LispExpression -> ! ! ! ! ! ! IO (Maybe LispExpression)! ! findVar env symbol = H.lookup env symbol!
45. Closures and polluting Environment
46. I’m not polluting, I just don’t need it anymore
47. (def sum ! (fn [a b] ! (fn [c] (+ c a b))))! ! (+ a b) ;; Shouldn't work Creates Closure
48. Closure is a temporary Environment
49. Passed only to recursive calls
50. (def sum ! (fn [a b] ! (fn [c] (+ c a b))))! ! (+ a b) ;; Shouldn't work Limited Visibility
51. That leads us to two-step lookup (shines in Haskell)
52. Look up var value in Closure
53. If there’s no Closure, look up Environment
54. If there’s Closure, look up in Closure first (shadowing)
55. If all fails, error
57. lookup_ <- (liftM2 mplus) ! (findVarMaybe closure func_) ! (findVar envRef func_)
58. (def sum ! (fn [a b] ! (fn [c] (+ c a b))))! ! (+ a b) ;; Shouldn't work Limited Visibility
59. That makes me dance!
61. Built-in Functions
62. Problem: `+` symbol is a “native” function
64. 2 function types
65. data LispFunk = UserFunction [LispExpression] LispExpression |! LibraryFunction String ([LispExpression] -> LispExpression)! deriving (Generic)
66. “User” - is just a lisp expression (list)
67. “Library” - is a Haskell (“native”) function
68. numericOp :: (Integer -> Integer -> Integer) -> ! [LispExpression] -> LispExpression! ! numericOp op args = LispNumber $ foldl1 op $ ! ! ! ! ! ! ! ! ! map unpackNum args! ! builtInOp :: String -> [LispExpression] -> ! LispExpression! builtInOp "+" args = numericOp (+) args
69. If statement
70. Consists of 3 blocks: Test expression Truthy expression Faulty expression
71. Test Expression: True is True (optimisation) Nil is False False is False Anything else is True
72. eval env closure (LispList[(ReservedKeyword IfKeyword), ! ! ! ! ! ! ! ! ! testExpression,! truthyExpression, falsyExpression]) = do! test <- (eval env closure testExpression)! res <- if (isTrue test)! then (eval env closure truthyExpression)! else (eval env closure falsyExpression)! return res
73. Map/reduce
74. Primitives
75. (def empty?! (fn [a] (= a (quote ()))))
77. (def map! (fn [f coll]! (if (empty? coll)! (quote ())! (cons (f (first coll))! (map f (next coll)))))) Recur here
78. (def reduce! (fn [f coll acc]! (if (empty? coll)! acc! (reduce f (next coll) (f acc (first coll)))))) Recur here
79. Bottomline
80. Definition is adding an evaluated expression to hash map
81. Function (fn) captures an enclosed environment and evaluates to internal function primitive
82. If Evaluates only test expression and one of given blocks, skipping the other one
83. Recursion Is given basically for free, since it’s just a var lookup and a function call
84. Evaluation Evaluate left from right, recursively
85. Closures Capture the current environment, dismiss when reaching end of lexical scope
86. Thanks everyone!
88. @ifesdjeen