Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

Exact lookup

1. mapAccumR :: forall acc x y (n :: Nat) . (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

   clash-prelude	Clash.Prelude

   The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

   >>> mapAccumR (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
   (10,10 :> 8 :> 5 :> 1 :> Nil)
   

   "mapAccumR f acc xs" corresponds to the following circuit layout:

2. mapAccumL :: forall acc x y (n :: Nat) . (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

   clash-prelude	Clash.Prelude.Safe

   The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new vector.

   >>> mapAccumL (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
   (10,1 :> 2 :> 4 :> 7 :> Nil)
   

   "mapAccumL f acc xs" corresponds to the following circuit layout:

3. mapAccumR :: forall acc x y (n :: Nat) . (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

   clash-prelude	Clash.Prelude.Safe

   The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

   >>> mapAccumR (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
   (10,10 :> 8 :> 5 :> 1 :> Nil)
   

   "mapAccumR f acc xs" corresponds to the following circuit layout:

4. mapFemtoseconds :: (Int64 -> Int64) -> Femtoseconds -> Femtoseconds

   clash-prelude	Clash.Signal.Internal

   Map Int64 fields in Femtoseconds

5. mapSignal# :: forall a b (dom :: Domain) . (a -> b) -> Signal dom a -> Signal dom b

   clash-prelude	Clash.Signal.Internal

   No documentation available.

6. mapAccumL :: forall acc x y (n :: Nat) . (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

   clash-prelude	Clash.Sized.Vector

   The mapAccumL function behaves like a combination of map and foldl; it applies a function to each element of a vector, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new vector.

   >>> mapAccumL (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
   (10,1 :> 2 :> 4 :> 7 :> Nil)
   

   "mapAccumL f acc xs" corresponds to the following circuit layout:

7. mapAccumR :: forall acc x y (n :: Nat) . (acc -> x -> (acc, y)) -> acc -> Vec n x -> (acc, Vec n y)

   clash-prelude	Clash.Sized.Vector

   The mapAccumR function behaves like a combination of map and foldr; it applies a function to each element of a vector, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new vector.

   >>> mapAccumR (\acc x -> (acc + x,acc + 1)) 0 (1 :> 2 :> 3 :> 4 :> Nil)
   (10,10 :> 8 :> 5 :> 1 :> Nil)
   

   "mapAccumR f acc xs" corresponds to the following circuit layout:

8. mapAccumS :: forall (m :: Type -> Type) a s b . Monad m => (a -> s -> ConduitT b Void m s) -> s -> ConduitT () b m () -> ConduitT a Void m s

   classy-prelude-conduit	ClassyPrelude.Conduit

   Consume a source with a strict accumulator, in a way piecewise defined by a controlling stream. The latter will be evaluated until it terminates.

   >>> let f a s = liftM (:s) $ mapC (*a) =$ CL.take a
   
   >>> reverse $ runIdentity $ yieldMany [0..3] $$ mapAccumS f [] (yieldMany [1..])
   [[],[1],[4,6],[12,15,18]] :: [[Int]]
   

9. mapAccumWhileC :: forall (m :: Type -> Type) a s b . Monad m => (a -> s -> Either s (s, b)) -> s -> ConduitT a b m s

   classy-prelude-conduit	ClassyPrelude.Conduit

   mapWhileC with a break condition dependent on a strict accumulator. Equivalently, mapAccum as long as the result is Right. Instead of producing a leftover, the breaking input determines the resulting accumulator via Left.

10. mapAccumWhileMC :: Monad m => (a -> s -> m (Either s (s, b))) -> s -> ConduitT a b m s

    classy-prelude-conduit	ClassyPrelude.Conduit

    Monadic mapAccumWhileC.

Page 279 of many | Previous | Next