Refactor TI and add examples for lists

Author: jlam55555

README.md

@@ -1,8 +1,24 @@
-# Fun Lazy Compiler (flc)
+# Fun Lazy Compiler (`flc`)
 A (simulated) compiler for a lazy functional language, following the tutorial by Simon Peyton Jones
 
 See tutorial (for [students][student.pdf]; for [tutors][tutor.pdf])
 
+### Usage
+```text
+fun-lazy-compiler -- a compiler and runtime for the Core lazy functional
+language
+
+Usage: flc [FILES] [-v|--verbose]
+  Compile and evaluate a program in the Core language
+
+Available options:
+  FILES                    Source file(s)
+  -v,--verbose             Print extra debugging information
+  -h,--help                Show this help text
+```
+
+Source files may be a path to a file or `-` to read from stdin. If no source files are specified, `flc` will read a from stdin until EOF.
+
 ### Build instructions
 This project uses the Haskell [Stack][stack] build environment. To build or run tests:
 ```bash
@@ -25,7 +41,8 @@ All Haskell code is auto-formatted using the [brittany][brittany] formatter.
 Sample source files are listed in the `examples/` directory.
 
 ```bash
-$ flc examples/cons.core examples/fibs.core
+$ flc nats.core map.core pe1.core
+233168
 ```
 
 ### Journal

app/Main.hs

@@ -8,7 +8,7 @@ import           Control.Exception
 import           System.IO.Error
 
 import           CorePrelude
-import           Evaluators.TemplateInstantiation.Evaluator
+import           Evaluators.TemplateInstantiation
 import           Evaluators.TemplateInstantiation.State
 import           Language
 import           Lexer
@@ -24,7 +24,7 @@ data FLCConfig = FLCConfig
 flcConfig :: Parser FLCConfig
 flcConfig =
   FLCConfig
-    <$> many (argument str (metavar "FILES" <> help "source files"))
+    <$> many (argument str (metavar "FILES" <> help "Source file(s)"))
     <*> switch
           (long "verbose" <> short 'v' <> help
             "Print extra debugging information"
@@ -72,7 +72,7 @@ performCompileAndPrint FLCConfig { verbose = True } fileContents = mapM_
     , ("Parsed AST"            , show program)
     , ("Prelude", pprint $ preludeDefs ++ extraPreludeDefs)
     , ("Pretty-printed program", pprint program)
-    , ("Evaluation trace"      , showResults results)
+    , ("Evaluation trace"      , showTrace results)
     , ("Program output"        , result)
     ]
   (tokens, program, results, result) = performCompile fileContents
@@ -81,11 +81,13 @@ performCompileAndPrint _ fileContents = putStrLn result
 
 -- Helper to get outputs of compilation stages
 -- Note: separately lexes and parses each files, and joins together
--- the scDefs into one program.
+-- the scDefs into one program. Does not simply concatenate files due
+-- to the specifics of the grammar (strict interleaving of semicolons
+-- between supercombinators, and no trailing semicolons).
 performCompile :: [String] -> ([Token], CoreProgram, [TiState], String)
 performCompile fileContents = (concat tokens, program, results, result)
  where
-  result  = showDataNode . getResult $ results
+  result  = showOutput results
   results = eval . compile $ program
   program = concat asts
   asts    = syntax <$> tokens

examples/cons.core

@@ -1,24 +1,16 @@
+-- Church encoding for `Cons`.
 -- This file will not compile standalone because there
 -- is no `main`. Need to include a driver file.
+-- Can be used alongside `cons.core`.
 -- Requires TI Mark 1.
 
--- Church encoding for `cons`.
-cons x y z = z x y ;
-car x = x K ;
-cdr x = x K1 ;
+-- Note: no definition of `Nil`, because we haven't
+-- defined structured data until TI Mark 5, and we don't
+-- actually need `Nil` until we deal with finite lists.
 
--- LISP-style.....
-caar = compose car car ;
-cadr = compose car cdr ;
-cdar = compose cdr car ;
-cddr = compose cdr cdr ;
-caadr = compose car cadr ;
-caaar = compose car caar ;
-cdadr = compose cdr cadr ;
-cdaar = compose cdr caar ;
-caddr = compose car cddr ;
-cadar = compose car cdar ;
-cdddr = compose cdr cddr ;
-cddar = compose cdr cdar ;
-
-getTenth = compose car (compose cdddr (compose cdddr cdddr))
+-- This will overwrite the list primitives in TI Mark 5.
+-- `cons2.core` may be used without this file to avoid
+-- overwritting the `Cons` primitive.
+Cons x y z = z x y ;
+fst x = x K ;
+snd x = x K1

examples/cons2.core

@@ -0,0 +1,22 @@
+-- This file will not compile standalone because there
+-- is no `main`. Need to include a driver file.
+-- Requires TI Mark 5, or `cons.core` and TI Mark 1.
+
+-- LISP-style.....
+car = fst ;
+cdr = snd ;
+
+caar = compose car car ;
+cadr = compose car cdr ;
+cdar = compose cdr car ;
+cddr = compose cdr cdr ;
+caadr = compose car cadr ;
+caaar = compose car caar ;
+cdadr = compose cdr cadr ;
+cdaar = compose cdr caar ;
+caddr = compose car cddr ;
+cadar = compose car cdar ;
+cdddr = compose cdr cddr ;
+cddar = compose cdr cdar ;
+
+getTenth = compose car (compose cdddr (compose cdddr cdddr))

examples/fibs.core

@@ -1,6 +1,7 @@
 -- Infinite stream of fibonacci numbers.
--- Need to import `cons.core`.
--- Requires TI Mark 4.
-fibsRec a b = cons a (fibsRec b (a + b)) ;
+-- Requires TI Mark 5, or TI Mark 4 with `cons.core`.
+fibsRec a b = Cons a (fibsRec b (a + b)) ;
 fibs = fibsRec 0 1 ;
+
+-- Requires `cons2.core`
 main = getTenth fibs

examples/map.core

@@ -0,0 +1,63 @@
+-- Common list primitives: `map`, `filter`, `fold`, `take`, `drop`, `nth`.
+-- Requires TI Mark 5.
+
+map f xs = caseList xs Nil (map2 f) ;
+map2 f x xs = Cons (f x) (map f xs) ;
+
+filter p xs = caseList xs Nil (filter2 p) ;
+filter2 p x xs =
+  let next = filter p xs in
+  if (p x) (Cons x next) next ;
+
+-- fold(l) :: (a -> b -> a) -> a -> [b] -> [a]
+fold f acc xs = caseList xs acc (fold2 f acc) ;
+fold2 f acc x xs = fold f (f acc x) xs ;
+
+take n xs = if (n <= 0) Nil (caseList xs Nil (take2 n)) ;
+take2 n x xs = Cons x (take (n - 1) xs) ;
+
+takeWhile p xs = caseList xs Nil (takeWhile2 p) ;
+takeWhile2 p x xs = if (p x) (Cons x (takeWhile p xs)) Nil ;
+
+drop n xs = if (n <= 0) xs (caseList xs Nil (drop2 n)) ;
+drop2 n x xs = drop (n - 1) xs ;
+
+nth n xs = caseList xs abort (nth2 n) ;
+nth2 n x xs = if (n <= 0) x (nth (n - 1) xs) ;
+
+-- Sample functions to use with `map`
+inc x = x + 1 ;
+double x = x * 2 ;
+
+-- Sample predicates to use with `filter`
+mod m n = m - (m / n) * n ;     -- should be a primitive
+even x = mod x 2 == 0 ;
+odd x = not (even x) ;
+
+-- Sample accumulators to use with `fold`
+add acc val = acc + val ;
+mul acc val = acc * val ;
+
+-- Example: sum and product of a list
+sum = fold add 0 ;
+prod = fold mul 1 ;
+
+-- Example: generate a linear range from a to b, inclusive
+range a b = map (add a) (take ((b - a) + 1) nats) ;
+
+-- Example: alternative way to write factorial
+-- Requires `nats.core`
+fac2 n =
+  let finiteNats = take n (drop 1 nats) in
+  prod finiteNats 
+
+-- Example programs:
+-- main = nth 10 fibs  -- requires `fibs.core`
+-- main = fac2 10
+-- main = length (range 5 10)
+-- main = fold add 0 (filter even (range 5 10))
+
+-- Would be nice to have a function that can force a list
+-- (because I'm not sure how to do that in this framework
+-- at the moment -- is probably similar to the print list
+-- functionality described at the end of Mark 5 of the TI).

examples/nats.core

@@ -1,6 +1,7 @@
 -- Infinite stream of natural numbers.
--- Need to import `cons.core`.
--- Requires TI Mark 4.
-numsFrom x = cons x (numsFrom (x + 1)) ;
+-- Requires TI Mark 5, or TI Mark 4 with `cons.core`.
+numsFrom x = Cons x (numsFrom (x + 1)) ;
 nats = numsFrom 0 ;
+
+-- Requires `cons2.core`
 main = getTenth nats

examples/ones.core

@@ -1,4 +1,7 @@
 -- Infinite stream of ones.
--- Need to import `cons.core`
--- Requires TI Mark 2.
-main = letrec ones = cons 1 ones in getTenth ones
+-- Requires TI Mark 5, or TI Mark 2 with `cons.core`.
+-- Also requires `cons2.core`.
+ones = Cons 1 ones ;
+
+-- Requires `cons2.core`
+main = letrec ones = Cons 1 ones in getTenth ones

examples/pe1.core

@@ -0,0 +1,14 @@
+-- Project Euler 1. Very slow on the TI evaluator :(
+-- Requires `nats.core`, `map.core`
+N = 1000 ;
+
+ltN x = x < N ;
+
+sumMultsOfMUnderN m =
+  let multsOfM       = map (mul m) nats in
+  let multsOfMUnderN = takeWhile ltN multsOfM in
+  sum multsOfMUnderN ;
+
+main =
+  let f = sumMultsOfMUnderN
+  in f 3 + f 5 - f 15

fun-lazy-compiler.cabal

@@ -28,8 +28,10 @@ library
   exposed-modules:
       Alloc
       CorePrelude
+      Evaluators.TemplateInstantiation
       Evaluators.TemplateInstantiation.Evaluator
       Evaluators.TemplateInstantiation.Node
+      Evaluators.TemplateInstantiation.Primitives
       Evaluators.TemplateInstantiation.PrintUtils
       Evaluators.TemplateInstantiation.State
       Evaluators.TemplateInstantiation.Statistics