Update to latest Spago and PureScript versions.

README.org

@@ -28,7 +28,12 @@ star = do
   forward 100.0
 #+END_SRC
 
+*  Usage
 
-To run the example, build as follows, then point your browser at ~html/index.html~:
+In your shell, type:
 
-: pulp browserify > html/index.js
+: npm install
+: npm run build
+: npm run bundle
+
+Then point your browser to [[./html/index.html]].

package.json

@@ -1,16 +1,21 @@
 {
   "name": "purescript-free-turtle",
   "version": "0.1.0",
-  "description": "A demonstration of a Turtle interpreter based on the Free monad, with HTML Canvas graphics support.",
+  "description": "Turtle graphics language with a free monad Canvas interpreter, for educational purposes.",
   "main": "",
   "private": true,
   "author": "Erik Post",
   "license": "MIT",
+  "scripts": {
+    "postinstall": "npm run spago-install",
+    "build": "spago build",
+    "bundle": "spago bundle-app --main Main --to html/index.js",
+    "spago-install": "spago install"
+  },
   "dependencies": {
-    "grunt": "~0.4.4",
-    "grunt-contrib-copy": "~0.5.0",
-    "grunt-contrib-clean": "~0.5.0",
-    "grunt-execute": "~0.1.5",
-    "grunt-purescript": "~0.5.0"
+  },
+  "devDependencies": {
+    "purescript": "^0.13.8",
+    "spago": "^0.16.0"
   }
 }

src/Canvas.purs

@@ -1,25 +1,23 @@
 module Canvas where
 
 import Prelude
-import Data.Maybe
-import Control.Monad.Eff
+import Data.Maybe (Maybe, maybe)
+import Effect (Effect)
 import Language (Distance (), Angle (), Color (..))
 
-foreign import data Context2D :: *
+foreign import data Context2D :: Type
 
-foreign import data DOM :: !
-
-type Context2DEff = Eff (dom :: DOM) Context2D
+type Context2DEff = Effect Context2D
 
 type CanvasStyleString = String
 
-foreign import get2DContext :: forall eff. String -> Context2DEff
+foreign import get2DContext :: String -> Context2DEff
 
-foreign import initContext :: forall eff. CanvasStyleString -> Context2D -> Context2DEff
+foreign import initContext :: CanvasStyleString -> Context2D -> Context2DEff
 
-foreign import beginStroke :: forall eff. Context2D -> Context2DEff
+foreign import beginStroke :: Context2D -> Context2DEff
 
-foreign import endStroke :: forall eff. Context2D -> Context2DEff
+foreign import endStroke :: Context2D -> Context2DEff
 
 foreign import lineTo :: Distance -> Distance -> Context2D -> Context2DEff
 

src/CanvasInterpreter.purs

@@ -4,11 +4,8 @@ import Prelude
 import Canvas
 import Language
 import Control.Monad
-import Control.Monad.Free
-import Control.Monad.State
-import Control.Monad.Trans
-import Control.Monad.State.Class
-import Control.Monad.Eff
+import Control.Monad.Free (runFreeM)
+import Control.Monad.State (State, evalState, get, modify_, put)
 import Data.Tuple
 import Data.Foldable
 import Math (sin, cos, pi, (%))
@@ -17,7 +14,7 @@ import Math (sin, cos, pi, (%))
 data Turtle = Turtle Distance Distance Angle Boolean
 
 instance turtleShow :: Show Turtle where
-  show (Turtle x y angle isPenDown) = "(Turtle " ++ show x ++ " " ++ show y ++ " " ++ show angle ++ " " ++ show isPenDown ++ ")"
+  show (Turtle x y angle isPenDown) = "(Turtle " <> show x <> " " <> show y <> " " <> show angle <> " " <> show isPenDown <> ")"
 
 
 interpretTurtleProg :: forall a. TurtleProg a -> Context2D -> Context2DEff
@@ -49,7 +46,7 @@ interpretTurtleProg'' = runFreeM interpret
               instr = lineTo x' y'
           put (Turtle x' y' angle p)
 
-          return ((\prog -> prog ++ [instr]) <$> rest)
+          pure ((\prog -> prog <> [instr]) <$> rest)
 
         interpret (Arc r arcAngleDeg rest) = do
           Turtle x y turtleAngle p <- get
@@ -60,24 +57,24 @@ interpretTurtleProg'' = runFreeM interpret
               instr    = drawArc x y r turtleAngle angleEnd
 
           put (Turtle x' y' angle' p)
-          pure (rest <#> (++ [instr]))
+          pure (rest <#> (_ <> [instr]))
 
         interpret (Right angleDeg rest) = do
           let angle = rad angleDeg
-          modify $ \(Turtle x y angle0 p) -> Turtle x y (angle0 + angle) p
-          return rest
+          modify_ $ \(Turtle x y angle0 p) -> Turtle x y (angle0 + angle) p
+          pure rest
 
         interpret (PenUp rest) = do
-          modify $ \(Turtle x y angle _) -> Turtle x y angle false
-          return ((\prog -> prog ++ [endStroke]) <$> rest)
+          modify_ $ \(Turtle x y angle _) -> Turtle x y angle false
+          pure ((\prog -> prog <> [endStroke]) <$> rest)
 
         interpret (PenDown rest) = do
           Turtle x y angle p <- get
           put (Turtle x y angle true)
-          return ((\prog -> prog ++ [beginStroke, moveTo x y]) <$> rest)
+          pure ((\prog -> prog <> [beginStroke, moveTo x y]) <$> rest)
 
         interpret (UseColor col rest) = do
-          return ((\prog -> prog ++ [setStrokeStyle $ colorToCanvasStyle col]) <$> rest)
+          pure ((\prog -> prog <> [setStrokeStyle $ colorToCanvasStyle col]) <$> rest)
 
 
 adjacent r angle = r * cos angle

src/Language.purs

@@ -2,10 +2,7 @@ module Language where
 
 import Prelude
 import Control.Monad
-import Control.Monad.Free
-import Control.Monad.State
-import Control.Monad.Trans
-import Control.Monad.State.Class
+import Control.Monad.Free (Free, liftF)
 
 
 type Angle = Number

src/Main.purs

@@ -5,7 +5,6 @@ import Language
 import CanvasInterpreter
 import Canvas (Context2DEff (..))
 import Control.Monad
-import Control.Monad.Eff
 
 
 main :: Context2DEff