Haskell Language
Pipes
Ricerca…
Osservazioni
Come descrive la pagina di hackage :
pipe è una libreria di elaborazione del flusso pulita e potente che consente di creare e collegare componenti di streaming riutilizzabili
I programmi implementati attraverso lo streaming possono essere spesso succosi e componibili, con funzioni semplici e brevi che consentono di "inserire facilmente o meno" le funzionalità con il supporto del sistema di tipi Haskell.
await :: Monad m => Consumer' ama
Tira un valore da monte, dove a è il nostro tipo di input.
yield :: Monad m => a -> Producer' am ()
Produce un valore, dove a è il tipo di output.
Si consiglia vivamente di leggere il pacchetto Pipes.Tutorial integrato che offre un'eccellente panoramica dei concetti chiave di Pipes e di come interagiscono Producer , Consumer ed Effect .
I produttori
Un Producer è un'azione monadica che può yield valori per il consumo a valle:
type Producer b = Proxy X () () b
yield :: Monad m => a -> Producer a m ()
Per esempio:
naturals :: Monad m => Producer Int m ()
naturals = each [1..] -- each is a utility function exported by Pipes
Ovviamente possiamo anche avere Producer che sono funzioni anche di altri valori:
naturalsUntil :: Monad m => Int -> Producer Int m ()
naturalsUntil n = each [1..n]
I consumatori
Un Consumer può solo await valori da monte.
type Consumer a = Proxy () a () X
await :: Monad m => Consumer a m a
Per esempio:
fancyPrint :: MonadIO m => Consumer String m ()
fancyPrint = forever $ do
numStr <- await
liftIO $ putStrLn ("I received: " ++ numStr)
Pipes
I tubi possono sia await che yield .
type Pipe a b = Proxy () a () b
Questo pipe attende un Int e lo converte in una String :
intToStr :: Monad m => Pipe Int String m ()
intToStr = forever $ await >>= (yield . show)
Esecuzione di pipe con runEffect
Usiamo runEffect per eseguire il nostro Pipe :
main :: IO ()
main = do
runEffect $ naturalsUntil 10 >-> intToStr >-> fancyPrint
Nota che runEffect richiede un Effect , che è un Proxy autonomo senza input o output:
runEffect :: Monad m => Effect m r -> m r
type Effect = Proxy X () () X
(dove X è il tipo vuoto, noto anche come Void ).
Tubi di collegamento
Usa >-> per connettere Producer s, Consumer s e Pipe s per comporre più grandi funzioni Pipe .
printNaturals :: MonadIO m => Effect m ()
printNaturals = naturalsUntil 10 >-> intToStr >-> fancyPrint
Producer tipi Producer , Consumer , Pipe ed Effect sono tutti definiti in termini di tipo Proxy generale. Pertanto >-> può essere utilizzato per una varietà di scopi. I tipi definiti dall'argomento a sinistra devono corrispondere al tipo utilizzato dall'argomento giusto:
(>->) :: Monad m => Producer b m r -> Consumer b m r -> Effect m r
(>->) :: Monad m => Producer b m r -> Pipe b c m r -> Producer c m r
(>->) :: Monad m => Pipe a b m r -> Consumer b m r -> Consumer a m r
(>->) :: Monad m => Pipe a b m r -> Pipe b c m r -> Pipe a c m r
Il trasformatore di monade Proxy
Il tipo di dati di base di pipes è il trasformatore monade Proxy . Pipe , Producer , Consumer e così via sono definiti in termini di Proxy .
Poiché Proxy è un trasformatore monade definizioni di Pipe s assumono la forma di script monadici che await e yield valori, inoltre eseguendo effetti dalla base Monade m .
Combinazione di tubi e comunicazione di rete
Pipes supporta la semplice comunicazione binaria tra un client e un server
In questo esempio:
- un client si connette e invia un
FirstMessage - il server riceve e risponde a
DoSomething 0 - il cliente riceve e risponde
DoNothing - i passaggi 2 e 3 sono ripetuti indefinitamente
Il tipo di dati di comando scambiati sulla rete:
-- Command.hs
{-# LANGUAGE DeriveGeneric #-}
module Command where
import Data.Binary
import GHC.Generics (Generic)
data Command = FirstMessage
| DoNothing
| DoSomething Int
deriving (Show,Generic)
instance Binary Command
Qui, il server attende la connessione di un client:
module Server where
import Pipes
import qualified Pipes.Binary as PipesBinary
import qualified Pipes.Network.TCP as PNT
import qualified Command as C
import qualified Pipes.Parse as PP
import qualified Pipes.Prelude as PipesPrelude
pageSize :: Int
pageSize = 4096
-- pure handler, to be used with PipesPrelude.map
pureHandler :: C.Command -> C.Command
pureHandler c = c -- answers the same command that we have receveid
-- impure handler, to be used with PipesPremude.mapM
sideffectHandler :: MonadIO m => C.Command -> m C.Command
sideffectHandler c = do
liftIO $ putStrLn $ "received message = " ++ (show c)
return $ C.DoSomething 0
-- whatever incoming command `c` from the client, answer DoSomething 0
main :: IO ()
main = PNT.serve (PNT.Host "127.0.0.1") "23456" $
\(connectionSocket, remoteAddress) -> do
putStrLn $ "Remote connection from ip = " ++ (show remoteAddress)
_ <- runEffect $ do
let bytesReceiver = PNT.fromSocket connectionSocket pageSize
let commandDecoder = PP.parsed PipesBinary.decode bytesReceiver
commandDecoder >-> PipesPrelude.mapM sideffectHandler >-> for cat PipesBinary.encode >-> PNT.toSocket connectionSocket
-- if we want to use the pureHandler
--commandDecoder >-> PipesPrelude.map pureHandler >-> for cat PipesBinary.Encode >-> PNT.toSocket connectionSocket
return ()
Il client si connette così:
module Client where
import Pipes
import qualified Pipes.Binary as PipesBinary
import qualified Pipes.Network.TCP as PNT
import qualified Pipes.Prelude as PipesPrelude
import qualified Pipes.Parse as PP
import qualified Command as C
pageSize :: Int
pageSize = 4096
-- pure handler, to be used with PipesPrelude.amp
pureHandler :: C.Command -> C.Command
pureHandler c = c -- answer the same command received from the server
-- inpure handler, to be used with PipesPremude.mapM
sideffectHandler :: MonadIO m => C.Command -> m C.Command
sideffectHandler c = do
liftIO $ putStrLn $ "Received: " ++ (show c)
return C.DoNothing -- whatever is received from server, answer DoNothing
main :: IO ()
main = PNT.connect ("127.0.0.1") "23456" $
\(connectionSocket, remoteAddress) -> do
putStrLn $ "Connected to distant server ip = " ++ (show remoteAddress)
sendFirstMessage connectionSocket
_ <- runEffect $ do
let bytesReceiver = PNT.fromSocket connectionSocket pageSize
let commandDecoder = PP.parsed PipesBinary.decode bytesReceiver
commandDecoder >-> PipesPrelude.mapM sideffectHandler >-> for cat PipesBinary.encode >-> PNT.toSocket connectionSocket
return ()
sendFirstMessage :: PNT.Socket -> IO ()
sendFirstMessage s = do
_ <- runEffect $ do
let encodedProducer = PipesBinary.encode C.FirstMessage
encodedProducer >-> PNT.toSocket s
return ()
