Hoogle Search

Within LTS Haskell 22.20 (ghc-9.6.4)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. forever :: Applicative f => f a -> f b

   massiv-test	Test.Massiv.Utils

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

2. forever :: Applicative f => f a -> f b

   base-prelude	BasePrelude

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

3. forever :: Applicative f => f a -> f b

   rebase	Rebase.Prelude

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

4. forever :: Applicative f => f a -> f b

   LambdaHack	Game.LambdaHack.Core.Prelude

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

5. forever :: Applicative f => f a -> f b

   hledger	Hledger.Cli.Script

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

6. forever :: Applicative f => f a -> f b

   ihaskell	IHaskellPrelude

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

7. forever :: Applicative f => f a -> f b

   incipit-base	Incipit.Base

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

8. forever :: Applicative f => f a -> f b

   classy-prelude-yesod	ClassyPrelude.Yesod

   Repeat an action indefinitely.

   Examples

   A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

   echoServer :: Socket -> IO ()
   echoServer socket = forever $ do
   client <- accept socket
   forkFinally (echo client) (\_ -> hClose client)
   where
   echo :: Handle -> IO ()
   echo client = forever $
   hGetLine client >>= hPutStrLn client
   

   Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

9. forever :: Dsl k r a => k r a -> r

   control-dsl	Control.Dsl

   No documentation available.

10. forever :: Applicative f => f a -> f b

    control-monad-free	Control.Monad.Free

    Repeat an action indefinitely.

    Examples

    A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan). For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

    echoServer :: Socket -> IO ()
    echoServer socket = forever $ do
    client <- accept socket
    forkFinally (echo client) (\_ -> hClose client)
    where
    echo :: Handle -> IO ()
    echo client = forever $
    hGetLine client >>= hPutStrLn client
    

    Note that "forever" isn't necessarily non-terminating. If the action is in a MonadPlus and short-circuits after some number of iterations. then forever actually returns mzero, effectively short-circuiting its caller.

Page 2 of many | Previous | Next