Takes a TurtleCommand and executes the command on an implicitly created turtle that starts at position (0, 0) with heading north.

This is a convenience function written in terms of runWorld as:

runTurtle c = runWorld $ makeTurtle >>= run c

See also: makeTurtle.

Variant of runTurtle which takes an additional background color parameter.

A TurtleCommand represents an instruction to execute on a turtle. It could be as simple as "draw a line" or more complicated like "draw 300 circles."

TurtleCommands can be executed in order by combining them using the monadic operator (>>).

For example, to draw an equilateral triangle using do notation:

drawTriangle :: TurtleCommand ()
drawTriangle = do
  setHeading east
  forward 100
  left 120
  forward 100
  left 120
  forward 100

Which would produce:

runWorld takes a WorldCommand and produces the animation in a new window!

Interacting with the window.

While running, you can interact with the window in the following way:

Variant of runWorld which takes an additional background color parameter.

A WorldCommand represents an instruction that affects the entire animation canvas.

This could be as simple as "make a turtle" or more complicated, such as "run these 5 turtles in parallel."

Like TurtleCommands, WorldCommands can be executed in sequence by combining commands in order using the monadic operator (>>).

To execute a TurtleCommand within a WorldCommand, use the run function or >/> operator.

For parallel animations, see >!>.

run takes a TurtleCommand and a Turtle to execute the command on. The result of the computation is returned wrapped in a WorldCommand.

For example, to create a turtle and get its x position one might write:

 myCommand :: Turtle -> WorldCommand Float
 myCommand t = do
   (x, _) <- run position t
   return x

Or to create a command that accepts a turtle and draws a right angle:

myCommand :: Turtle -> WorldCommand ()
myCommand = run $ forward 10 >> right 90 >> forward 10

This is an infix version of run where the arguments are swapped.

We take a turtle and a command to execute on the turtle. The result of the computation is returned wrapped in a WorldCommand.

To create a turtle and draw a right-angle:

myCommand :: WorldCommand ()
myCommand = do
  t <- makeTurtle
  t >/> do 
    forward 10
    right 90
    forward 10

While WorldCommands can be combined with (>>) to produce sequential instructions, we can also use the parallel animation operator (>!>) to achieve parallel instructions. That is: animate two turtles at time!

Here is an example:

 import Graphics.WorldTurtle

 main :: IO ()
 main = runWorld $ do
   t1 <- makeTurtle' (0, 0) north green
   t2 <- makeTurtle' (0, 0) north red

   -- Draw the anticlockwise and clockwise circles in sequence. 
   t1 >/> circle 90 >> t2 >/> circle (-90)
 
   clear

   -- Draw the anticlockwise and clockwise circles in parallel.
   t1 >/> circle 90 >!> t2 >/> circle (-90)

Which would produce an animation like this

Note that (>!>) is an alias for bindM2, and is defined as:

 (>!>) = bindM2 (const . return)