6 changed files with 6 additions and 889 deletions
--- a/code/cs325-langs/sols/hw3.lang
+++ b/code/cs325-langs/sols/hw3.lang
@ -1,95 +0,0 @@
 function qselect(xs, k, c) {
    if xs == [] {
        return 0;
    }
    traverser bisector(list: xs, span: (0,len(xs)));
    traverser pivot(list: xs, random: true);
    let pivotE = pop!(pivot);
    let (leftList, rightList) = bisect!(bisector, (x) -> c(x) < c(pivotE));
    if k > len(leftList) + 1 {
        return qselect(rightList, k - len(leftList) - 1, c);
    } elsif k == len(leftList) + 1 {
        return pivotE;
    } else {
        return qselect(leftList, k, c);
    }
 }
 function closestUnsorted(xs, k, n) {
    let min = qselect(list(xs), k, (x) -> abs(x - n));
    let out = [];
    let countEqual = k;
    traverser iter(list: xs, span: (0, len(xs)));
    while valid!(iter) {
        if abs(at!(iter)-n) < abs(min-n) {
            let countEqual = countEqual - 1;
        }
        step!(iter);
    }
    traverser iter(list: xs, span: (0, len(xs)));
    while valid!(iter) {
        if abs(at!(iter)-n) == abs(min-n) and countEqual > 0 {
            let countEqual = countEqual - 1;
            let out = out + [at!(iter)];
        } elsif abs(at!(iter)-n) < abs(min-n) {
            let out = out + [at!(iter)];
        }
        step!(iter);
    }
    return out;
 }
 function closestSorted(xs, k, n) {
    let start = bisect(xs, n);
    let counter = 0;
    traverser left(list: xs, span: (0, start), reverse: true);
    traverser right(list: xs, span: (start, len(xs)));
    while counter != k and canstep!(left) and valid!(right) {
        if abs(at!(left, 1) - n) < abs(at!(right) - n) {
            step!(left);
        } else {
            step!(right);
        }
        let counter = counter + 1;
    }
    while counter != k and (canstep!(left) or valid!(right)) {
        if canstep!(left) { step!(left); }
        else { step!(right); }
        let counter = counter + 1;
    }
    return subset!(left, right);
 }
 sorted function xyz(xs, k) {
    traverser x(list: xs, span: (0,len(xs)));
    let dest = [];
    while valid!(x) {
        traverser z(list: xs, span: (pos!(x)+2,len(xs)));
        traverser y(list: xs, span: (pos!(x)+1,pos!(z)));
        while valid!(y) and valid!(z) {
            if at!(x) + at!(y) == at!(z) {
                let dest = dest + [(at!(x), at!(y), at!(z))];
                step!(z);
            } elsif at!(x) + at!(y) > at!(z) {
                step!(z);
            } else {
                step!(y);
            }
        }
        step!(x);
    }
    return dest;
 }
--- a/code/cs325-langs/src/CommonParsing.hs
+++ b/code/cs325-langs/src/CommonParsing.hs
@ -8,7 +8,7 @@ import Text.Parsec.Combinator
 type Parser a b = Parsec String a b
 kw :: String -> Parser a ()
-kw s = try $ string s <* spaces $> ()
+kw s = string s $> ()
 kwIf :: Parser a ()
 kwIf = kw "if"
@ -19,12 +19,6 @@ kwThen = kw "then"
 kwElse :: Parser a ()
 kwElse = kw "else"
 kwElsif :: Parser a ()
 kwElsif = kw "elsif"
 kwWhile :: Parser a ()
 kwWhile = kw "while"
 kwState :: Parser a ()
 kwState = kw "state"
@ -37,21 +31,6 @@ kwCombine = kw "combine"
 kwRand :: Parser a ()
 kwRand = kw "rand"
 kwFunction :: Parser a ()
 kwFunction = kw "function"
 kwSorted :: Parser a ()
 kwSorted = kw "sorted"
 kwLet :: Parser a ()
 kwLet = kw "let"
 kwTraverser :: Parser a ()
 kwTraverser = kw "traverser"
 kwReturn :: Parser a ()
 kwReturn = kw "return"
 op :: String -> op -> Parser a op
 op s o = string s $> o
@ -68,9 +47,6 @@ var reserved =
        then fail "Can't use reserved keyword as identifier"
        else return name
 list :: Char -> Char -> Char -> Parser a b -> Parser a [b]
 list co cc cd pe = surround co cc $ sepBy pe (char cd >> spaces)
 surround :: Char -> Char -> Parser a b -> Parser a b
 surround c1 c2 pe =
    do
--- a/code/cs325-langs/src/LanguageThree.hs
+++ b/code/cs325-langs/src/LanguageThree.hs
@ -1,461 +0,0 @@
 module LanguageThree where
 import qualified CommonParsing as P
 import qualified PythonAst as Py
 import Control.Monad.State
 import Data.Bifunctor
 import Data.Foldable
 import Data.Functor
 import qualified Data.Map as Map
 import Data.Maybe
 import Text.Parsec hiding (State)
 import Text.Parsec.Char
 import Text.Parsec.Combinator
 {- Data Types -}
 data Op
    = Add
    | Subtract
    | Multiply
    | Divide
    | LessThan
    | LessThanEqual
    | GreaterThan
    | GreaterThanEqual
    | Equal
    | NotEqual
    | And
    | Or
 data Expr
    = TraverserCall String [Expr]
    | FunctionCall String [Expr]
    | BinOp Op Expr Expr
    | Lambda [String] Expr
    | Var String
    | IntLiteral Int
    | BoolLiteral Bool
    | ListLiteral [Expr]
    | TupleLiteral [Expr]
 type Branch = (Expr, [Stmt])
 data Stmt
    = IfElse Branch [Branch] [Stmt]
    | While Branch
    | Traverser String [(String, Expr)]
    | Let Pat Expr
    | Return Expr
    | Standalone Expr
 data Pat
    = VarPat String
    | TuplePat [Pat]
 data SortedMarker = Sorted | Unsorted deriving Eq
 data Function = Function SortedMarker String [String] [Stmt]
 data Prog = Prog [Function]
 {- Parser -}
 type Parser = Parsec String ()
 parseVar :: Parser String
 parseVar = P.var
    [ "if", "elif", "else"
    , "while", "let", "traverser"
    , "function", "sort"
    , "true", "false"
    ]
 parseBool :: Parser Bool
 parseBool = (string "true" $> True) <|> (string "false" $> False)
 parseList :: Parser Expr
 parseList = ListLiteral <$> P.list '[' ']' ',' parseExpr
 parseTupleElems :: Parser [Expr]
 parseTupleElems = P.list '(' ')' ',' parseExpr
 parseTuple :: Parser Expr
 parseTuple = do
    es <- parseTupleElems
    return $ case es of
        e:[] -> e
        _ -> TupleLiteral es
 parseLambda :: Parser Expr
 parseLambda = try $ do
    vs <- P.list '(' ')' ',' parseVar
    string "->" >> spaces
    Lambda vs <$> parseExpr
 parseCall :: Parser Expr
 parseCall = try $ do
    v <- parseVar
    choice
        [ TraverserCall v <$> (char '!' *> parseTupleElems)
        , FunctionCall v <$> parseTupleElems
        ]
 parseBasic :: Parser Expr
 parseBasic = choice
    [ IntLiteral <$> P.int
    , BoolLiteral <$> parseBool
    , try parseCall
    , Var <$> parseVar
    , parseList
    , parseLambda
    , parseTuple
    ]
 parseExpr :: Parser Expr
 parseExpr = P.precedence BinOp parseBasic
    [ P.op "*" Multiply <|> P.op "/" Divide
    , P.op "+" Add <|> P.op "-" Subtract
    , P.op "==" Equal <|> P.op "!=" NotEqual <|>
        try (P.op "<=" LessThanEqual) <|>  P.op "<" LessThan <|>
        try (P.op ">=" GreaterThanEqual) <|>  P.op ">" GreaterThan
    , P.op "and" And
    , P.op "or" Or
    ]
 parseBlock :: Parser [Stmt]
 parseBlock = char '{' >> spaces >> many parseStmt <* char '}' <* spaces
 parseBranch :: Parser Branch
 parseBranch = (,) <$> (parseExpr <* spaces) <*> parseBlock
 parseIf :: Parser Stmt
 parseIf = do
    i <- P.kwIf >> parseBranch
    els <- many (P.kwElsif >> parseBranch)
    e <- try (P.kwElse >> parseBlock) <|> return []
    return $ IfElse i els e
 parseWhile :: Parser Stmt
 parseWhile = While <$> (P.kwWhile >> parseBranch)
 parseTraverser :: Parser Stmt
 parseTraverser = Traverser
    <$> (P.kwTraverser *> parseVar)
    <*> (P.list '(' ')' ',' parseKey) <* char ';' <* spaces
 parseKey :: Parser (String, Expr)
 parseKey = (,)
    <$> (parseVar <* spaces <* char ':' <* spaces)
    <*> parseExpr
 parseLet :: Parser Stmt
 parseLet = Let
    <$> (P.kwLet >> parsePat <* char '=' <* spaces)
    <*> parseExpr <* char ';' <* spaces
 parseReturn :: Parser Stmt
 parseReturn = Return <$> (P.kwReturn >> parseExpr <* char ';' <* spaces)
 parsePat :: Parser Pat
 parsePat = (VarPat <$> parseVar) <|> (TuplePat <$> P.list '(' ')' ',' parsePat)
 parseStmt :: Parser Stmt
 parseStmt = choice
    [ parseTraverser
    , parseLet
    , parseIf
    , parseWhile
    , parseReturn
    , Standalone <$> (parseExpr <* char ';' <* spaces)
    ]
 parseFunction :: Parser Function
 parseFunction = Function
    <$> (P.kwSorted $> Sorted <|> return Unsorted)
    <*> (P.kwFunction >> parseVar)
    <*> (P.list '(' ')' ',' parseVar)
    <*> parseBlock
 parseProg :: Parser Prog
 parseProg = Prog <$> many parseFunction
 parse :: String -> String -> Either ParseError Prog
 parse = runParser parseProg ()
 {- Translation -}
 data TraverserBounds = Range Py.PyExpr Py.PyExpr | Random
 data TraverserData = TraverserData
    { list :: Maybe String
    , bounds :: Maybe TraverserBounds 
    , rev :: Bool
    }
 data ValidTraverserData = ValidTraverserData
    { validList :: String
    , validBounds ::  TraverserBounds
    , validRev :: Bool
    }
 type Translator = State (Map.Map String ValidTraverserData, [Py.PyStmt], Int)
 getScoped :: Translator (Map.Map String ValidTraverserData)
 getScoped = gets (\(m, _, _) -> m)
 setScoped :: Map.Map String ValidTraverserData -> Translator ()
 setScoped m = modify (\(_, ss, i) -> (m, ss, i))
 scope :: Translator a -> Translator a
 scope m = do
    s <- getScoped
    a <- m
    setScoped s
    return a
 clearTraverser :: String -> Translator ()
 clearTraverser s = modify (\(m, ss, i) -> (Map.delete s m, ss, i))
 putTraverser :: String -> ValidTraverserData -> Translator ()
 putTraverser s vtd = modify (\(m, ss, i) -> (Map.insert s vtd m, ss, i))
 getTemp :: Translator String
 getTemp = gets $ \(_, _, i) -> "temp" ++ show i
 freshTemp :: Translator String
 freshTemp = modify (second (+1)) >> getTemp
 emitStatement :: Py.PyStmt -> Translator ()
 emitStatement = modify . first . (:)
 collectStatements :: Translator a -> Translator ([Py.PyStmt], a)
 collectStatements t = do
    modify (first $ const [])
    a <- t
    ss <- gets $ \(_, ss, _) -> ss
    modify (first $ const [])
    return (ss, a)
 withdrawStatements :: Translator (Py.PyStmt) -> Translator [Py.PyStmt]
 withdrawStatements ts =
    (\(ss, s) -> ss ++ [s]) <$> (collectStatements ts)
 requireTraverser :: String -> Translator ValidTraverserData
 requireTraverser s = gets (\(m, _, _) -> Map.lookup s m) >>= handleMaybe
    where
        handleMaybe Nothing = fail "Invalid traverser"
        handleMaybe (Just vtd) = return vtd
 traverserIncrement :: Bool -> Py.PyExpr -> Py.PyExpr -> Py.PyExpr
 traverserIncrement rev by e =
    Py.BinOp op e (Py.BinOp Py.Multiply by (Py.IntLiteral 1))
    where op = if rev then Py.Subtract else Py.Add
 traverserValid :: Py.PyExpr -> ValidTraverserData -> Py.PyExpr
 traverserValid e vtd =
    case validBounds vtd of
        Range f t -> 
            if validRev vtd
            then Py.BinOp Py.GreaterThanEq e f
            else Py.BinOp Py.LessThan e t
        Random -> Py.BoolLiteral True
 traverserStep :: String -> ValidTraverserData -> Py.PyStmt
 traverserStep s vtd =
    case validBounds vtd of
        Range _ _ -> Py.Assign (Py.VarPat s) $ Py.BinOp op (Py.Var s) (Py.IntLiteral 1)
            where op = if validRev vtd then Py.Subtract else Py.Add
        Random -> traverserRandom s $ validList vtd
 traverserRandom :: String -> String -> Py.PyStmt
 traverserRandom s l = 
    Py.Assign (Py.VarPat s) $ Py.FunctionCall (Py.Var "random.randrange")
        [Py.FunctionCall (Py.Var "len") [Py.Var l]]
 hasVar :: String -> Py.PyPat -> Bool
 hasVar s (Py.VarPat s') = s == s'
 hasVar s (Py.TuplePat ps) = any (hasVar s) ps
 hasVar s _ = False
 substituteVariable :: String -> Py.PyExpr -> Py.PyExpr -> Py.PyExpr
 substituteVariable s e (Py.BinOp o l r) =
    Py.BinOp o (substituteVariable s e l) (substituteVariable s e r)
 substituteVariable s e (Py.ListLiteral es) = 
    Py.ListLiteral $ map (substituteVariable s e) es
 substituteVariable s e (Py.DictLiteral es) =
    Py.DictLiteral $
        map (first (substituteVariable s e) . second (substituteVariable s e)) es
 substituteVariable s e (Py.Lambda ps e') =
    Py.Lambda ps $ if any (hasVar s) ps then substituteVariable s e e' else e'
 substituteVariable s e (Py.Var s')
    | s == s' = e
    | otherwise = Py.Var s'
 substituteVariable s e (Py.TupleLiteral es) =
    Py.TupleLiteral $ map (substituteVariable s e) es
 substituteVariable s e (Py.FunctionCall e' es) =
    Py.FunctionCall (substituteVariable s e e') $
        map (substituteVariable s e) es
 substituteVariable s e (Py.Access e' es) =
    Py.Access (substituteVariable s e e') $
        map (substituteVariable s e) es
 substituteVariable s e (Py.Ternary i t e') =
    Py.Ternary (substituteVariable s e i) (substituteVariable s e t)
        (substituteVariable s e e')
 substituteVariable s e (Py.Member e' m) =
    Py.Member (substituteVariable s e e') m
 substituteVariable s e (Py.In e1 e2) =
    Py.In (substituteVariable s e e1) (substituteVariable s e e2)
 substituteVariable s e (Py.NotIn e1 e2) =
    Py.NotIn (substituteVariable s e e1) (substituteVariable s e e2)
 substituteVariable s e (Py.Slice f t) =
    Py.Slice (substituteVariable s e <$> f) (substituteVariable s e <$> t)
 translateExpr :: Expr -> Translator Py.PyExpr
 translateExpr (TraverserCall "pop" [Var s]) = do
    l <- validList <$> requireTraverser s
    return $ Py.FunctionCall (Py.Member (Py.Var l) "pop") [Py.Var s]
 translateExpr (TraverserCall "pos" [Var s]) = do
    requireTraverser s
    return $ Py.Var s
 translateExpr (TraverserCall "at" [Var s]) = do
    l <- validList <$> requireTraverser s
    return $ Py.Access (Py.Var l) [Py.Var s]
 translateExpr (TraverserCall "at" [Var s, IntLiteral i]) = do
    vtd <- requireTraverser s
    return $ Py.Access (Py.Var $ validList vtd)
        [traverserIncrement (validRev vtd) (Py.IntLiteral i) (Py.Var s)]
 translateExpr (TraverserCall "step" [Var s]) = do
    vtd <- requireTraverser s
    emitStatement $ traverserStep s vtd
    return $ Py.IntLiteral 0
 translateExpr (TraverserCall "canstep" [Var s]) = do
    vtd <- requireTraverser s
    return $
        traverserValid
            (traverserIncrement (validRev vtd) (Py.IntLiteral 1) (Py.Var s)) vtd
 translateExpr (TraverserCall "valid" [Var s]) = do
    vtd <- requireTraverser s
    return $ traverserValid (Py.Var s) vtd
 translateExpr (TraverserCall "subset" [Var s1, Var s2]) = do
    l1 <- validList <$> requireTraverser s1
    l2 <- validList <$> requireTraverser s2
    if l1 == l2
    then return $ Py.Access (Py.Var l1) [Py.Slice (Just $ Py.Var s1) (Just $ Py.Var s2)]
    else fail "Incompatible traversers!"
 translateExpr (TraverserCall "bisect" [Var s, Lambda [x] e]) = do
    vtd <- requireTraverser s
    newTemp <- freshTemp
    lambdaExpr <- translateExpr e
    let access = Py.Access (Py.Var $ validList vtd) [Py.Var s]
    let translated = substituteVariable x access lambdaExpr
    let append s = Py.FunctionCall (Py.Member (Py.Var s) "append") [ access ]
    let bisectStmt = Py.FunctionDef newTemp []
         [ Py.Nonlocal [s]
         , Py.Assign (Py.VarPat "l") (Py.ListLiteral [])
         , Py.Assign (Py.VarPat "r") (Py.ListLiteral [])
         , Py.While (traverserValid (Py.Var s) vtd)
            [ Py.IfElse translated
                [ Py.Standalone $ append "l" ]
                []
                (Just [ Py.Standalone $ append "r" ])
            , traverserStep s vtd
            ]
         , Py.Return $ Py.TupleLiteral [Py.Var "l", Py.Var "r"]
         ]
    emitStatement bisectStmt
    return $ Py.FunctionCall (Py.Var newTemp) []
 translateExpr (TraverserCall _ _) = fail "Invalid traverser operation"
 translateExpr (FunctionCall f ps) = do
    pes <- mapM translateExpr ps
    return $ Py.FunctionCall (Py.Var f) pes 
 translateExpr (BinOp o l r) =
    Py.BinOp (translateOp o) <$> translateExpr l <*> translateExpr r
 translateExpr (Lambda ps e) =
    Py.Lambda (map Py.VarPat ps) <$> translateExpr e
 translateExpr (Var s) = return $ Py.Var s
 translateExpr (IntLiteral i) = return $ Py.IntLiteral i
 translateExpr (BoolLiteral b) = return $ Py.BoolLiteral b
 translateExpr (ListLiteral es) = Py.ListLiteral <$> mapM translateExpr es
 translateExpr (TupleLiteral es) = Py.TupleLiteral <$> mapM translateExpr es
 applyOption :: TraverserData -> (String, Py.PyExpr) -> Maybe TraverserData
 applyOption td ("list", Py.Var s) =
    return $ td { list = Just s }
 applyOption td ("span", Py.TupleLiteral [f, t]) =
    return $ td { bounds = Just $ Range f t }
 applyOption td ("random", Py.BoolLiteral True) =
    return $ td { bounds = Just Random }
 applyOption td ("reverse", Py.BoolLiteral b) =
    return $ td { rev = b }
 applyOption td _ = Nothing
 translateOption :: (String, Expr) -> Translator (String, Py.PyExpr)
 translateOption (s, e) = (,) s <$> translateExpr e
 defaultTraverser :: TraverserData
 defaultTraverser =
    TraverserData { list = Nothing, bounds = Nothing, rev = False }
 translateBranch :: Branch -> Translator (Py.PyExpr, [Py.PyStmt])
 translateBranch (e, s) = (,) <$> translateExpr e <*>
    (concat <$> mapM (withdrawStatements . translateStmt) s)
 translateStmt :: Stmt -> Translator Py.PyStmt
 translateStmt (IfElse i els e) = uncurry Py.IfElse
    <$> (translateBranch i) <*> (mapM translateBranch els) <*> convertElse e
    where
        convertElse [] = return Nothing
        convertElse es = Just . concat <$>
            mapM (withdrawStatements . translateStmt) es
 translateStmt (While b) = uncurry Py.While <$> translateBranch b
 translateStmt (Traverser s os) =
    foldlM applyOption defaultTraverser <$> mapM translateOption os >>= saveTraverser 
    where
        saveTraverser :: Maybe TraverserData -> Translator Py.PyStmt
        saveTraverser (Just (td@TraverserData { list = Just l, bounds = Just bs})) =
            putTraverser s vtd $> translateInitialBounds s vtd
            where
                vtd = ValidTraverserData
                    { validList = l
                    , validBounds = bs
                    , validRev = rev td
                    }
        saveTraverser Nothing = fail "Invalid traverser (!)"
 translateStmt (Let p e) = Py.Assign <$> translatePat p <*> translateExpr e
 translateStmt (Return e) = Py.Return <$> translateExpr e
 translateStmt (Standalone e) = Py.Standalone <$> translateExpr e
 translateInitialBounds :: String -> ValidTraverserData -> Py.PyStmt
 translateInitialBounds s vtd =
    case (validBounds vtd, validRev vtd) of
        (Random, _) -> traverserRandom s $ validList vtd
        (Range l _, False) -> Py.Assign (Py.VarPat s) l
        (Range _ r, True) -> Py.Assign (Py.VarPat s) r
 translatePat :: Pat -> Translator Py.PyPat
 translatePat (VarPat s) = clearTraverser s $> Py.VarPat s
 translatePat (TuplePat ts) = Py.TuplePat <$> mapM translatePat ts
 translateOp :: Op -> Py.PyBinOp
 translateOp Add = Py.Add
 translateOp Subtract = Py.Subtract
 translateOp Multiply = Py.Multiply
 translateOp Divide = Py.Divide
 translateOp LessThan = Py.LessThan
 translateOp LessThanEqual = Py.LessThanEq
 translateOp GreaterThan = Py.GreaterThan
 translateOp GreaterThanEqual = Py.GreaterThanEq
 translateOp Equal = Py.Equal
 translateOp NotEqual = Py.NotEqual
 translateOp And = Py.And
 translateOp Or = Py.Or
 translateFunction :: Function -> [Py.PyStmt]
 translateFunction (Function m s ps ss) = return $ Py.FunctionDef s ps $
    [ Py.Standalone $ Py.FunctionCall (Py.Member (Py.Var p) "sort") []
        | p <- take 1 ps, m == Sorted ] ++ stmts
    where
        stmts = concat $ evalState
            (mapM (withdrawStatements . translateStmt) ss) (Map.empty, [], 0)
 translate :: Prog -> [Py.PyStmt]
 translate (Prog fs) =
    (Py.FromImport "bisect" ["bisect"]) :
    (Py.Import "random") : concatMap translateFunction fs
--- a/code/cs325-langs/src/PythonAst.hs
+++ b/code/cs325-langs/src/PythonAst.hs
@ -24,7 +24,7 @@ data PyExpr
    | DictLiteral [(PyExpr, PyExpr)]
    | Lambda [PyPat] PyExpr
    | Var String
-    | TupleLiteral [PyExpr]
+    | Tuple [PyExpr]
    | FunctionCall PyExpr [PyExpr]
    | Access PyExpr [PyExpr]
    | Ternary PyExpr PyExpr PyExpr
@ -47,6 +47,3 @@ data PyStmt
    | FunctionDef String [String] [PyStmt]
    | Return PyExpr
    | Standalone PyExpr
    | Import String
    | FromImport String [String]
    | Nonlocal [String]
--- a/code/cs325-langs/src/PythonGen.hs
+++ b/code/cs325-langs/src/PythonGen.hs
@ -46,11 +46,6 @@ translateStmt (FunctionDef s ps b) = block head body
        body = stmtBlock b
 translateStmt (Return e) = ["return " ++ translateExpr e]
 translateStmt (Standalone e) = [translateExpr e]
 translateStmt (Import s) = ["import " ++ s]
 translateStmt (FromImport s ss) =
    ["from " ++ s ++ " import " ++ intercalate "," ss]
 translateStmt (Nonlocal vs) = 
    ["nonlocal " ++ intercalate "," vs]
 precedence :: PyBinOp -> Int
 precedence Add = 3
@ -79,12 +74,12 @@ opString GreaterThan = ">"
 opString GreaterThanEq = ">="
 opString Equal = "=="
 opString NotEqual = "!="
-opString And = " and "
+opString And = "and"
-opString Or = " or "
+opString Or = "or"
 translateOp :: PyBinOp -> PyBinOp -> PyExpr -> String
 translateOp o o' =
-    if precedence o > precedence o'
+    if precedence o < precedence o'
    then parenth . translateExpr
    else translateExpr
@ -114,7 +109,7 @@ translateExpr (Lambda ps e) = parenth (head ++ ": " ++ body)
        head = "lambda " ++ intercalate ", " (map translatePat ps)
        body = translateExpr e
 translateExpr (Var s) = s
-translateExpr (TupleLiteral es) = list "(" ")" es
+translateExpr (Tuple es) = list "(" ")" es
 translateExpr (FunctionCall f ps) = translateExpr f ++ list "(" ")" ps
 translateExpr (Access (Var s) e) = s ++ list "[" "]" e
 translateExpr (Access e@Access{} i) = translateExpr e ++ list "[" "]" i
--- a/content/blog/02_cs325_languages_hw3.md
+++ b/content/blog/02_cs325_languages_hw3.md
@ -1,295 +0,0 @@
 ---
 title: A Language for an Assignment - Homework 3
 date: 2020-01-02T22:17:43-08:00
 tags: ["Haskell", "Python", "Algorithms"]
 draft: true
 ---
 It rained in Sunriver on New Year's Eve, and it continued to rain
 for the next couple of days. So, instead of going skiing as planned,
 to the dismay of my family and friends, I spent the majority of
 those days working on the third language for homework 3. It
 was quite the language, too - the homework has three problems, each of
 which has a solution independent of the others. I invite you
 to join me in my descent into madness as we construct another language.
 ### Homework 3
 Let's take a look at the three homework problems. The first two are
 related, but are solved using a different technique:
 {{< codelines "text" "cs325-langs/hws/hw3.txt" 18 30 >}}
 This problem requires us to find the `k` numbers closest to some
 query (which I will call `n`) from a list `xs`. The list isn't sorted, and the
 problem must run in linear time. Sorting the list would require
 the standard
 {{< sidenote "right" "n-note" "\(O(n\log n)\) time." >}}
 The \(n\) in this expression is not the same as the query <code>n</code>,
 but rather the length of the list. In fact, I have not yet assigned
 the length of the input <code>xs</code> to any variable. If we say that
 \(m\) is a number that denotes that length, the proper expression
 for the complexity is \(O(m \log m)\).
 {{< /sidenote >}} Thus, we have to take another route, which should
 already be familiar: quickselect. Using quickselect, we can find the `k`th
 closest number, and then collect all the numbers that are closer than the `kth`
 closest number. So, we need a language that:
 * Supports quickselect (and thus, list partitioning and recursion).
 * Supports iteration, {{< sidenote "left" "iteration-note" "multiple times." >}}
 Why would we need to iterate multiple times? Note that we could have a list
 of numbers that are all the same, <code>[1,1,1,1,1]</code>. Then, we'll need
 to know how many of the numbers <em>equally close</em> as the <code>k</code>th
 element we need to include, which will require another pass through the list.
 {{< /sidenote >}}
 That's a good start. Let's take a look at the second problem:
 {{< codelines "text" "cs325-langs/hws/hw3.txt" 33 47 >}}
 This problem really is easier. We have to find the position of _the_ closest
 element, and then try expand towards either the left or right, depending on
 which end is better. This expansion will take several steps, and will
 likely require a way to "look" at a given part of the list. So let's add two more
 rules. We need a language that also:
 * Supports looping control flow, such as `while`.
 * {{< sidenote "right" "view-note" "Allows for a \"view\" into the list" >}}
 We could, of course, simply use list indexing. But then, we'd just be making
 a simple imperative language, and that's boring. So let's play around
 with our design a little, and experimentally add such a "list view" component.
 {{< /sidenote >}}
 (like an abstraction over indexing).
 This is shaping up to be a fun language. Let's take a look at the last problem:
 {{< codelines "text" "cs325-langs/hws/hw3.txt" 50 64 >}}
 This problem requires more iterations of a list. We have several
 {{< sidenote "right" "cursor-note" "\"cursors\"" >}}
 I always make the language before I write the post, since a lot of
 design decisions change mid-implementation. I realize now that
 "cursors" would've been a better name for this language feature,
 but alas, it is too late.
 {{< /sidenote >}} looking into the list, and depending if the values
 at each of the cursors add up, we do or do not add a new tuple to a list. So,
 two more requirements:
 * The "cursors" must be able to interact.
 * The language can represent {{< sidenote "left" "tuple-note" "tuples." >}}
 We could, of course, hack some other way to return a list of tuples, but
 it turns out tuples are pretty simple to implement, and help make for nicer
 programming in our language.
 {{< /sidenote >}}
 I think we've gathered what we want from the homework. Let's move on to the
 language!
 ### A Language
 As is now usual, let's envision a solution to the problems in our language. There
 are actually quite a lot of functions to look at, so let's see them one by one.
 First, let's look at `qselect`.
 {{< codelines "text" "cs325-langs/sols/hw3.lang" 1 19 >}}
 After the early return, the first interesting part of the language is the
 use of what I have decided to call a __list traverser__. The list
 traverser is a __generalization of a list index__. Whenever we use a list
 index variable, we generally use the following operations:
 * __Initialize__: we set the list index to some initial value, such as 0.
 * __Step__: If we're walking the list from left to right, we increment the index.
 If we're walking the list from right to left, we decrement the index.
 * __Validity Check__: We check if the index is still valid (that is, we haven't
 gone past the edge of the list).
 * __Access__: Get the element the cursor is pointing to.
 A {{< sidenote "right" "cpp-note" "traverser declaration" >}}
 A fun fact is that we've just rediscovered C++
 <a href="http://www.cplusplus.com/reference/iterator/">iterators</a>. C++
 containers and their iterators provide us with the operations I described:
 We can initialize an iterator like <code>auto it = list.begin()</code>. We
 can step the iterator using <code>it++</code>. We can check its validity
 using <code>it != list.end()</code>, and access what it's pointing to using
 <code>*it</code>. While C++ uses templates and inheritance for this,
 we define a language feature specifically for lists.
 {{< /sidenote >}} describes these operations. The declartion for the `bisector`
 traverser creates a "cursor" over the list `xs`, that goes between the 0th
 and last elements of `xs`. The declaration for the `pivot` traverser creates
 a "cursor" over the list `xs` that jumps around random locations in the list.
 The next interesting part of the language is a __traverser macro__. This thing,
 that looks like a function call (but isn't), performs an operation on the
 cursor. For instance, `pop!` removes the element at the cursor from the list,
 whereas `bisect!` categorizes the remaining elements in the cursor's list
 into two lists, using a boolean-returning lambda (written in Java syntax).
 Note that this implementation of `qselect` takes a function `c`, which it
 uses to judge the actual value of the number. This is because our `qselect`
 won't be finding _the_ smallest number, but the number with the smallest difference
 with `n`. `n` will be factored in via the function.
 Next up, let's take a look at the function that uses `qselect`, `closestUnsorted`:
 {{< codelines "text" "cs325-langs/sols/hw3.lang" 21 46 >}}
 Like we discussed, it finds the `k`th closest element (calling it `min`),
 and counts how many elements that are __equal__ need to be included,
 by setting the number to `k` at first, and subtracting 1 for every number
 it encounters that's closer than `min`. Notice that we use the `valid!` and
 `step!` macros, which implement the opertions we described above. Notice
 that the user doesn't deal with adding and subtracting numbers, and doing
 comparisons. All they have to do is ask "am I still good to iterate?"
 Next, let's take a look at `closestSorted`, which will require more
 traverser macros.
 {{< codelines "text" "cs325-langs/sols/hw3.lang" 48 70 >}}
 The first new macro is `canstep!`. This macro just verifies that
 the traverser can make another step. We need this for the "reverse" iterator,
 which indicates the lower bound of the range of numbers we want to return,
 because `subset!` (which itself is just Python's slice, like `xs[a:b]`), uses an inclusive bottom
 index, and thus, we can't afford to step it before knowing that we can, and that
 it's a better choice after the step.
 Similarly, we have the `at!(t, i)` macro, which looks at the
 traverser `t`, with offset `i`.
 We have two loops. The first loop runs as long as we can expand the range in both
 directions, and picks the better direction at each iteration. The second loop
 runs as long as we still want more numbers, but have already hit the edge
 of the list on the left or on the right.
 Finally, let's look at the solution to `xyz`:
 {{< codelines "text" "cs325-langs/sols/hw3.lang" 72 95 >}}
 I won't go in depth, but notice that the expression in the `span` part
 of the `traverser` declaration can access another traverser. We treat
 as a feature the fact that this expression isn't immediately evaluated at the place
 of the traverser declaration. Rather, every time that a comparison for a traverser
 operation is performed, this expression is re-evaluated. This allows us to put
 dynamic bounds on traversers `y` and `z`, one of which must not exceed the other.
 This is more than enough to work with. Let's move on to the implementation.
 #### Implementation
 Again, let's not go too far into the details of implementing the language from scratch.
 Instead, let's take a look into specific parts of the language that deserve attention.
 ##### Revenge of the State Monad
 Our previous language was, indeed, a respite from complexity. Translation was
 straightforward, and the resulting expressions and statements were plugged straight
 into a handwritten AST. We cannot get away with this here; the language is powerful
 enough to implement three list-based problems, which comes at the cost of increased 
 complexity.
 We need, once again, to generate temporary variables. We also need to keep track of
 which variables are traversers, and the properties of these traversers, throughout
 each function of the language. We thus fall back to using `Control.Monad.State`:
 {{< todo >}}Code for Translator Monad{{< /todo >}}
 There's one part of the state tuple that we haven't yet explained: the list of
 statements.
 ##### Generating Statements
 Recall that our translation function for expressions in the first homework had the type:
 ```Haskell
 translateExpr :: Expr -> Translator ([Py.PyStmt], Py.PyExpr)
 ```
 We then had to use `do`-notation, and explicitly concatenate lists
 of emitted statements. In this language, I took an alternative route: I made
 the statements part of the state. They are thus implicitly generated and
 stored in the monad, and expression generators don't have to worry about
 concatenating them. When the program is ready to use the generated statements
 (say, when an `if`-statement needs to use the statements emitted by the condition
 expression), we retrieve them from the monad:
 {{< todo >}}Code for getting statements{{< /todo >}}
 ##### Validating Traverser Declarations
 We declare two separate types that hold traverser data. The first is a kind of "draft"
 type, `TraverserData`. This record holds all possible configurations of a traverser
 that occur as the program is iterating through the various `key: value` pairs in
 the declaration. For instance, at the very beginning of processing a traverser declaration,
 our program will use a "default" `TraverserData`, with all fields set to `Nothing` or
 their default value. This value will then be modified by the first key/value pair,
 changing, for instance, the list that the traverser operates on. This new modified
 `TraverserData` will then be modified by the next key/value pair, and so on. This
 is, effectively, a fold operation.
 {{< todo >}}Code for TraverserData{{< /todo >}}
 {{< todo >}}Maybe sidenote about fold?{{< /todo >}}
 The data may not have all the required fields until the very end, and its type
 reflects that: `Maybe String` here, `Maybe TraverserBounds` there. We don't
 want to deal with unwrapping the `Maybe a` values every time we use the traverser,
 especially if we've done so before. So, we define a `ValidTraverserData` record,
 that does not have `Maybe` arguments, and thus, has all the required data. At the
 end of a traverser declaration, we attempt to translate a `TraverserData` into
 a `ValidTraverserData`, invoking `fail` if we can't, and storing the `ValidTraverserData`
 into the state otherwise. Then, every time we retrieve a traverser from the state,
 it's guaranteed to be valid, and we have to spend no extra work unpacking it. We
 define a lookup monadic operation like this:
 {{< todo >}}Code for getting ValidTraverserData{{< /todo >}}
 ##### Compiling Macros
 I didn't call them macros for no reason. Clearly, we don't want to generate
 code that
 {{< sidenote "right" "increment-note" "calls functions only to increment an index." >}}
 In fact, there's no easy way to do this at all. Python's integers (if we choose to
 represent our traversers using integers), are immutable. Furthermore, unlike C++,
 where passing by reference allows a function to change its parameters "outside"
 the call, Python offers no way to reassign a different value to a variable given
 to a function.
 <br><br>
 For an example use of C++'s pass-by-reference mechanic, consider <code>std::swap</code>:
 it's a function, but it modifies the two variables given to it. There's no
 way to generically implement such a function in Python.
 {{< /sidenote >}} We also can't allow arbitrary expressions to serve as traversers:
 our translator keeps some context about which variables are traversers, what their
 bounds are, and how they behave. Thus, __calls to traverser macros are very much macros__:
 they operate on AST nodes, and __require__ that their first argument is a variable,
 named like the traverser. We use the `requireTraverser` monadic operation
 to get the traverser associated with the given variable name, and then perform
 the operation as intended. The `at!(t)` operation is straightforward:
 {{< todo >}}Code for at!{{< /todo >}}
 The `at!(t,i)` is less so, since it deals with the intricacies of accessing
 the list at either a positive of negative offset, depending on the direction
 of the traverser. We implement a function to properly generate an expression for the offset:
 {{< todo >}}Code for traverserIncrement{{< /todo >}}
 We then implement `at!(t,i)` as follows:
 {{< todo >}}Code for at!{{< /todo >}}
 The most complicated macro is `bisect!`. It must be able to step the traverser,
 and also return a tuple of two lists that the bisection yields. We also
 prefer that it didn't pollute the environment with extra variables. To
 achieve this, we want `bisect!` to be a function call. We want this
 function to implement the iteration and list construction.
 `bisect!`, by definition, takes a lambda. This lambda, in our language, is declared
 in the lexical scope in which `bisect!` is called. Thus, to guarantee correct translation,
 we must do one of two things:
 1. Translate 1-to-1, and create a lambda, passing it to a fixed `bisect` function declared
 elsewhere.
 2. Translate to a nested function declaration, inlining the lambda.
 {{< todo >}}Maybe sidenote about inline?{{< /todo >}}
 Since I quite like the idea of inlining a lambda, let's settle for that. To do this,
 we pull a fresh temporary variable and declare a function, into which we place
 the traverser iteration code, as well as the body of the lambda, with the variable
 substituted for the list access expression. Here's the code:
 {{< todo >}}Code for bisect!{{< /todo >}}