CMa03.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Imperative Programming Languages\n",
    "\n",
    "함수 호출을 추가해 보자"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "컴파일 타겟이 되는 VM의 단순화된 버전을 하스켈로 구현"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- {-# LANGUAGE DeriveFoldable #-}\n",
    "{-# LANGUAGE DeriveFunctor #-}\n",
    "{-# LANGUAGE NoMonomorphismRestriction #-}\n",
    "{-# LANGUAGE FlexibleInstances #-}\n",
    "{-# LANGUAGE FlexibleContexts #-}\n",
    "\n",
    "data Instr pa\n",
    "    = HALT | NEG | ADD | SUB | MUL | DIV\n",
    "    | AND | OR | EQU | NEQ | GR | GEQ | LE | LEQ\n",
    "    | POP | DUP\n",
    "    | LOADc Int | LOADrc Int | LOAD | STORE\n",
    "    | JUMP pa | JUMPz pa | JUMPi pa\n",
    "    | CALL | RETURN | ALLOC Int | SLIDE Int\n",
    "    deriving (Eq, Ord, Show, Functor)\n",
    "\n",
    "-- (FP,code) stack, value stack, 함수 주소들(0번째가 main)\n",
    "type CMa = ([(FA,Code)], Stack, [Code])\n",
    "\n",
    "type Stack = [Value]\n",
    "type Value = Int\n",
    "\n",
    "-- stack address as reverse index of stack\n",
    "type SA = Int\n",
    "\n",
    "-- function address (0이 main, 1이 그 다음 함수, ...)\n",
    "type FA = Int\n",
    "\n",
    "type Code = [Instr PA]\n",
    "\n",
    "-- program address representation\n",
    "newtype PA = PA Code  deriving (Eq,Ord,Show)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Data.List\n",
    "\n",
    "data DotDotDot = DotDotDot\n",
    "\n",
    "instance Show DotDotDot where\n",
    "    show _ = \"...\"\n",
    "\n",
    "-- to prevent infinite printing\n",
    "instance {-# OVERLAPS #-} Show Code where\n",
    "    show is = \"[\"++intercalate \",\" (show . fmap (\\(PA _) -> DotDotDot) <$> is)++\"]\"\n",
    "\n",
    "-- to prevent infinite printing\n",
    "instance {-# OVERLAPS #-} Show CMa where\n",
    "    show ((fp,is):_,vs,_) = \"{ fp = \"++show fp++\", stack = \"++show vs++\",\\n code = \"++show is++\" }\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "-- load and store operation for Stack\n",
    "load :: SA -> Stack -> Value\n",
    "load i vs = reverse vs !! i\n",
    "\n",
    "store :: SA -> Value -> Stack -> Stack\n",
    "store i x vs = vs1++x:vs2\n",
    "    where\n",
    "    (vs1,_:vs2) = splitAt (length vs - 1 - i) vs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Data.Bits\n",
    "\n",
    "step :: CMa -> CMa\n",
    "step ((fp,HALT:_):ps, vs, cs) = ((fp,[]):ps, vs, cs)\n",
    "step ((fp,NEG:is):ps, v : vs, cs) = ((fp,is):ps, (-v):vs, cs)\n",
    "step ((fp,ADD:is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1+v2):vs, cs)\n",
    "step ((fp,SUB:is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1-v2):vs, cs)\n",
    "step ((fp,MUL:is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1*v2):vs, cs)\n",
    "step ((fp,DIV:is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1`div`v2):vs, cs)\n",
    "step ((fp,AND:is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1.&.v2):vs, cs)\n",
    "step ((fp,OR :is):ps, v2:v1:vs, cs) = ((fp,is):ps, (v1.|.v2):vs, cs)\n",
    "step ((fp,EQU:is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1==v2):vs, cs)\n",
    "step ((fp,NEQ:is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1/=v2):vs, cs)\n",
    "step ((fp,GR :is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1> v2):vs, cs)\n",
    "step ((fp,GEQ:is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1>=v2):vs, cs)\n",
    "step ((fp,LE :is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1< v2):vs, cs)\n",
    "step ((fp,LEQ:is):ps, v2:v1:vs, cs) = ((fp,is):ps, b2i(v1<=v2):vs, cs)\n",
    "step ((fp,POP:is):ps, _:vs, cs) = ((fp,is):ps, vs, cs)\n",
    "step ((fp,DUP:is):ps, v:vs, cs) = ((fp,is):ps, v:v:vs, cs)\n",
    "step ((fp,LOADc v :is):ps, vs, cs) = ((fp,is):ps, v:vs, cs)\n",
    "step ((fp,LOADrc j:is):ps, vs, cs) = ((fp,is):ps, (fp+j):vs, cs)\n",
    "step ((fp,LOAD:is):ps, a:vs, cs) = ((fp,is):ps, v:vs, cs) where v = load a vs \n",
    "step ((fp,STORE:is):ps, a:n:vs, cs) = ((fp,is):ps, n:vs', cs) where vs' = store a n vs\n",
    "step ((fp,JUMP (PA c):_):ps, vs, cs) = ((fp,c):ps, vs, cs)\n",
    "step ((fp,JUMPz(PA c):_):ps, 0:vs, cs) = ((fp,c):ps, vs, cs)\n",
    "step ((fp,JUMPz _   :is):ps, _:vs, cs) = ((fp,is):ps, vs, cs)\n",
    "step ((fp,CALL:is):ps, a:vs, cs) = ((fp1,cs!!a):(fp,is):ps, vs, cs) where fp1 = length vs\n",
    "step ((fp,SLIDE m:is):ps, v:vs, cs) = ((fp,is):ps, v:vs', cs) where vs' = drop m vs\n",
    "step ((fp,ALLOC k:is):ps, vs, cs) = ((fp,is):ps, vs', cs) where vs' = replicate k 0 ++ vs\n",
    "step ((fp1,RETURN:is1):(fp,is):ps, vs, cs) = ((fp,is):ps, vs', cs) where vs' = drop (length vs - fp1) vs\n",
    "\n",
    "step vm = error $ \"VM is stuck: \"++show vm\n",
    "\n",
    "i2b 0 = False\n",
    "i2b 1 = True\n",
    "\n",
    "b2i False = 0\n",
    "b2i True  = 1\n",
    "\n",
    "exec :: CMa -> [CMa]\n",
    "exec vm@((_,[]):_,_,_) = [vm]\n",
    "exec vm        = vm : exec (step vm)\n",
    "\n",
    "run :: CMa -> CMa\n",
    "run = last . exec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "type LabeledCode = [LabeledInstr]\n",
    "data LabeledInstr = Label :. Instr Label  deriving Show\n",
    "type Label = String\n",
    "\n",
    "lbis1 :: LabeledCode\n",
    "lbis1 =\n",
    "    [ \"\"     :. LOADc 3\n",
    "    , \"loop\" :. LOADc 1\n",
    "    , \"\"     :. SUB\n",
    "    , \"\"     :. DUP\n",
    "    , \"\"     :. JUMPz \"end\"\n",
    "    , \"\"     :. JUMP \"loop\"\n",
    "    , \"end\"  :. HALT\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import Data.Maybe\n",
    "\n",
    "assemble :: LabeledCode -> Code\n",
    "assemble lbis = is'\n",
    "    where\n",
    "        is' = map (fmap lb2a) is\n",
    "        (lbs,is) = unzip [(lb,i) | lb :. i <- lbis]\n",
    "        lb2a \"\" = error \"empty string label\"\n",
    "        lb2a lb = PA $ tails is' !! elemIndex' lb lbs\n",
    "\n",
    "elemIndex' x xs = fromJust (elemIndex x xs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><div class=\"suggestion-name\" style=\"clear:both;\">Use :</div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Found:</div><div class=\"highlight-code\" id=\"haskell\">[LOADc 3] ++ loop</div></div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Why Not:</div><div class=\"highlight-code\" id=\"haskell\">LOADc 3 : loop</div></div>"
      ],
      "text/plain": [
       "Line 2: Use :\n",
       "Found:\n",
       "[LOADc 3] ++ loop\n",
       "Why not:\n",
       "LOADc 3 : loop"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is1 :: Code\n",
    "is1 = [ LOADc 3 ] ++ loop\n",
    "loop  = [ LOADc 1\n",
    "        , SUB\n",
    "        , DUP\n",
    "        , JUMPz (PA end)\n",
    "        , JUMP  (PA loop) ] ++ end\n",
    "end   = [ HALT ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LOADc 3,LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[LOADc 3,LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "assemble lbis1\n",
    "is1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [],\n",
       " code = [LOADc 3,LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [3],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,3],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2,2],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,2],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0,0],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mapM_ print . exec $ ([(0,is1)],[],[is1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [],\n",
       " code = [LOADc 3,LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [3],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,3],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2,2],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,2],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [LOADc 1,SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [SUB,DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [DUP,JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0,0],\n",
       " code = [JUMPz ...,JUMP ...,HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [HALT] }\n",
       "{ fp = 0, stack = [0],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is1' = assemble lbis1\n",
    "mapM_ print . exec $ ([(0,is1')],[],[is1'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "이제 책 Fig.2.8 (p.13) 에 나온 C언어 코드를 CMa 명령 코드으로 컴파일하는 함수들을 직접 구현해 보자.\n",
    "**식**(expression)을 컴파일하는 `codeR` 및 `codeL`과\n",
    "**문**(statement)을 컴파일하는 `code`를 하스켈로 작성해 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "data Expr\n",
    "    = Lit Int        -- n   (integer literal)\n",
    "    | Var String     -- x\n",
    "    | Neg Expr       -- -e\n",
    "    | Add Expr Expr  -- e1 + e2\n",
    "    | Sub Expr Expr  -- e1 - e2\n",
    "    | Mul Expr Expr  -- e1 * e2\n",
    "    | Div Expr Expr  -- e1 / e2\n",
    "    | And Expr Expr  -- e1 + e2\n",
    "    | Or  Expr Expr  -- e1 || e2\n",
    "    | Equ Expr Expr  -- e1 == e2\n",
    "    | Neq Expr Expr  -- e1 /= e2\n",
    "    | Gr  Expr Expr  -- e1 >  e2\n",
    "    | Geq Expr Expr  -- e1 >= e2\n",
    "    | Le  Expr Expr  -- e1 <= e2\n",
    "    | Leq Expr Expr  -- e1 <  e2\n",
    "    | Assign Expr Expr  -- eL <- eR    (assignment expression. 실제 C문법으로는 eL = eR)\n",
    "    | Call String [Expr] -- f(e1,...,en)\n",
    "    deriving (Eq,Ord,Show)\n",
    "\n",
    "data Stmt\n",
    "    = EStmt Expr                -- e;  (expression as statement)\n",
    "    | Block [Stmt]              -- { s1; ...; sn; }\n",
    "    | If Expr Stmt (Maybe Stmt) -- if (e) s  또는  if (e) s1 else s0\n",
    "    | While Expr Stmt           -- while (e) s\n",
    "    | For (Expr,Expr,Expr) Stmt -- for (e1;e2;e3) s\n",
    "    | Return Expr               -- return e;\n",
    "    deriving (Eq,Ord,Show)\n",
    "\n",
    "type VDec = (String, Expr)\n",
    "type FDec = (String, [String], [VDec], Stmt)\n",
    "\n",
    "type Prog = ([VDec],[FDec])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,2,3,4,5,6]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "[1,2,3] ++ [4,5,6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><div class=\"suggestion-name\" style=\"clear:both;\">Redundant section</div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Found:</div><div class=\"highlight-code\" id=\"haskell\">(4 :) [5, 6, 7]</div></div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Why Not:</div><div class=\"highlight-code\" id=\"haskell\">4 : [5, 6, 7]</div></div>"
      ],
      "text/plain": [
       "Line 1: Redundant section\n",
       "Found:\n",
       "(4 :) [5, 6, 7]\n",
       "Why not:\n",
       "4 : [5, 6, 7]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[4,5,6,7]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(4 :) [5,6,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>foldr :: forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b</span>"
      ],
      "text/plain": [
       "foldr :: forall (t :: * -> *) a b. Foldable t => (a -> b -> b) -> b -> t a -> b"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type foldr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><div class=\"suggestion-name\" style=\"clear:both;\">Redundant lambda</div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Found:</div><div class=\"highlight-code\" id=\"haskell\">c = \\ k\n",
       "      -> codeR e ρ . (JUMPz (PA k) :) . code s ρ . (JUMP (PA (c k)) :)\n",
       "           $ k</div></div><div class=\"suggestion-row\" style=\"float: left;\"><div class=\"suggestion-warning\">Why Not:</div><div class=\"highlight-code\" id=\"haskell\">c k\n",
       "  = codeR e ρ . (JUMPz (PA k) :) . code s ρ . (JUMP (PA (c k)) :) $ k</div></div>"
      ],
      "text/plain": [
       "Line 51: Redundant lambda\n",
       "Found:\n",
       "c = \\ k\n",
       "      -> codeR e ρ . (JUMPz (PA k) :) . code s ρ . (JUMP (PA (c k)) :)\n",
       "           $ k\n",
       "Why not:\n",
       "c k\n",
       "  = codeR e ρ . (JUMPz (PA k) :) . code s ρ . (JUMP (PA (c k)) :) $ k"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import Data.Map (Map, (!), (!?))\n",
    "import qualified Data.Map as Map\n",
    "\n",
    "data Tag = G | L deriving (Eq,Ord,Show)\n",
    "type AEnv = Map String (Tag,Int)\n",
    "\n",
    "codeR :: Expr -> AEnv -> (Code -> Code)\n",
    "codeR (Lit q) _ = (LOADc q :)\n",
    "codeR (Var x) ρ = codeL (Var x) ρ . (LOAD :)\n",
    "codeR (Neg e) ρ = codeR e ρ . (NEG :)\n",
    "codeR (Add e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (ADD :)\n",
    "codeR (Sub e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (SUB :)\n",
    "codeR (Mul e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (MUL :)\n",
    "codeR (Div e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (DIV :)\n",
    "codeR (And e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (AND :)\n",
    "codeR (Or  e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (OR :)\n",
    "codeR (Equ e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (EQU :)\n",
    "codeR (Neq e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (NEQ :)\n",
    "codeR (Gr  e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (GR :)\n",
    "codeR (Geq e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (GEQ :)\n",
    "codeR (Le  e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (LE :)\n",
    "codeR (Leq e1 e2) ρ = codeR e1 ρ . codeR e2 ρ . (LEQ :)\n",
    "codeR (Assign eL eR) ρ = codeR eR ρ . codeL eL ρ . (STORE :)\n",
    "codeR (Call f []) ρ = (ALLOC 1 :) . codeR (Var f) ρ . (CALL :)\n",
    "codeR (Call f es) ρ = foldr1 (.) [codeR e ρ | e <- reverse es]\n",
    "                    . codeR (Var f) ρ . (CALL :) . (SLIDE (length es - 1) :)\n",
    "codeR e _ = error $ \"R-value not defined: \"++show e\n",
    "\n",
    "codeL :: Expr -> AEnv -> (Code -> Code)\n",
    "codeL (Var x) ρ = case ρ!x of (G,a) -> (LOADc a:)\n",
    "                              (L,j) -> (LOADrc j:)\n",
    "codeL e       _   = error $ \"L-value not defined: \"++show e\n",
    "\n",
    "code :: Stmt -> AEnv -> (Code -> Code)\n",
    "code (EStmt e) ρ = codeR e ρ . (POP :)\n",
    "code (Block ss) ρ = foldr (.) id [code s ρ | s <- ss]\n",
    "code (If e s Nothing) ρ =\n",
    "    \\k -> codeR e ρ . (JUMPz (PA k) :)\n",
    "        . code s ρ\n",
    "        $ k\n",
    "code (If e s1 (Just s0)) ρ =\n",
    "    \\k -> codeR e ρ . (JUMPz (PA (c0 k)) :)\n",
    "        . c1 . (JUMP (PA k) :)\n",
    "        . c0\n",
    "        $ k\n",
    "    where\n",
    "        c1 = code s1 ρ\n",
    "        c0 = code s0 ρ\n",
    "code (While e s) ρ = c\n",
    "    where\n",
    "    c = \\k -> codeR e ρ\n",
    "            . (JUMPz (PA k) :)\n",
    "            . code s ρ\n",
    "            . (JUMP (PA (c k)) :)\n",
    "            $ k\n",
    "code (For (e1,e2,e3) s) ρ = code (Block ss) ρ\n",
    "    where ss = [ EStmt e1\n",
    "               , While e2 $ Block [s, EStmt e3]\n",
    "               ] \n",
    "code (Return e) ρ = codeR e ρ . (LOADrc(-1) :) . (STORE :) . (RETURN :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "지금은 변수 메모리 공간은 미리 할당되어 있다고 가정한다.\n",
    "즉, 적절한 *주소환경*(address environment)과 그에 맞는 크기의 stack으로 시작한다고 가정한다는 말이다.\n",
    "\n",
    "예컨대, 아래 코드를 컴파일한다면\n",
    "$\\rho = \\{x\\mapsto 0,\\, i\\mapsto 1\\}$라는 주소환경으로\n",
    "$x$와 $i$에 값을 저장할 주소를 미리 정해 놓고 초기 스택도 그에\n",
    "맞춰 미리 크기를 잡아 놓고 시작하기로 하자. \n",
    "\n",
    "```c\n",
    "int x = 1000;\n",
    "int i = 1;\n",
    "\n",
    "x <- x + i;\n",
    "i <- i + 1;\n",
    "```\n",
    "\n",
    "주소환경과 초기 스택을 적절하게 구성해 놓은 상태로 시작한다면 위 코드는 사실상 아래와 같은 코드를 컴파일하는 것과 같다.\n",
    "\n",
    "```c\n",
    "x <- 1000;\n",
    "i <- 1;\n",
    "\n",
    "x <- x + i;\n",
    "i <- i + 1;\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "stmt3 = Block \n",
    "    [ EStmt $ Assign (Var \"x\") (Lit 1000)\n",
    "    , EStmt $ Assign (Var \"i\") (Lit 1)\n",
    "    , EStmt $ Assign (Var \"x\") (Add (Var \"x\") (Var \"i\"))\n",
    "    , EStmt $ Assign (Var \"i\") (Add (Var \"i\") (Lit 1))\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "is3 = code stmt3 (Map.fromList [(\"x\",(G,0)),(\"i\",(G,1))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP,HALT]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP,DUP,POP,HALT]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is3 []\n",
    "is3 [HALT]\n",
    "is3 [DUP,POP,HALT]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [0,0],\n",
       " code = [LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1000,0,0],\n",
       " code = [LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [0,1000,0,0],\n",
       " code = [STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1000,0,1000],\n",
       " code = [POP,LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [0,1000],\n",
       " code = [LOADc 1,LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,0,1000],\n",
       " code = [LOADc 1,STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1,0,1000],\n",
       " code = [STORE,POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1,1000],\n",
       " code = [POP,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1000],\n",
       " code = [LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [0,1,1000],\n",
       " code = [LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1000,1,1000],\n",
       " code = [LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1000,1,1000],\n",
       " code = [LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1000,1,1000],\n",
       " code = [ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1001,1,1000],\n",
       " code = [LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [0,1001,1,1000],\n",
       " code = [STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1001,1,1001],\n",
       " code = [POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1001],\n",
       " code = [LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1,1001],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1,1001],\n",
       " code = [LOADc 1,ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,1,1,1001],\n",
       " code = [ADD,LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [2,1,1001],\n",
       " code = [LOADc 1,STORE,POP] }\n",
       "{ fp = 0, stack = [1,2,1,1001],\n",
       " code = [STORE,POP] }\n",
       "{ fp = 0, stack = [2,2,1001],\n",
       " code = [POP] }\n",
       "{ fp = 0, stack = [2,1001],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is3_ = is3 []\n",
    "mapM_ print $ exec ([(0,is3_)],[0,0],[is3_])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [2,1001],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "run ([(0,is3_)],[1,1000],[is3_])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "이번엔 이 프로그램을 컴파일해 보자.\n",
    "\n",
    "```c\n",
    "int x = 1000;\n",
    "int i = 1;\n",
    "while (i < 5) {\n",
    "    x <- x + i;\n",
    "    i <- i + 1;\n",
    "}\n",
    "```\n",
    "\n",
    "마찬가지로 $x$와 $i$에 대한 적절한 주소환경 $\\{x\\mapsto 0,\\,i\\mapsto 1\\}$과 초기 스택으로 시작한다고 가정한다면 아래 코드를 컴파일하면 되는 것이다.\n",
    "```c\n",
    "x <- 1000;\n",
    "i <- 1;\n",
    "while (i < 5) {\n",
    "    x <- x + i;\n",
    "    i <- i + 1;\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "stmt41 = Block \n",
    "    [ EStmt $ Assign (Var \"x\") (Lit 1000)  -- x <- 1000;\n",
    "    , EStmt $ Assign (Var \"i\") (Lit 1)     -- i <- 1;\n",
    "    ]\n",
    "\n",
    "stmt42 = Block\n",
    "    [ While (Le (Var \"i\") (Lit 5)) $ Block                   -- while (i < 5) {\n",
    "        [ EStmt $ Assign (Var \"x\") (Add (Var \"x\") (Var \"i\")) --    x <- x + i;\n",
    "        , EStmt $ Assign (Var \"i\") (Add (Var \"i\") (Lit 1))   --    i <- i + 1;\n",
    "        ]                                                    -- }\n",
    "    ]\n",
    "\n",
    "stmt43 = Block\n",
    "    [ EStmt $ Assign (Var \"x\") (Add (Var \"x\") (Lit 100))     -- x <- x + 100;\n",
    "    , EStmt $ Assign (Var \"i\") (Add (Var \"i\") (Lit 100))     -- i <- i + 100;\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "rho4 = Map.fromList [(\"x\",(G,0)),(\"i\",(G,1))]\n",
    "is41 = code stmt41 rho4\n",
    "is42 = code stmt42 rho4\n",
    "is43 = code stmt43 rho4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 1,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP,JUMP ...]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "[LOADc 1000,LOADc 0,STORE,POP,LOADc 1,LOADc 1,STORE,POP,LOADc 1,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,LOAD,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 1,ADD,LOADc 1,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 100,ADD,LOADc 0,STORE,POP,LOADc 1,LOAD,LOADc 100,ADD,LOADc 1,STORE,POP]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is41 . is42 $ []\n",
    "is41 . is42 . is43 $ []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [1,1000],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is41_is41_ = is41 . is41 $ [] \n",
    "run ([(0,is41_is41_)], [0,0], [is41_is41_])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [5,1010],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is41_is42_ = is41 . is42 $ []\n",
    "run ([(0,is41_is42_)], [0,0], [is41_is42_])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [105,1110],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is41_is42_is43_ = is41 . is42 . is43 $ []\n",
    "run ([(0,is41_is42_is43_)], [0,0], [is41_is42_is43_])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [201,1200],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "is41_is43_is43_ = is41 . is43 . is43 $ []\n",
    "run ([(0,is41_is43_is43_)], [0,0], [is41_is43_is43_]) -- stmt43을 두번 실행했으므로 100을 두번씩 더해 200씩 증가"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "정리하자면, 컴파일 함수 `codeR`, `codeL`, `code`가 *식*(`Expr`) 또는 *문*(`Stmt`)과 *주소환경*(`AEnv`)을 받아 고정된 코드(`Code`)를 결과로 계산하는 대신,\n",
    "뒤이어 오는 **나머지 할 일** 코드를 인자로 받아 전체 코드를 계산해내는 코드 변환 함수(`Code -> Code`)를 결과로 계산하도록 수정하였다.\n",
    "이렇게 함으로써 조건문이나 반복문에서 그 다음 뒤이어 아직 정해지지 않은 코드 위치로 이동하는 코드를 작성하기에 용이해진다.\n",
    "\n",
    "이렇게 **나머지 할 일**이라는 개념을 전문용어로는 continuation이라고 한다. 순차적으로 진행되지 않는 계산을 표현하기 위한 개념으로 다양한 곳에 활용된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "stmt5 = Block \n",
    "    [ EStmt $ Assign (Var \"i\") (Lit 1)                    -- i <- 1;\n",
    "    , While (Le (Var \"i\") (Lit 5)) $                      -- while (i < 5)\n",
    "        EStmt $ Assign (Var \"i\") (Add (Var \"i\") (Lit 1))  --     i <- i + 1;\n",
    "    , EStmt $ Assign (Var \"i\") (Add (Var \"i\") (Lit 1))    -- i <- i + 1;\n",
    "    ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "c5 = code stmt5 (Map.fromList [(\"i\",(G,0))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>/* Styles used for the Hoogle display in the pager */\n",
       ".hoogle-doc {\n",
       "display: block;\n",
       "padding-bottom: 1.3em;\n",
       "padding-left: 0.4em;\n",
       "}\n",
       ".hoogle-code {\n",
       "display: block;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "}\n",
       ".hoogle-text {\n",
       "display: block;\n",
       "}\n",
       ".hoogle-name {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-head {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-sub {\n",
       "display: block;\n",
       "margin-left: 0.4em;\n",
       "}\n",
       ".hoogle-package {\n",
       "font-weight: bold;\n",
       "font-style: italic;\n",
       "}\n",
       ".hoogle-module {\n",
       "font-weight: bold;\n",
       "}\n",
       ".hoogle-class {\n",
       "font-weight: bold;\n",
       "}\n",
       ".get-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "white-space: pre-wrap;\n",
       "}\n",
       ".show-type {\n",
       "color: green;\n",
       "font-weight: bold;\n",
       "font-family: monospace;\n",
       "margin-left: 1em;\n",
       "}\n",
       ".mono {\n",
       "font-family: monospace;\n",
       "display: block;\n",
       "}\n",
       ".err-msg {\n",
       "color: red;\n",
       "font-style: italic;\n",
       "font-family: monospace;\n",
       "white-space: pre;\n",
       "display: block;\n",
       "}\n",
       "#unshowable {\n",
       "color: red;\n",
       "font-weight: bold;\n",
       "}\n",
       ".err-msg.in.collapse {\n",
       "padding-top: 0.7em;\n",
       "}\n",
       ".highlight-code {\n",
       "white-space: pre;\n",
       "font-family: monospace;\n",
       "}\n",
       ".suggestion-warning { \n",
       "font-weight: bold;\n",
       "color: rgb(200, 130, 0);\n",
       "}\n",
       ".suggestion-error { \n",
       "font-weight: bold;\n",
       "color: red;\n",
       "}\n",
       ".suggestion-name {\n",
       "font-weight: bold;\n",
       "}\n",
       "</style><span class='get-type'>c5 :: Code -> Code</span>"
      ],
      "text/plain": [
       "c5 :: Code -> Code"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    ":type c5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[LOADc 1,LOADc 0,STORE,POP,LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c5 [HALT]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{ fp = 0, stack = [0],\n",
       " code = [LOADc 1,LOADc 0,STORE,POP,LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,0],\n",
       " code = [LOADc 0,STORE,POP,LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,1,0],\n",
       " code = [STORE,POP,LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [POP,LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,1],\n",
       " code = [LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,1,1],\n",
       " code = [LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1],\n",
       " code = [LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,1],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,1],\n",
       " code = [LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,1,1],\n",
       " code = [ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2,1],\n",
       " code = [LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,2,1],\n",
       " code = [STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2,2],\n",
       " code = [POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,2],\n",
       " code = [LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2,2],\n",
       " code = [LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,2,2],\n",
       " code = [LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,2],\n",
       " code = [JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2],\n",
       " code = [LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,2],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [2,2],\n",
       " code = [LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,2,2],\n",
       " code = [ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3,2],\n",
       " code = [LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,3,2],\n",
       " code = [STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3,3],\n",
       " code = [POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3],\n",
       " code = [JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3],\n",
       " code = [LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,3],\n",
       " code = [LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3,3],\n",
       " code = [LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,3,3],\n",
       " code = [LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,3],\n",
       " code = [JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3],\n",
       " code = [LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,3],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [3,3],\n",
       " code = [LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,3,3],\n",
       " code = [ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4,3],\n",
       " code = [LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,4,3],\n",
       " code = [STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4,4],\n",
       " code = [POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4],\n",
       " code = [JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4],\n",
       " code = [LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,4],\n",
       " code = [LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4,4],\n",
       " code = [LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,4,4],\n",
       " code = [LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,4],\n",
       " code = [JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4],\n",
       " code = [LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,4],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [4,4],\n",
       " code = [LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,4,4],\n",
       " code = [ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,4],\n",
       " code = [LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,5,4],\n",
       " code = [STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,5],\n",
       " code = [POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5],\n",
       " code = [JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5],\n",
       " code = [LOADc 0,LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,5],\n",
       " code = [LOAD,LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,5],\n",
       " code = [LOADc 5,LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,5,5],\n",
       " code = [LE,JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,5],\n",
       " code = [JUMPz ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,JUMP ...,LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5],\n",
       " code = [LOADc 0,LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,5],\n",
       " code = [LOAD,LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [5,5],\n",
       " code = [LOADc 1,ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [1,5,5],\n",
       " code = [ADD,LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [6,5],\n",
       " code = [LOADc 0,STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [0,6,5],\n",
       " code = [STORE,POP,HALT] }\n",
       "{ fp = 0, stack = [6,6],\n",
       " code = [POP,HALT] }\n",
       "{ fp = 0, stack = [6],\n",
       " code = [HALT] }\n",
       "{ fp = 0, stack = [6],\n",
       " code = [] }"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "c5_ = c5 [HALT]\n",
    "mapM_ print $ exec ([(0,c5_)], [0], [c5_])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Haskell",
   "language": "haskell",
   "name": "haskell"
  },
  "language_info": {
   "codemirror_mode": "ihaskell",
   "file_extension": ".hs",
   "mimetype": "text/x-haskell",
   "name": "haskell",
   "pygments_lexer": "Haskell",
   "version": "9.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}