for -package:faktory

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)

for is traverse with its arguments flipped. For a version that ignores the results see for_.

blaze-html Text.Blaze.Html4.FrameSet.Attributes Text.Blaze.Html4.Strict.Attributes Text.Blaze.Html4.Transitional.Attributes Text.Blaze.Html5.Attributes Text.Blaze.XHtml1.FrameSet.Attributes Text.Blaze.XHtml1.Strict.Attributes Text.Blaze.XHtml1.Transitional.Attributes Text.Blaze.XHtml5.Attributes

Combinator for the for attribute. Example:

div ! for "bar" $ "Hello."

Result:

<div for="bar">Hello.</div>

for :: Functor m => Proxy x' x b' b m a' -> (b -> Proxy x' x c' c m b') -> Proxy x' x c' c m a'

pipes Pipes

(for p body) loops over p replacing each yield with body.

for :: Functor m => Producer b m r -> (b -> Effect       m ()) -> Effect       m r
for :: Functor m => Producer b m r -> (b -> Producer   c m ()) -> Producer   c m r
for :: Functor m => Pipe   x b m r -> (b -> Consumer x   m ()) -> Consumer x   m r
for :: Functor m => Pipe   x b m r -> (b -> Pipe     x c m ()) -> Pipe     x c m r

The following diagrams show the flow of information:

.--->   b
/        |
+-----------+            /   +-----|-----+                 +---------------+
|           |           /    |     v     |                 |               |
|           |          /     |           |                 |               |
x ==>    p    ==> b   ---'   x ==>   body  ==> c     =     x ==> for p body  ==> c
|           |                |           |                 |               |
|     |     |                |     |     |                 |       |       |
+-----|-----+                +-----|-----+                 +-------|-------+
v                            v                               v
r                            ()                              r

For a more complete diagram including bidirectional flow, see "Pipes.Core#respond-diagram".

for :: Functor f => f a -> (a -> b) -> f b

utility-ht Control.Functor.HT

for :: Monad m => [a] -> (a -> m b) -> m [b]

utility-ht Control.Monad.HT

for :: Monad m => Int -> Int -> (Int -> m ()) -> m ()

statistics Statistics.Function, dense-linear-algebra Statistics.Matrix Statistics.Matrix.Function

Simple for loop. Counts from start to end-1.

for :: (Monad m, Functor f) => Stream (Of a) m r -> (a -> Stream f m x) -> Stream f m r

streaming Streaming.Prelude

for replaces each element of a stream with an associated stream. Note that the associated stream may layer any functor.

for :: Tagged a b -> a -> b

crypto-api Crypto.Util

Obtain a tagged value for a particular instantiated type.

for :: Monad m => ByteStream m r -> (ByteString -> ByteStream m x) -> ByteStream m r

streaming-bytestring Streaming.ByteString

for xs f applies f to each chunk in the stream, and concatenates the resulting streams. Generalised in 0.2.4 to match streaming: the callback's (ignored) return value can be of any type.

for :: (Contiguous arr1, Contiguous arr2, Element arr1 a, Element arr2 b, Applicative f) => arr1 a -> (a -> f b) -> f (arr2 b)

contiguous Data.Primitive.Contiguous

for is traverse with its arguments flipped. For a version that ignores the results see for_.

for :: Refinement

clay Clay Clay.Attributes

for :: Functor m => m a -> (a -> b) -> m b

Agda Agda.Utils.Functor

The true pure for loop. for is a misnomer, it should be forA.

for :: From -> Maybe LockStrength

opaleye Opaleye.Internal.Sql

for :: Monad m => a -> (a -> Bool) -> (a -> a) -> b -> (a -> b -> m b) -> m b

yjtools Control.Monad.Tools

for :: WriteAttr Element String

threepenny-gui Graphics.UI.Threepenny.Attributes

for :: (HasTime t s, Monoid e) => t -> Wire s e m a a

netwire Control.Wire.Interval

For the given time period.

Depends: now for the given time period.
Inhibits: after the given time period.

for :: forall t a f (es :: [Effect]) (ff :: (Type -> Type) -> Type -> Type) (c :: (Type -> Type) -> Constraint) . (Free c ff, f ~ Eff ff es, For t :> es) => t (f a) -> f (t a)

data-effects Data.Effect.Concurrent.Parallel

Executes in parallel the actions stored within a Traversable container t.

for :: [a] -> (a -> b) -> [b]

BNFC BNFC.Utils

Non-monadic forM.

for :: Testable a => (WithOption a -> b) -> Int -> a -> b

extrapolate Test.Extrapolate Test.Extrapolate.IO

Use for to configure the number of tests performed by check.

> check `for` 10080 $ \xs -> sort (sort xs) == sort (xs :: [Int])
+++ OK, passed 10080 tests.

Don't forget the dollar ($)!

For :: TemplateExpr -> [TemplateElement] -> Maybe [TemplateElement] -> TemplateElement

hakyll Hakyll.Web.Template.Internal.Element

type family For (a1 :: t a) (a2 :: a ~> f b) :: f t b

singletons-base Data.Traversable.Singletons

For :: Either InitGroup (Maybe Exp) -> Maybe Exp -> Maybe Exp -> Stm -> SrcLoc -> Stm

language-c-quote Language.C.Syntax

For :: t -> t -> (Expr t) -> (ForContent t) -> t -> (Block t) -> Statement t

yi Yi.Syntax.JavaScript

data For (t :: Type -> Type) (a :: Type -> Type) b

data-effects Data.Effect.Concurrent.Parallel

An effect for parallel computations based on a Traversable container t.

For :: forall (t :: Type -> Type) (a :: Type -> Type) a1 . t (a a1) -> For t a (t a1)

data-effects Data.Effect.Concurrent.Parallel

Executes in parallel the actions stored within a Traversable container t.