Hoogle Search

Within LTS Haskell 24.40 (ghc-9.10.3)

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

Exact lookup

1. Plain :: [Inline] -> Block

   pandoc-types	Text.Pandoc.Definition

   Plain text, not a paragraph

2. Parens :: !CommaSeparated [Expr] -> Expr

   pretty-simple	Text.Pretty.Simple.Internal.Expr

   No documentation available.

3. module Text.Pretty.Simple.Internal.Printer

   No documentation available.

4. Partial :: (Maybe ByteString -> ST s (IDecode s a)) -> IDecode s a

   serialise	Codec.Serialise

   The decoder has consumed the available input and needs more to continue. Provide Just if more input is available and Nothing otherwise, and you will get a new IDecode.

5. PeekAvailable :: (Int# -> ST s (DecodeAction s a)) -> DecodeAction s a

   serialise	Codec.Serialise.Decoding

   No documentation available.

6. PeekByteOffset :: (Int# -> ST s (DecodeAction s a)) -> DecodeAction s a

   serialise	Codec.Serialise.Decoding

   No documentation available.

7. PeekTokenType :: (TokenType -> ST s (DecodeAction s a)) -> DecodeAction s a

   serialise	Codec.Serialise.Decoding

   No documentation available.

8. module Codec.Serialise.Properties

   This module contains a set of generally useful properties, which instance authors are encouraged to use in order to test their instances of the Serialise class. For example, if you have a data type which you might derive or write instances for:

   data Foo = Foo { fooInt :: Int, fooBool :: Bool }
   deriving (Eq, Show, Generic)
   -- or, alternatively
   instance Serialise Foo where
   encode = ...
   decode = ...
   

   Then you can use this module to easily derive some quick properties:

   import qualified Codec.Serialise.Properties as Props
   
   fooSerialiseId :: Foo -> Bool
   fooSerialiseId = Props.serialiseIdentity
   
   fooFlatTermId :: Foo -> Bool
   fooFlatTermId = Props.flatTermIdentity
   
   fooHasValidFlatTerm :: Foo -> Bool
   fooHasValidFlatTerm = Props.hasValidFlatTerm
   

   You can then conveniently use these three functions with QuickCheck, for example.

9. module Streaming.Prelude

   The names exported by this module are closely modeled on those in Prelude and Data.List, but also on Pipes.Prelude, Pipes.Group and Pipes.Parse. The module may be said to give independent expression to the conception of Producer / Source / Generator manipulation articulated in the latter two modules. Because we dispense with piping and conduiting, the distinction between all of these modules collapses. Some things are lost but much is gained: on the one hand, everything comes much closer to ordinary beginning Haskell programming and, on the other, acquires the plasticity of programming directly with a general free monad type. The leading type, Stream (Of a) m r is chosen to permit an api that is as close as possible to that of Data.List and the Prelude. Import qualified thus:

   import Streaming
   import qualified Streaming.Prelude as S
   

   For the examples below, one sometimes needs

   import Streaming.Prelude (each, yield, next, mapped, stdoutLn, stdinLn)
   import Data.Function ((&))
   

   Other libraries that come up in passing are

   import qualified Control.Foldl as L -- cabal install foldl
   import qualified Pipes as P
   import qualified Pipes.Prelude as P
   import qualified System.IO as IO
   

   Here are some correspondences between the types employed here and elsewhere:

   streaming             |            pipes               |       conduit       |  io-streams
   -------------------------------------------------------------------------------------------------------------------
   Stream (Of a) m ()                  | Producer a m ()                | Source m a          | InputStream a
   | ListT m a                      | ConduitM () o m ()  | Generator r ()
   -------------------------------------------------------------------------------------------------------------------
   Stream (Of a) m r                   | Producer a m r                 | ConduitM () o m r   | Generator a r
   -------------------------------------------------------------------------------------------------------------------
   Stream (Of a) m (Stream (Of a) m r) | Producer a m (Producer a m r)  |
   --------------------------------------------------------------------------------------------------------------------
   Stream (Stream (Of a) m) r          | FreeT (Producer a m) m r       |
   --------------------------------------------------------------------------------------------------------------------
   --------------------------------------------------------------------------------------------------------------------
   ByteString m ()                     | Producer ByteString m ()       | Source m ByteString  | InputStream ByteString
   --------------------------------------------------------------------------------------------------------------------
   

10. data Piece

    wai-app-static	WaiAppStatic.Types

    An individual component of a path, or of a filepath. This is the core type used by wai-app-static for doing lookups. It provides a smart constructor to avoid the possibility of constructing unsafe path segments (though unsafeToPiece can get around that as necessary). Individual file lookup backends must know how to convert from a Piece to their storage system.

Page 341 of many | Previous | Next