Search results

foldl :: forall f a b. Foldable f => (b -> a -> b) -> b -> f a -> b

foldl :: forall a b. (b -> a -> b) -> b -> Array a -> b

foldl :: forall f a b. Monad f => (b -> a -> b) -> b -> ListT f a -> f b

Fold a list from the left, accumulating the result using the specified function.

foldl :: forall a b t. TypedArray a t => (b -> t -> b) -> b -> ArrayView a -> Effect b

Fold a list from the left, accumulating the result using the specified function.

foldl :: forall a. (a -> Octet -> a) -> a -> ByteString -> a

Θ(n) Fold a byte string.

foldl :: forall b a f. Foldable f => Fold a b -> f a -> b

Run a Fold by providing a Foldable container of inputs, and then generating a single output. This is analogous to the foldl function from Data.Foldable.

foldl :: forall a. (a -> DataBuff -> a) -> a -> Builder -> a

Stack-safe foldl over a Builder. O(n)

foldl :: forall b a. Iso (Tuple a b) a -> Iso (Tuple a (List b)) a

foldl :: forall a b f. Foldable f => (b -> a -> Return b) -> b -> f a -> b

foldl :: forall a b parentTypeLock. (b -> a -> b) -> b -> Array (SelectionSet parentTypeLock a) -> SelectionSet parentTypeLock b

foldl :: forall b a m. Monad m => (b -> a -> b) -> b -> StreamT m a -> m b

foldl :: forall a. (Int -> a -> a) -> a -> Array Char -> a

foldl :: forall f a b. Foldable f => Fold a b -> f a -> b

Run a Fold by providing a Foldable container of inputs, and then generating a single output. This is analogous to the foldl function from Data.Foldable.

foldl1 :: forall t a. Foldable1 t => (a -> a -> a) -> t a -> a

foldl1 :: forall f a. Foldable f => (a -> a -> a) -> NonEmpty f a -> a

Fold a non-empty structure, collecting results using a binary operation.

foldl1 (+) (1 :| [2, 3]) == 6

foldl1 :: forall a. (a -> a -> a) -> NonEmptyArray a -> a

foldl' :: forall f a b. Monad f => (b -> a -> f b) -> b -> ListT f a -> f b

Fold a list from the left, accumulating the result (effectfully) using the specified function.

foldl1 :: forall a t. Partial => TypedArray a t => (t -> t -> t) -> ArrayView a -> Effect t

Folding from the left. Assumes the typed array is non-empty.

foldl1 :: forall v k f. Foldable (f k) => (v -> v -> v) -> NonEmpty f k v -> v

foldl1 :: forall t f b. Foldable1 t => (forall a. b -> f a -> b) -> b -> t f -> b

foldlOf :: forall s t a b r. Fold (Dual (Endo Function r)) s t a b -> (r -> a -> r) -> r -> s -> r

Left fold over a Fold.

foldlRec :: forall f a b. MonadRec f => (b -> a -> b) -> b -> ListT f a -> f b

Fold a list from the left, accumulating the result using the specified function. Uses tail call optimization.

foldlRec' :: forall f a b. MonadRec f => (b -> a -> f b) -> b -> ListT f a -> f b

Fold a list from the left, accumulating the result (effectfully) using the specified function. Uses tail call optimization.

foldlVFRL :: forall rl row a b. FoldableVFRL rl row => Proxy rl -> (b -> a -> b) -> b -> VariantF row a -> b

foldlValues :: forall accum row fieldType rowList. RowToList row rowList => FoldlValues rowList row fieldType => (accum -> fieldType -> accum) -> accum -> Record row -> accum

foldlDefault :: forall f a b. Foldable f => (b -> a -> b) -> b -> f a -> b

A default implementation of foldl using foldMap.

Note: when defining a Foldable instance, this function is unsafe to use in combination with foldMapDefaultL.

foldlDefault :: forall i f a b. FoldableWithIndex i f => (b -> a -> b) -> b -> f a -> b

A default implementation of foldl using foldlWithIndex

foldlCurrent :: forall a b. { cur :: b -> a -> b, rest :: b -> a -> b } -> b -> ZipperArray a -> b

Performs a foldl using the provided functions to transform the items. The cur function is used for the current item, and the rest function is used for the other items.

foldl1Default :: forall t a. Foldable1 t => (a -> a -> a) -> t a -> a

A default implementation of foldl1 using foldMap1.

Note: when defining a Foldable1 instance, this function is unsafe to use in combination with foldMap1DefaultL.

foldLocations :: forall a. (a -> LocationState -> Effect a) -> (LocationState -> Effect a) -> PushStateInterface -> Effect (Effect Unit)

Folds effectfully over location changes given callbacks for handling changes and the initial location. Returns an effect which removes the listener.

foldLineNames :: forall i o. FoldLineNames i o => i -> o

foldlMultiVal :: forall xs acc. MultiVal xs => (acc -> Val -> acc) -> acc -> xs -> acc

foldlSelected :: forall b a f. Foldable f => Eq a => (IsSelected -> b -> a -> b) -> b -> SelectionFoldable f a -> b

foldlSelected :: forall b a d f. Foldable f => Eq a => { rest :: b -> a -> b, sel :: b -> Tuple d a -> b } -> b -> SelectionFoldableWithData f d a -> b

Performs a foldl, using the provided functions to transform the items and the data. The sel function is used for all items a that are equal to the selected item, and the rest function is used for the other items.

foldlWithIndex :: forall i f a b. FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b

foldlWithIndex :: forall a b t. TypedArray a t => (Index -> b -> t -> b) -> b -> ArrayView a -> Effect b

Fold a list from the left, accumulating the result using the supplied function. The accumulating function receives the index, the accumulated value and the element.

foldlWithIndex :: forall a b f i. FoldableWithIndex i f => (i -> b -> a -> Return b) -> b -> f a -> b

foldlValuesImpl :: forall rowList row fieldType accum. FoldlValues rowList row fieldType => Proxy rowList -> (accum -> fieldType -> accum) -> accum -> Record row -> accum

foldlRecordRowList :: forall f x rl r b proxy. FoldlRecord f x rl r b => f -> x -> proxy rl -> Record r -> b

foldlRecordRowList :: forall f x rl r b. FoldlRecord f x rl r b => f -> x -> RLProxy rl -> Record r -> b

foldlVariantRowList :: forall f x rl r b proxy. FoldlVariant f x rl r b => proxy rl -> f -> x -> Variant r -> b

foldlVariantFRowList :: forall f x rl r z y proxy. FoldlVariantF f x rl r z y => proxy rl -> f -> x -> VariantF r z -> y

foldlValuesWithIndex :: forall accum row fieldType rowList. RowToList row rowList => FoldlValuesWithIndex rowList row fieldType => (accum -> String -> fieldType -> accum) -> accum -> Record row -> accum

foldlWithIndexDefault :: forall i f a b. FoldableWithIndex i f => (i -> b -> a -> b) -> b -> f a -> b

A default implementation of foldlWithIndex using foldMapWithIndex.

Note: when defining a FoldableWithIndex instance, this function is unsafe to use in combination with foldMapWithIndexDefaultL.

foldlWithIndexCurrent :: forall a b. { cur :: Int -> b -> a -> b, rest :: Int -> b -> a -> b } -> b -> ZipperArray a -> b

Performs a foldlWithIndex using the provided functions to transform the items. The cur function is used for the current item, and the rest function is used for the other items.

foldlWithIndexSelected :: forall b a f i. FoldableWithIndex i f => Eq a => (IsSelected -> i -> b -> a -> b) -> b -> SelectionFoldable f a -> b

foldlWithIndexSelected :: forall b a d f i. FoldableWithIndex i f => Eq a => { rest :: i -> b -> a -> b, sel :: i -> b -> Tuple d a -> b } -> b -> SelectionFoldableWithData f d a -> b

Performs a foldlWithIndex, using the provided functions to transform the items and the data. The sel function is used for all items a that are equal to the selected item, and the rest function is used for the other items.

foldlValuesWithIndexImpl :: forall rowList row fieldType accum. FoldlValuesWithIndex rowList row fieldType => Proxy rowList -> (accum -> String -> fieldType -> accum) -> accum -> Record row -> accum