-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell Lindenmayer Systems
--   
--   Haskell library for generating Lindemayer systems
@package hls
@version 0.11


-- | Standard <a>Turtle</a> graphics.
module LSystem.Turtle

-- | Turtle.
data Turtle
Turtle :: Double -> Double -> Pt -> Double -> Double -> Double -> [Turtle] -> Turtle

-- | turning angle
ta :: Turtle -> Double

-- | turning angle increment
tai :: Turtle -> Double

-- | location
loc :: Turtle -> Pt

-- | heading
hdg :: Turtle -> Double

-- | line length
ll :: Turtle -> Double

-- | length scalar
ls :: Turtle -> Double

-- | turtle stack
stk :: Turtle -> [Turtle]

-- | Right turn by <a>ta</a>.
turnRight :: Turtle -> Turtle

-- | Left turn by <a>ta</a>.
turnLeft :: Turtle -> Turtle

-- | <tt>180</tt> degree turn.
turnBack :: Turtle -> Turtle

-- | Increment line length (<a>ll</a>) by multiplying by line scalar
--   (<a>ls</a>).
incrLine :: Turtle -> Turtle

-- | Decrement line length (<a>ll</a>) by dividing by line scalar
--   (<a>ls</a>).
decrLine :: Turtle -> Turtle

-- | Move <a>loc</a> of <a>Turtle</a> by <a>ll</a> on current <a>hdg</a>.
forward :: Turtle -> Turtle

-- | Push <a>Turtle</a> onto <a>stk</a>.
push :: Turtle -> Turtle

-- | Fetch <a>Turtle</a> from <a>stk</a>.
pop :: Turtle -> Turtle

-- | Given state processing function <i>f</i>, a <a>Turtle</a> and an
--   initial state, step <a>Turtle</a> and state.
stepTurtle :: (t -> Pt -> Pt -> b) -> Turtle -> t -> (Turtle, b)


-- | Lindenmayer system definition, expander and renderer.
module LSystem.LSystem

-- | Element of <a>Axiom</a>.
type Element = Char

-- | An axiom (sequence of <tt>Elements</tt>).
type Axiom = [Element]

-- | A <a>Map</a> from <a>Element</a>s to <a>Axiom</a>s.
type Rules = Map Element Axiom

-- | An <a>LSystem</a> is an <a>Axiom</a> and a set of <a>Rules</a>.
data LSystem
LSystem :: Axiom -> Rules -> LSystem

-- | L-System constructor.
--   
--   <pre>
--   lSystem "F+F+F" [('F',"F-F+F")]
--   </pre>
lSystem :: Axiom -> [(Element, [Element])] -> LSystem

-- | Rule lookup.
getRule :: Rules -> Element -> [Element]

-- | Rule application.
applyRule :: [Element] -> Rules -> [Element]

-- | <i>n</i> iterations of the specified <a>LSystem</a>.
--   
--   <pre>
--   expand (lSystem "F+F+F" [('F',"F-F+F")]) 1 == "F-F+F+F-F+F+F-F+F"
--   </pre>
expand :: LSystem -> Int -> [Element]

-- | State transformer <a>Turtle</a> commands.
stateT :: Element -> Turtle -> Turtle

-- | Operational <a>Turtle</a> commands.
cmd :: (Turtle -> b -> (Turtle, b)) -> Element -> Turtle -> b -> (Turtle, b)

-- | Fold over an expanded L-system using standard turtle commands.
render :: b -> (b -> Pt -> Pt -> b) -> [Element] -> Turtle -> b
instance Eq LSystem
instance Show LSystem


-- | Postscript renderer for <a>LSystem</a>s.
module LSystem.Render.PS

-- | Given initial <a>ta</a>, <a>ls</a> and <a>ll</a> values render
--   <i>i</i> steps of an <a>LSystem</a>.
renderL :: (LSystem, Double, Double) -> Int -> Double -> [(Pt, Pt)]

-- | Given a scalar and a <a>Path</a> render a <a>greyGS</a> <a>Image</a>.
draw :: Double -> Path -> Image

-- | Rendering functions for grounded (ie. with <a>ta</a> and <a>ls</a>
--   values) <tt>LSystems</tt>.
renderLL, renderLO :: (LSystem, Double, Double) -> Int -> Double -> Path


-- | Various <a>LSystem</a>s. For <a>l0</a> through <a>lB</a> see
--   <a>http://paulbourke.net/fractals/lsys/</a>. For <a>lC</a> see
--   <a>http://en.wikipedia.org/wiki/Penrose_tiling</a>. For <a>lD</a> see
--   <a>http://hackage.haskell.org/package/nymphaea</a>.
module LSystem.Systems
l0, lB, lA, l9, l8, l7, l6, l5, l4, l3, l2, l1 :: LSystem
lC :: LSystem
lD :: LSystem
l0d, lDd, lCd, lBd, lAd, l9d, l8d, l7d, l6d, l5d, l4d, l3d, l2d, l1d :: (LSystem, Double, Double)
l0i, lDi, lCi, lBi, lAi, l9i, l8i, l7i, l6i, l5i, l4i, l3i, l2i, l1i :: Image

-- | Generate postscript file with drawings of <a>l0</a> through <a>lD</a>.
--   
--   <pre>
--   systems_ps "/tmp/hls.ps"
--   System.Process.system "gv /tmp/hls.ps"
--   </pre>
systems_ps :: FilePath -> IO ()