Jaki jest preferowany sposób łączenia dwóch zlewów?

Question

Do tej pory użyłem zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r'), ale jest uważane za przestarzałe.

Answer 1

((Pakiet jest conduit-0.5.2.3. Cały module jest tylko dla wstecznej kompatybilności.))

---

[edit]

Więc moje proste monadycznego przypuszczenie (patrz niżej) wydaje się być zła, mimo że typy są poprawne. Teraz mogę tylko zgadywać, że odpowiedź brzmi:

Funkcje wymiany są nadal w fazie rozwoju, podobnie jak wszystkie rury i kanały kablowe oraz podobne koncepcje i biblioteki.

Będę czekać na następny interfejs API, aby rozwiązać to pytanie i nadal używać do tego czasu zipSink. (może to była tylko niesłuszna.)

[/edit]

nie jestem, że znają z tego pakietu, ale nie byłoby zrobić tak samo jak ten?

zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r') 
zipSinks s1 s2 = (,) <$> s1 <*> s2 

W końcu jest to Monad. (Functor, Applicative)

zipSinks :: Monad sink => sink r -> sink r' -> sink (r, r') 
zipSinks s1 s2 = liftM2 (,) s1 s2 

Answer 2

Edit

Po uwzględnieniu tego, ja nie sądzę, że jest to możliwe przy obecnej wersji Data.Conduit. Rury nie są kategoriami, więc &&& jest wykluczone. I nie ma sposobu, abym mógł wymyślić, by wyciągnąć wyniki z prądu, podawać je stopniowo do obu zlewów i zwierać, gdy kończy się pierwszy zlew. (Chociaż nie sądzę, że zwarcie w ten sposób działa, wydaje się, że byłoby to bardzo pożądane.) Z wyjątkiem oczywiście dopasowania do wzorca na obu zlewach (jak w pakiecie ma zipSinks), ale to właśnie jesteśmy próbując tego uniknąć.

To powiedziawszy, chciałbym kochać, aby udowodnić, że jest źle tutaj.

To nie jest ładne, ale możesz to zrobić w sposób oczywisty.

Pierwsze import:

module Main where 

import Control.Monad.Trans 
import Data.Conduit 
import qualified Data.Conduit.Binary as CB 
import qualified Data.Conduit.List as CL 
import qualified Data.Conduit.Text as CT 
import qualified Data.Conduit.Util as CU 
import Data.Maybe 
import Data.Text (unpack) 

Teraz zipSinks. Zasadniczo chcesz utworzyć zlew, który pobiera dane wejściowe z kanału i przesyła je osobno do każdego zlewu podrzędnego. W tym przypadku użyłem do tego celu CL.sourceList. Jeśli await zwraca Nothing, maybeToList zwraca pustą listę, więc pochłaniacze podrzędne są również uruchamiane bez wprowadzania danych. Na koniec wynik każdego zlewu podrzędnego jest podawany do krotki.

zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r') 
zipSinks s1 s2 = do 
    l <- fmap maybeToList await 
    o1 <- lift $ CL.sourceList l $$ s1 
    o2 <- lift $ CL.sourceList l $$ s2 
    return (o1, o2) 

Oto kilka przykładów użycia zipSinks. Wygląda na to, że działa dobrze zarówno wewnątrz modelu IO, jak i poza nim, a w kilku testach, które zrobiłem, wyjście dopasowuje wyjście zipped', utworzone przy użyciu starego zipSinks.

doubleHead :: Monad m => Sink Int m (Maybe Int) 
doubleHead = await >>= return . fmap (2*) 

-- old version 
zipped' :: Monad m => Sink Int m (Maybe Int, Maybe Int) 
zipped' = CU.zipSinks CL.head doubleHead 

-- new version 
zipped :: Monad m => Sink Int m (Maybe Int, Maybe Int) 
zipped = zipSinks CL.head doubleHead 

fromList = CL.sourceList [7, 8, 9] $$ zipped 
-- (Just 7, Just 14) 

fromFile :: String -> IO (Maybe Int, Maybe Int) 
fromFile filename = runResourceT $ 
     CB.sourceFile filename 
    $= CB.lines 
    $= CT.decode CT.utf8 
    $= CL.map (read . unpack) 
    $$ zipped 

-- for a file with the lines: 
-- 
-- 1 
-- 2 
-- 3 
-- 
-- returns (Just 1, Just 2)