Links und Funktionen
Sprachumschaltung

Navigationspfad


Inhaltsbereich

Code 13

Lösung der Programmierübung "nacheinander" mit dem expliziten Welten-Threading-Typ

Haskell source code icon Vorlesung13_2.hs — Haskell source code, 1 KB (1269 bytes)

Dateiinhalt

{-# LANGUAGE RankNTypes, ImpredicativeTypes #-}

-- type Welt = ()              -- Wichtig dabei: Nicht schummeln und Welt = () ausnutzen!
type Welt = forall a . a       -- dieser Typ für Welt erschwert schummeln
type MyIO a = Welt -> (a,Welt)

-- 1) Als erstes haben wir die Typabkürzung ausgefaltet, von:
-- nacheinander :: MyIO a -> MyIO b -> MyIO b
-- zu:
nacheinander :: (Welt -> (a,Welt)) -> (Welt -> (b, Welt))
                                   ->  Welt -> (b, Welt)
                                   
-- Mit dem expandierten Typ ist eigentlich alles klar:
-- Wir bekommen zwei Actions, welche nur auf eine Welt warten,
-- um loslegen zu können.
-- Jetzt müssen wir nur noch Paare auseinandernehmen.
nacheinander act1 act2 welt = 
  let (_erg1,welt')  = act1 welt
      (erg2,welt'') = act2 welt'
  in (erg2,welt'')    
  
-- _erg1 interessiert hier nicht, weshalb wir das ganz auch etwas abkürzen können.
-- Pointfree geschrieben hätten wir die äquivalente Definition:
nacheinander' ::  MyIO a -> MyIO b -> MyIO b
nacheinander' act1 act2 = act2 . snd . act1 
  
act1 :: MyIO Int  
act1 w = (7,w)

act2 :: MyIO Int  
act2 w = (9,w)

act3 :: MyIO Int  
act3 w = (5,w)


-- TEST:
-- > fst $ (act1 `nacheinander` act2 `nacheinander` act3) undefined
-- 5

Artikelaktionen

abgelegt unter:

Funktionsleiste