Anwendung: arithmetische Ausdrücke

module Arithmetik_Type 

( module Arithmetik_Type
, module Rose
, zeige
)

where

import Rose
import Bild
import Form

data Op = Plus | Minus | Mal | Durch 
     deriving (Eq, Ord, Show)

data Contents = Operator Op
	      | Constant Integer
     deriving (Eq, Ord, Show)

type Term = Rose Contents

instance Form Op       where form = form . show
instance Form Contents where form = form . show


module Arithmetik_Parser where

import Arithmetik_Type

import Parser_Type
import Parser_Basic
import Parser_Combinators


pm :: Parser Op
pm =      fmap ( const Plus  ) ( operator "+" )
   `plus` fmap ( const Minus ) ( operator "-" )

md :: Parser Op
md =      fmap ( const Mal   ) ( operator "*" )
   `plus` fmap ( const Durch ) ( operator "/" )

falte :: Parser Op -> Parser Term -> Parser Term
falte sep p = do 
    x0 <- p
    sys <- many $ do s <- sep; y <- p; return (s, y)
    return $ foldl ( \ x (s, y) -> Node { key = Operator s
					, children = [ x, y ] } )
		   x0 sys

term :: Parser Term
term = summe

summe :: Parser Term
summe = falte pm produkt

produkt :: Parser Term
produkt = falte md atom

atom :: Parser Term
atom =    do n <- natural
	     return $ Node { key = Constant n, children = [] }
   `plus` paren term