Durante il ciclo in Haskell con una condizione

Question

Sto avendo una piccola situazione Haskell qui. Sto cercando di scrivere due funzioni con le monadi. Prima si suppone di iterare attraverso una funzione fintanto che la condizione è vera per l'input/output della funzione. Il secondo dovrebbe usare il primo per prendere un numero come input e scriverlo come output finché non si entra in uno spazio.

Sono bloccato con questo, qualsiasi aiuto?

module Test where 

while :: (a -> Bool) -> (a -> IO a) -> a -> IO a 
while praed funktion x = do 
         f <- praed (funktion x) 
         if f == True then do 
              y <- funktion x 
              while praed funktion y 
         else return x 



power2 :: IO() 
power2 = do putStr (Please enter a number.") 
      i <- getChar 
      while praed funktion 
      where praed x = if x /= ' ' then False else True 
        funktion = i 

Answer 1

import Control.Monad 

while :: (a -> Bool) -> (a -> IO a) -> a -> IO a 
while praed funktion x 
    | praed x = do 
     y <- funktion x 
     while praed funktion y 
    | otherwise = return x 


power2 :: IO() 
power2 = do 
    putStr "Please enter a number." 
    i <- getChar 
    let praed x = x /= ' ' 
    let f x = do 
     putChar x 
     getChar 
    while praed f '?' 
    return() 

Alcune note:

• utilizzando if x then True else False è ridondante, è pari a poco x.
• Analogamente if x == True ... è ridondante ed equivalente a if x ....

• È necessario distinguere tra le azioni IO ei relativi risultati. Per esempio, se yo fare

  do 
      i <- getChar 
      ... 
  

  poi nel ... i rappresenta il risultato dell'azione, un personaggio, così i :: Char. Ma getChar :: IO Char è l'azione stessa. È possibile visualizzarlo come una ricetta che restituisce Char quando viene eseguita. Puoi passare la ricetta alle funzioni ecc., E viene eseguita solo se eseguita da qualche parte.

• Il tuo while chiamato funktion due volte, che probabilmente non è quello che intendi: leggerebbe un carattere due volte, controlla il primo e restituisce il secondo. Ricorda, il tuo funktion è un'azione, quindi ogni volta che "invochi" l'azione (ad esempio utilizzando <- funktion ... nella notazione do), l'azione viene eseguita nuovamente. Così dovrebbe invece essere qualcosa come

  do 
      y <- funktion x 
      f <- praed y 
      -- ... 
  

  (il mio codice è un po 'diversa, controlla l'argomento che viene passato a esso.)

Answer 2

Per una versione pura:

{-# LANGUAGE BangPatterns #-} 

while :: (a -> Bool) -> (a -> a) -> a -> a 
while p f = go where go !x = if p x then go (f x) else x 

test1 :: Int 
test1 = while (< 1000) (* 2) 2 
-- test1 => 1024 

per monadico:

import Control.Monad 

whileM :: (Monad m, MonadPlus f) => (a -> m Bool) -> m a -> m (f a) 
whileM p f = go where 
    go = do 
    x <- f 
    r <- p x 
    if r then (return x `mplus`) `liftM` go else return mzero 

test2 :: IO [String] 
test2 = whileM (return . (/= "quit")) getLine 
-- *Main> test2 
-- quit 
-- [] 
-- *Main> test2 
-- 1 
-- 2 
-- 3 
-- quit 
-- ["1","2","3"] 

power2 :: IO (Maybe Char) 
power2 = whileM (return . (/= 'q')) getChar 
-- *Main> power2 
-- q 
-- Nothing 
-- *Main> power2 
-- 1 
-- 2 
-- 3 
-- q 
-- Just '\n' 

vedere al so:

http://hackage.haskell.org/package/monad-loops, http://hackage.haskell.org/package/loop-while, http://hackage.haskell.org/package/control-monad-loop.

http://www.haskellforall.com/2012/01/haskell-for-c-programmers-for-loops.html