Hoogle Search

Within LTS Haskell 24.66 (ghc-9.10.3)

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

Exact lookup

1. mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b

   can-i-haz	Control.Monad.Except.CoHas

   Map the unwrapped computation using the given function.

   • runExcept (mapExcept f m) = f (runExcept
     m)

2. mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b

   can-i-haz	Control.Monad.Except.CoHas

   Map the unwrapped computation using the given function.

   • runExceptT (mapExceptT f m) = f
     (runExceptT m)

3. mapReader :: (a -> b) -> Reader r a -> Reader r b

   can-i-haz	Control.Monad.Reader.Has

   Transform the value returned by a Reader.

   • runReader (mapReader f m) = f .
     runReader m

4. mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b

   can-i-haz	Control.Monad.Reader.Has

   Transform the computation inside a ReaderT.

   • runReaderT (mapReaderT f m) = f .
     runReaderT m

5. mapMaybeVarEnv :: (a -> Maybe b) -> VarEnv a -> VarEnv b

   clash-lib	Clash.Core.VarEnv

   Apply a function to every element in the environment; values for which the function returns Nothing are removed from the environment

6. mapVarEnv :: (a -> b) -> VarEnv a -> VarEnv b

   clash-lib	Clash.Core.VarEnv

   Apply a function to every element in the environment

7. mapMaybe :: (a -> Maybe b) -> UniqMap a -> UniqMap b

   clash-lib	Clash.Data.UniqMap

   Apply a function to all elements in the map, keeping those where the result is not Nothing.

8. map' :: Expr -> Expr -> Expr

   code-conjure	Conjure.Engine

   map lifted over Exprs.

   > map' absE (unit one)
   map abs [1] :: [Int]
   

9. mapConsts :: (Expr -> Expr) -> Expr -> Expr

   code-conjure	Conjure.Engine

   O(n*m). Applies a function to all terminal constants in an expression. Given that:

   > let one   = val (1 :: Int)
   > let two   = val (2 :: Int)
   > let xx -+- yy = value "+" ((+) :: Int->Int->Int) :$ xx :$ yy
   > let intToZero e = if typ e == typ zero then zero else e
   

   Then:

   > one -+- (two -+- xx)
   1 + (2 + x) :: Int
   

   > mapConsts intToZero (one -+- (two -+- xx))
   0 + (0 + x) :: Integer
   

   Given that the argument function is O(m), this function is O(n*m).

10. mapE :: Expr

    code-conjure	Conjure.Engine

    map over the Int element type encoded as an Expr

    > mapE
    map :: (Int -> Int) -> [Int] -> [Int]
    

Page 282 of many | Previous | Next