newtype StateTransformer s a = ST (s -> (a, s)) 
      
--    s    Zustand 
--    a    Ausgabewert

apply :: StateTransformer s a -> s -> (a, s)
apply (ST f) x = f x

instance Monad (StateTransformer s) where 
  return x =  ST $ \s -> (x, s)
  a1 >>= aa2  =  ST action
         where
            action  = \s -> let (res, s') = apply a1 s
                             in apply (aa2 res) s'
                              
                                
--- Operationen auf dem Zustand:   
incr = ST $ \s -> ((), s+1)
decr = ST $ \s -> ((), s-1)
hole = ST $ \s -> (s, s)
add n = ST $ \s -> ((), s +n)
sub n = ST $ \s -> ((), s - n)
mult n = ST $ \s -> ((), s * n)
divide (n) = ST $ \s -> ((), s `div` n)
clear = ST $ \_ -> ((), 0)
check p = ST $ \s -> (p s, s)

anfang =  ST (\ein -> ((),ein))
 
test  =  (anfang   >> incr >> incr >> add 3 >> hole) 

zeigetest =  (apply test 4444)

test2 = anfang >>  incr >> add 3 >> sub 5  

zeigetest2 =  (apply test2 3333)


----
 

repeatN :: (Monad m, Num a) => a -> m b -> m ()
 
repeatN 0 a = return ()
repeatN n a = a >> repeatN (n-1) a

test3 = anfang >>  incr >> (repeatN 5 (add 3)) >> sub 5  
zeigetest3 =  (apply test3 6666)

for :: Monad m => [a] -> (a -> m c) -> m ()
for []      fa = return ()
for (n:ns)  fa = fa n >> for ns fa 

testprintZahlen = for [1..10] print

forever :: Monad m => m a -> m b
forever a = a >> forever a


while :: Monad m => m Bool -> m a -> m ()
while check a = do {
             b <- check;
             if b then a >> while check a
             else return ()
             }
             
test4 = anfang >>   (add 10)  >> while (check (\x -> x > 0)) decr
zeigetest4 =  (apply test4 7777)    
bot = bot