Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

Exact lookup

1. listVarsWith :: [Expr] -> Expr -> [Expr]

   express	Data.Express

   O(n+m). Like lookupNames but returns a list of variables encoded as Exprs.

2. listVars :: Typeable a => String -> a -> [Expr]

   express	Data.Express.Hole

   Generate an infinite list of variables based on a template and a given type. (cf. listVarsAsTypeOf)

   > putL 10 $ listVars "x" (undefined :: Int)
   [ x :: Int
   , y :: Int
   , z :: Int
   , x' :: Int
   , y' :: Int
   , z' :: Int
   , x'' :: Int
   , ...
   ]
   

   > putL 10 $ listVars "p" (undefined :: Bool)
   [ p :: Bool
   , q :: Bool
   , r :: Bool
   , p' :: Bool
   , q' :: Bool
   , r' :: Bool
   , p'' :: Bool
   , ...
   ]
   

3. listVarsAsTypeOf :: String -> Expr -> [Expr]

   express	Data.Express.Hole

   Generate an infinite list of variables based on a template and the type of a given Expr. (cf. listVars)

   > let one = val (1::Int)
   > putL 10 $ "x" `listVarsAsTypeOf` one
   [ x :: Int
   , y :: Int
   , z :: Int
   , x' :: Int
   , ...
   ]
   

   > let false = val False
   > putL 10 $ "p" `listVarsAsTypeOf` false
   [ p :: Bool
   , q :: Bool
   , r :: Bool
   , p' :: Bool
   , ...
   ]
   

4. listVarsWith :: [Expr] -> Expr -> [Expr]

   express	Data.Express.Instances

   O(n+m). Like lookupNames but returns a list of variables encoded as Exprs.

5. listToExpr :: ToExpr a => [a] -> Expr

   tree-diff	Data.TreeDiff.Class

   No documentation available.

6. listToAutomatonExcept :: forall (m :: Type -> Type) b a . Monad m => [b] -> AutomatonExcept a b m ()

   automaton	Data.Automaton.Trans.Except

   Converts a list to an AutomatonExcept, which outputs an element of the list at each step, throwing () when the list ends.

7. listToMaybeS :: forall (m :: Type -> Type) b a . (Functor m, Monad m) => [b] -> Automaton (MaybeT m) a b

   automaton	Data.Automaton.Trans.Maybe

   Converts a list to an Automaton in MaybeT, which outputs an element of the list at each step, throwing Nothing when the list ends.

8. listen :: forall (m :: Type -> Type) r w s a . Monad m => RWST r w s m a -> RWST r w s m (a, w)

   automaton	Data.Automaton.Trans.RWS

   listen m is an action that executes the action m and adds its output to the value of the computation.

   • runRWST (listen m) r s = liftM (\ (a, w)
     -> ((a, w), w)) (runRWST m r s)

9. listens :: forall (m :: Type -> Type) w b r s a . Monad m => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b)

   automaton	Data.Automaton.Trans.RWS

   listens f m is an action that executes the action m and adds the result of applying f to the output to the value of the computation.

   • listens f m = liftM (id *** f) (listen
     m)

   • runRWST (listens f m) r s = liftM (\ (a,
     w) -> ((a, f w), w)) (runRWST m r s)

10. listen :: forall (m :: Type -> Type) w a . Monad m => WriterT w m a -> WriterT w m (a, w)

    automaton	Data.Automaton.Trans.Writer

    listen m is an action that executes the action m and adds its output to the value of the computation.

    • runWriterT (listen m) = liftM (\ (a, w)
      -> ((a, w), w)) (runWriterT m)

Page 24 of many | Previous | Next