L-systems in Haskell

l-systems.lhs

L-systems in Haskell.
===

> import Data.List.Split (splitOn)
> import Data.List
> 
> type Rules = [(Char, String)]
> 
> -- compute the next generation
> next :: Rules -> String -> String
> next rules [] = []
> next rules (x:xs) = 
>   case lookup x rules of
>     Nothing -> [x] ++ (next rules xs)
>     Just y  -> y ++ next rules xs
> 
> -- another version of next
> next2 :: Rules -> String -> String
> next2 rules xs = concatMap go xs
>   where go x = case lookup x rules of
>                  Nothing -> [x]
>                  Just y  -> y

simplify
===

In this case function `splitOn` and `intercalate` are inverses of each
other. `splitOn` splits a list at the specified delimiter character,
and `intercalate` joins a list of Strings together with a chosen separator
string.

> simplify :: String -> String
> simplify xs = intercalate "F" (map go (splitOn "F" xs))
>   where go xs = let count = mod (foldl accumulate 0 xs) 4
>                     accumulate s '+' = s+1
>                     accumulate s '-' = s-1
>                     accumulate s _   = s
>                     result | count == 0  = ""
>                            | count == 1  = "+"
>                            | count == 3  = "-"
>                            | count == 2  = "++"  -- or "--"
>                 in result
> 
> lsystem = [ ('X', "X+YF+"), ('Y', "-FX-Y") ]
> 
> test1 = take 4 $ iterate (next lsystem) "FX"
> -- test1 returns: ["FX","FX+YF+","FX+YF++-FX-YF+","FX+YF++-FX-YF++-FX+YF+--FX-YF+"]
> 
> test2 = map simplify test1
> -- test2 returns: ["F","F+F+","F+F+F-F+","F+F+F-F+F+F-F-F+"]