Falls ihrs noch nicht mitbekommen hat: es gibt einen Konkurrenz zur poignant guide in Haskell.

http://learnyouahaskell.com/

Die Zeichnungen sind zwar nicht ganz so gut, der Text aber recht ansehlich. Zumindest, was ich in den ersten beiden Kapiteln so rauslesen konnte.

Gruß,
Skade

Ich warte schon lange auf ein Update, in der Hoffnung endlich die Monaden richtig zu verstehen.

Ich habe noch einmal das Tutorial "Yet another Haskell Tutorial" von Hal Daum´e angelesen, komme bei dem Monaden-Kapitel aber einfach nicht weiter.

Ich glaube so halbwegs verstanden zu haben, wie Monaden funktionieren. Aber in der Praxis ist das einfach noch zu komplex.

Derzeit versuche ich das Beispiel mit dem NumberTree hinzukriegen. Leider funktioniert es nicht. Ist das Buch ggf. fehlerhaft, oder hab ich doch einen Fehler in meinen Code?

Idee hinter dem Algorithmus: NumberTree soll alle Blätter des Baumes durchnummerieren.

module Bla where
data Tree a = Leaf a | Branch (Tree a) (Tree a) deriving (Show, Eq)

newtype State st a = State (st -> (st, a))

instance Monad (State q) where
return a = State (\s -> (s, a))
(State run) >>= action = State update where
update stb =
let
(sta, a) = run stb
State up = action a
in
up stb

getState :: State s s
getState = State (\st -> (st, st))

putState :: s -> State s ()
putState new = State (\_ -> (new, ()))

mapTree :: (a -> b) -> (Tree a) -> (Tree b)
mapTree f (Leaf x) = Leaf (f x)
mapTree f (Branch l r) = Branch (mapTree f l) (mapTree f r)

mapTreeM :: Monad m => (a -> m b) -> Tree a -> (m (Tree b))
mapTreeM f (Leaf x) = do
b <- f x
return (Leaf b)
mapTreeM f (Branch l r) = do
ll <- mapTreeM f l
rr <- mapTreeM f r
return (Branch ll rr)

numberTree :: Tree a -> State Int (Tree (a, Int))
numberTree t = mapTreeM number t where
number v = do
current <- getState
putState (current + 1) --
return (v, current)

runStateM :: State s a -> s -> a
runStateM (State f) st = snd (f st)



exampleTree =
Branch
(
Branch
(Leaf 'a')
(Leaf 'b')
)
(
Branch
(Leaf 'c')
(
Branch
(Leaf 'd')
(Leaf 'e')
)
)



Konsole:
*Bla> runStateM (numberTree exampleTree) 1
Branch (Branch (Leaf ('a',1)) (Leaf ('b',1))) (Branch (Leaf ('c',1)) (Branch (Leaf ('d',1)) (Leaf ('e',1))))
Die Blätter sollten eigentlich durchnummeriert sein, stattdessen haben sie alle die gleiche Nummer.

Hat jemand das selbe Tutorial mal durchgearbeitet und ist dabei auf dieselbe Problematik gestoßen?

Wenn es hier schon um Haskell geht, dann sollte "Real World Haskell" nicht fehlen.

_________________
Schlagt mich nicht! Ich bin Anfänger!

@Kai: Ich bin wohl ein bißchen spät, aber der Fehler ist in Zeile 14. Statt "up stb" sollte da "up sta" stehen. Lustigerweise steht stb für den alten, sta für den neueren Zustand - kein Wunder, wenn man sich da verzettelt :)

Für deutschsprachige Diskussionen über Haskell empfehle ich übrigens #haskell.de auf Freenode. (In der Hoffnung, daß da mal mehr als zwei Leute online sind, und einer von ihnen auch mal ne Frage hat, die von den anderen beantwortet werden kann.)