fa9a605 · typeable/wai

151 lift f = SinkM (lift (liftM SinkNoData f))

152

153sinkJoin :: MonadBase IO m => SinkM a m (SinkM a m b) -> SinkM a m b

154−sinkJoin = error "sinkJoin"

154+sinkJoin (SinkM msink) = SinkM $ do

155−{-

155+ sink <- msink

156−sinkJoin (Sink msinkI) = Sink $ do

157− sinkI <- msinkI

158− case sinkI of

156+ case sink of

159− SinkNoData (Sink inner) -> inner

157+ SinkNoData (SinkM inner) -> inner

160− SinkData msink -> do

158+ SinkData pushO closeO -> do

161 istate <- liftBase $ I.newIORef Nothing

159 istate <- liftBase $ I.newIORef Nothing

162− return $ SinkData $ go istate msink

160+ return $ SinkData (push istate pushO) (close istate closeO)

163 where

161 where

164− go :: MonadBaseControl IO m

165− => I.IORef (Maybe (SinkInsideData a m b))

166− -> (Stream a -> ResourceT m (SinkResult a (Sink a m b)))

167− -> SinkInsideData a m b

168− go istate outer stream = do

162+ push istate pushO stream = do

169 state <- liftBase $ I.readIORef istate

163 state <- liftBase $ I.readIORef istate

170 case state of

164 case state of

165+ Just (pushI, _) -> pushI stream

171 Nothing -> do

166 Nothing -> do

172− SinkResult leftover minner' <- outer stream

167+ SinkResult leftover minner' <- pushO stream

173 case minner' of

168 case minner' of

169+ Nothing -> return $ SinkResult leftover Nothing

174− Just (Sink msink) -> do

170+ Just (SinkM msink') -> do

175− sink <- msink

171+ sink <- msink'

176 case sink of

172 case sink of

177− SinkData inner -> do

173+ SinkData pushI closeI -> do

178− liftBase $ I.writeIORef istate $ Just inner

174+ liftBase $ I.writeIORef istate $ Just (pushI, closeI)

179 if null leftover

175 if null leftover

180 then return $ SinkResult [] Nothing

176 then return $ SinkResult [] Nothing

181− else go istate outer $ Chunks leftover

177+ else push istate pushO leftover

182 SinkNoData x -> return $ SinkResult leftover $ Just x

178 SinkNoData x -> return $ SinkResult leftover $ Just x

179+ close istate closeO = do

180+ state <- liftBase $ I.readIORef istate

181+ case state of

182+ Just (_, closeI) -> closeI

183+ Nothing -> do

184+ SinkResult leftover (SinkM minner) <- closeO

185+ inner <- minner

186+ case inner of

187+ SinkData pushI closeI -> closeHelper' leftover pushI closeI

183− Nothing -> return $ SinkResult leftover Nothing

188+ SinkNoData x -> return $ SinkResult leftover x

184− Just inner -> inner stream

189+ closeHelper' stream pushI closeI

185− -}

190+ | null stream = closeI

191+ | otherwise = do

192+ SinkResult leftover mres <- pushI stream

193+ case mres of

194+ Nothing -> closeHelper' leftover pushI closeI

195+ Just res -> return $ SinkResult leftover res