{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MagicHash #-}
module Data.List.Index
(
indexed
, deleteAt
, setAt
, modifyAt
, updateAt
, insertAt
, imap
, imapM
, imapM_
, ifor
, ifor_
, ifoldr
, ifoldl
, ifoldl'
, iall
, iany
, iconcatMap
, ifilter
, ipartition
, itakeWhile
, idropWhile
, izipWith
, izipWithM
, izipWithM_
, ifind
, ifindIndex
, ifindIndices
, izipWith3
, izipWith4
, izipWith5
, izipWith6
, izipWith7
, iforM
, iforM_
, itraverse
, itraverse_
, ireplicateM
, ireplicateM_
, ifoldrM
, ifoldlM
, ifoldMap
, imapAccumR
, imapAccumL
) where
import Data.Foldable (sequenceA_)
import Data.Maybe (listToMaybe)
import Data.Semigroup (Semigroup ((<>)))
import GHC.Base (Int (..), Int#, build, oneShot, (+#))
indexed :: [a] -> [(Int, a)]
indexed :: [a] -> [(Int, a)]
indexed xs :: [a]
xs = Int# -> [a] -> [(Int, a)]
forall b. Int# -> [b] -> [(Int, b)]
go 0# [a]
xs
where
go :: Int# -> [b] -> [(Int, b)]
go i :: Int#
i (a :: b
a:as :: [b]
as) = (Int# -> Int
I# Int#
i, b
a) (Int, b) -> [(Int, b)] -> [(Int, b)]
forall a. a -> [a] -> [a]
: Int# -> [b] -> [(Int, b)]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [b]
as
go _ _ = []
{-# NOINLINE [1] indexed #-}
indexedFB :: ((Int, a) -> t -> t) -> a -> (Int# -> t) -> Int# -> t
indexedFB :: ((Int, a) -> t -> t) -> a -> (Int# -> t) -> Int# -> t
indexedFB c :: (Int, a) -> t -> t
c = \x :: a
x cont :: Int# -> t
cont i :: Int#
i -> (Int# -> Int
I# Int#
i, a
x) (Int, a) -> t -> t
`c` Int# -> t
cont (Int#
i Int# -> Int# -> Int#
+# 1#)
{-# INLINE [0] indexedFB #-}
{-# RULES
"indexed" [~1] forall xs. indexed xs = build (\c n -> foldr (indexedFB c) (\_ -> n) xs 0#)
"indexedList" [1] forall xs. foldr (indexedFB (:)) (\_ -> []) xs 0# = indexed xs
#-}
deleteAt :: Int -> [a] -> [a]
deleteAt :: Int -> [a] -> [a]
deleteAt i :: Int
i ls :: [a]
ls
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [a]
ls
| Bool
otherwise = Int -> [a] -> [a]
forall t a. (Eq t, Num t) => t -> [a] -> [a]
go Int
i [a]
ls
where
go :: t -> [a] -> [a]
go 0 (_:xs :: [a]
xs) = [a]
xs
go n :: t
n (x :: a
x:xs :: [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: t -> [a] -> [a]
go (t
nt -> t -> t
forall a. Num a => a -> a -> a
-1) [a]
xs
go _ [] = []
{-# INLINE deleteAt #-}
setAt :: Int -> a -> [a] -> [a]
setAt :: Int -> a -> [a] -> [a]
setAt i :: Int
i a :: a
a ls :: [a]
ls
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [a]
ls
| Bool
otherwise = Int -> [a] -> [a]
forall t. (Eq t, Num t) => t -> [a] -> [a]
go Int
i [a]
ls
where
go :: t -> [a] -> [a]
go 0 (_:xs :: [a]
xs) = a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs
go n :: t
n (x :: a
x:xs :: [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: t -> [a] -> [a]
go (t
nt -> t -> t
forall a. Num a => a -> a -> a
-1) [a]
xs
go _ [] = []
{-# INLINE setAt #-}
modifyAt :: Int -> (a -> a) -> [a] -> [a]
modifyAt :: Int -> (a -> a) -> [a] -> [a]
modifyAt i :: Int
i f :: a -> a
f ls :: [a]
ls
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [a]
ls
| Bool
otherwise = Int -> [a] -> [a]
forall t. (Eq t, Num t) => t -> [a] -> [a]
go Int
i [a]
ls
where
go :: t -> [a] -> [a]
go 0 (x :: a
x:xs :: [a]
xs) = a -> a
f a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs
go n :: t
n (x :: a
x:xs :: [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: t -> [a] -> [a]
go (t
nt -> t -> t
forall a. Num a => a -> a -> a
-1) [a]
xs
go _ [] = []
{-# INLINE modifyAt #-}
updateAt :: Int -> (a -> Maybe a) -> [a] -> [a]
updateAt :: Int -> (a -> Maybe a) -> [a] -> [a]
updateAt i :: Int
i f :: a -> Maybe a
f ls :: [a]
ls
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [a]
ls
| Bool
otherwise = Int -> [a] -> [a]
forall t. (Eq t, Num t) => t -> [a] -> [a]
go Int
i [a]
ls
where
go :: t -> [a] -> [a]
go 0 (x :: a
x:xs :: [a]
xs) = case a -> Maybe a
f a
x of
Nothing -> [a]
xs
Just x' :: a
x' -> a
x' a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs
go n :: t
n (x :: a
x:xs :: [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: t -> [a] -> [a]
go (t
nt -> t -> t
forall a. Num a => a -> a -> a
-1) [a]
xs
go _ [] = []
{-# INLINE updateAt #-}
insertAt :: Int -> a -> [a] -> [a]
insertAt :: Int -> a -> [a] -> [a]
insertAt i :: Int
i a :: a
a ls :: [a]
ls
| Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 0 = [a]
ls
| Bool
otherwise = Int -> [a] -> [a]
forall t. (Eq t, Num t) => t -> [a] -> [a]
go Int
i [a]
ls
where
go :: t -> [a] -> [a]
go 0 xs :: [a]
xs = a
a a -> [a] -> [a]
forall a. a -> [a] -> [a]
: [a]
xs
go n :: t
n (x :: a
x:xs :: [a]
xs) = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: t -> [a] -> [a]
go (t
nt -> t -> t
forall a. Num a => a -> a -> a
-1) [a]
xs
go _ [] = []
{-# INLINE insertAt #-}
imap :: (Int -> a -> b) -> [a] -> [b]
imap :: (Int -> a -> b) -> [a] -> [b]
imap f :: Int -> a -> b
f ls :: [a]
ls = Int# -> [a] -> [b]
go 0# [a]
ls
where
go :: Int# -> [a] -> [b]
go i :: Int#
i (x :: a
x:xs :: [a]
xs) = Int -> a -> b
f (Int# -> Int
I# Int#
i) a
x b -> [b] -> [b]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
go _ _ = []
{-# NOINLINE [1] imap #-}
imapFB
:: (b -> t -> t) -> (Int -> a -> b) -> a -> (Int# -> t) -> Int# -> t
imapFB :: (b -> t -> t) -> (Int -> a -> b) -> a -> (Int# -> t) -> Int# -> t
imapFB c :: b -> t -> t
c f :: Int -> a -> b
f = \x :: a
x r :: Int# -> t
r k :: Int#
k -> Int -> a -> b
f (Int# -> Int
I# Int#
k) a
x b -> t -> t
`c` Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE [0] imapFB #-}
{-# RULES
"imap" [~1] forall f xs. imap f xs = build (\c n -> foldr (imapFB c f) (\_ -> n) xs 0#)
"imapList" [1] forall f xs. foldr (imapFB (:) f) (\_ -> []) xs 0# = imap f xs
#-}
iconcatMap :: (Int -> a -> [b]) -> [a] -> [b]
iconcatMap :: (Int -> a -> [b]) -> [a] -> [b]
iconcatMap f :: Int -> a -> [b]
f xs :: [a]
xs = (forall b. (b -> b -> b) -> b -> b) -> [b]
forall a. (forall b. (a -> b -> b) -> b -> b) -> [a]
build ((forall b. (b -> b -> b) -> b -> b) -> [b])
-> (forall b. (b -> b -> b) -> b -> b) -> [b]
forall a b. (a -> b) -> a -> b
$ \c :: b -> b -> b
c n :: b
n ->
(Int -> a -> b -> b) -> b -> [a] -> b
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr (\i :: Int
i x :: a
x b :: b
b -> (b -> b -> b) -> b -> [b] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr b -> b -> b
c b
b (Int -> a -> [b]
f Int
i a
x)) b
n [a]
xs
{-# INLINE iconcatMap #-}
ifoldMap :: (Semigroup m, Monoid m) => (Int -> a -> m) -> [a] -> m
ifoldMap :: (Int -> a -> m) -> [a] -> m
ifoldMap p :: Int -> a -> m
p ls :: [a]
ls = (a -> (Int# -> m) -> Int# -> m) -> (Int# -> m) -> [a] -> Int# -> m
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (Int# -> m) -> Int# -> m
go (\_ -> m
forall a. Monoid a => a
mempty) [a]
ls 0#
where go :: a -> (Int# -> m) -> Int# -> m
go x :: a
x r :: Int# -> m
r k :: Int#
k = Int -> a -> m
p (Int# -> Int
I# Int#
k) a
x m -> m -> m
forall a. Semigroup a => a -> a -> a
<> Int# -> m
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE ifoldMap #-}
iall :: (Int -> a -> Bool) -> [a] -> Bool
iall :: (Int -> a -> Bool) -> [a] -> Bool
iall p :: Int -> a -> Bool
p ls :: [a]
ls = (a -> (Int# -> Bool) -> Int# -> Bool)
-> (Int# -> Bool) -> [a] -> Int# -> Bool
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (Int# -> Bool) -> Int# -> Bool
go (\_ -> Bool
True) [a]
ls 0#
where go :: a -> (Int# -> Bool) -> Int# -> Bool
go x :: a
x r :: Int# -> Bool
r k :: Int#
k = Int -> a -> Bool
p (Int# -> Int
I# Int#
k) a
x Bool -> Bool -> Bool
&& Int# -> Bool
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE iall #-}
iany :: (Int -> a -> Bool) -> [a] -> Bool
iany :: (Int -> a -> Bool) -> [a] -> Bool
iany p :: Int -> a -> Bool
p ls :: [a]
ls = (a -> (Int# -> Bool) -> Int# -> Bool)
-> (Int# -> Bool) -> [a] -> Int# -> Bool
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> (Int# -> Bool) -> Int# -> Bool
go (\_ -> Bool
False) [a]
ls 0#
where go :: a -> (Int# -> Bool) -> Int# -> Bool
go x :: a
x r :: Int# -> Bool
r k :: Int#
k = Int -> a -> Bool
p (Int# -> Int
I# Int#
k) a
x Bool -> Bool -> Bool
|| Int# -> Bool
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE iany #-}
imapM :: Monad m => (Int -> a -> m b) -> [a] -> m [b]
imapM :: (Int -> a -> m b) -> [a] -> m [b]
imapM f :: Int -> a -> m b
f as :: [a]
as = (Int -> a -> m [b] -> m [b]) -> m [b] -> [a] -> m [b]
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr Int -> a -> m [b] -> m [b]
k ([b] -> m [b]
forall (m :: * -> *) a. Monad m => a -> m a
return []) [a]
as
where
k :: Int -> a -> m [b] -> m [b]
k i :: Int
i a :: a
a r :: m [b]
r = do
b
x <- Int -> a -> m b
f Int
i a
a
[b]
xs <- m [b]
r
[b] -> m [b]
forall (m :: * -> *) a. Monad m => a -> m a
return (b
xb -> [b] -> [b]
forall a. a -> [a] -> [a]
:[b]
xs)
{-# INLINE imapM #-}
iforM :: Monad m => [a] -> (Int -> a -> m b) -> m [b]
iforM :: [a] -> (Int -> a -> m b) -> m [b]
iforM = ((Int -> a -> m b) -> [a] -> m [b])
-> [a] -> (Int -> a -> m b) -> m [b]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Int -> a -> m b) -> [a] -> m [b]
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> [a] -> m [b]
imapM
{-# INLINE iforM #-}
itraverse :: Applicative m => (Int -> a -> m b) -> [a] -> m [b]
itraverse :: (Int -> a -> m b) -> [a] -> m [b]
itraverse f :: Int -> a -> m b
f as :: [a]
as = (Int -> a -> m [b] -> m [b]) -> m [b] -> [a] -> m [b]
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr Int -> a -> m [b] -> m [b]
k ([b] -> m [b]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []) [a]
as
where
k :: Int -> a -> m [b] -> m [b]
k i :: Int
i a :: a
a r :: m [b]
r = (:) (b -> [b] -> [b]) -> m b -> m ([b] -> [b])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> a -> m b
f Int
i a
a m ([b] -> [b]) -> m [b] -> m [b]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m [b]
r
{-# INLINE itraverse #-}
ifor :: Applicative m => [a] -> (Int -> a -> m b) -> m [b]
ifor :: [a] -> (Int -> a -> m b) -> m [b]
ifor = ((Int -> a -> m b) -> [a] -> m [b])
-> [a] -> (Int -> a -> m b) -> m [b]
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Int -> a -> m b) -> [a] -> m [b]
forall (m :: * -> *) a b.
Applicative m =>
(Int -> a -> m b) -> [a] -> m [b]
itraverse
{-# INLINE ifor #-}
imapM_ :: Monad m => (Int -> a -> m b) -> [a] -> m ()
imapM_ :: (Int -> a -> m b) -> [a] -> m ()
imapM_ f :: Int -> a -> m b
f as :: [a]
as = (Int -> a -> m () -> m ()) -> m () -> [a] -> m ()
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr Int -> a -> m () -> m ()
forall b. Int -> a -> m b -> m b
k (() -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) [a]
as
where
k :: Int -> a -> m b -> m b
k i :: Int
i a :: a
a r :: m b
r = Int -> a -> m b
f Int
i a
a m b -> m b -> m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m b
r
{-# INLINE imapM_ #-}
iforM_ :: Monad m => [a] -> (Int -> a -> m b) -> m ()
iforM_ :: [a] -> (Int -> a -> m b) -> m ()
iforM_ = ((Int -> a -> m b) -> [a] -> m ())
-> [a] -> (Int -> a -> m b) -> m ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Int -> a -> m b) -> [a] -> m ()
forall (m :: * -> *) a b.
Monad m =>
(Int -> a -> m b) -> [a] -> m ()
imapM_
{-# INLINE iforM_ #-}
itraverse_ :: Applicative m => (Int -> a -> m b) -> [a] -> m ()
itraverse_ :: (Int -> a -> m b) -> [a] -> m ()
itraverse_ f :: Int -> a -> m b
f as :: [a]
as = (Int -> a -> m () -> m ()) -> m () -> [a] -> m ()
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr Int -> a -> m () -> m ()
forall b. Int -> a -> m b -> m b
k (() -> m ()
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()) [a]
as
where
k :: Int -> a -> m b -> m b
k i :: Int
i a :: a
a r :: m b
r = Int -> a -> m b
f Int
i a
a m b -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m b
r
{-# INLINE itraverse_ #-}
ifor_ :: Applicative m => [a] -> (Int -> a -> m b) -> m ()
ifor_ :: [a] -> (Int -> a -> m b) -> m ()
ifor_ = ((Int -> a -> m b) -> [a] -> m ())
-> [a] -> (Int -> a -> m b) -> m ()
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Int -> a -> m b) -> [a] -> m ()
forall (m :: * -> *) a b.
Applicative m =>
(Int -> a -> m b) -> [a] -> m ()
itraverse_
{-# INLINE ifor_ #-}
ireplicateM :: Applicative m => Int -> (Int -> m a) -> m [a]
ireplicateM :: Int -> (Int -> m a) -> m [a]
ireplicateM cnt :: Int
cnt f :: Int -> m a
f = Int -> m [a]
go 0
where
go :: Int -> m [a]
go !Int
i | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
cnt = [a] -> m [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
| Bool
otherwise = (:) (a -> [a] -> [a]) -> m a -> m ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> m a
f Int
i m ([a] -> [a]) -> m [a] -> m [a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> m [a]
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1)
{-# INLINE ireplicateM #-}
ireplicateM_ :: Monad m => Int -> (Int -> m a) -> m ()
ireplicateM_ :: Int -> (Int -> m a) -> m ()
ireplicateM_ cnt :: Int
cnt f :: Int -> m a
f = if Int
cnt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 0 then Int -> m ()
go 0 else () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
where
cnt_ :: Int
cnt_ = Int
cntInt -> Int -> Int
forall a. Num a => a -> a -> a
-1
go :: Int -> m ()
go !Int
i = if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
cnt_ then Int -> m a
f Int
i m a -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return () else Int -> m a
f Int
i m a -> m () -> m ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> m ()
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ 1)
{-# INLINE ireplicateM_ #-}
ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr f :: Int -> a -> b -> b
f z :: b
z xs :: [a]
xs = (a -> (Int -> b) -> Int -> b) -> (Int -> b) -> [a] -> Int -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\x :: a
x g :: Int -> b
g i :: Int
i -> Int -> a -> b -> b
f Int
i a
x (Int -> b
g (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1))) (b -> Int -> b
forall a b. a -> b -> a
const b
z) [a]
xs 0
{-# INLINE ifoldr #-}
ifoldrM :: Monad m => (Int -> a -> b -> m b) -> b -> [a] -> m b
ifoldrM :: (Int -> a -> b -> m b) -> b -> [a] -> m b
ifoldrM f :: Int -> a -> b -> m b
f z :: b
z xs :: [a]
xs = (Int -> a -> m b -> m b) -> m b -> [a] -> m b
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr Int -> a -> m b -> m b
k (b -> m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
z) [a]
xs
where
k :: Int -> a -> m b -> m b
k i :: Int
i a :: a
a r :: m b
r = Int -> a -> b -> m b
f Int
i a
a (b -> m b) -> m b -> m b
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m b
r
{-# INLINE ifoldrM #-}
imapAccumR
:: (acc -> Int -> x -> (acc, y))
-> acc
-> [x]
-> (acc, [y])
imapAccumR :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
imapAccumR f :: acc -> Int -> x -> (acc, y)
f z :: acc
z xs :: [x]
xs =
(x -> (Int -> (acc, [y])) -> Int -> (acc, [y]))
-> (Int -> (acc, [y])) -> [x] -> Int -> (acc, [y])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\x :: x
x g :: Int -> (acc, [y])
g i :: Int
i -> let (a :: acc
a, ys :: [y]
ys) = Int -> (acc, [y])
g (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1)
(a' :: acc
a', y :: y
y) = acc -> Int -> x -> (acc, y)
f acc
a Int
i x
x
in (acc
a', y
yy -> [y] -> [y]
forall a. a -> [a] -> [a]
:[y]
ys))
((acc, [y]) -> Int -> (acc, [y])
forall a b. a -> b -> a
const (acc
z, [])) [x]
xs 0
{-# INLINE imapAccumR #-}
ifoldl :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b
ifoldl :: (b -> Int -> a -> b) -> b -> [a] -> b
ifoldl k :: b -> Int -> a -> b
k z0 :: b
z0 xs :: [a]
xs =
(a -> ((Int, b) -> b) -> (Int, b) -> b)
-> ((Int, b) -> b) -> [a] -> (Int, b) -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(a
v::a) ((Int, b) -> b
fn :: (Int, b) -> b) ->
((Int, b) -> b) -> (Int, b) -> b
oneShot (\((!Int
i)::Int, b
z::b) -> (Int, b) -> b
fn (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1, b -> Int -> a -> b
k b
z Int
i a
v)))
((Int, b) -> b
forall a b. (a, b) -> b
snd :: (Int, b) -> b)
[a]
xs
(0, b
z0)
{-# INLINE ifoldl #-}
ifoldl' :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b
ifoldl' :: (b -> Int -> a -> b) -> b -> [a] -> b
ifoldl' k :: b -> Int -> a -> b
k z0 :: b
z0 xs :: [a]
xs =
(a -> ((Int, b) -> b) -> (Int, b) -> b)
-> ((Int, b) -> b) -> [a] -> (Int, b) -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(a
v::a) ((Int, b) -> b
fn :: (Int, b) -> b) ->
((Int, b) -> b) -> (Int, b) -> b
oneShot (\((!Int
i)::Int, b
z::b) -> b
z b -> b -> b
forall a b. a -> b -> b
`seq` (Int, b) -> b
fn (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1, b -> Int -> a -> b
k b
z Int
i a
v)))
((Int, b) -> b
forall a b. (a, b) -> b
snd :: (Int, b) -> b)
[a]
xs
(0, b
z0)
{-# INLINE ifoldl' #-}
ifoldlM :: Monad m => (b -> Int -> a -> m b) -> b -> [a] -> m b
ifoldlM :: (b -> Int -> a -> m b) -> b -> [a] -> m b
ifoldlM f :: b -> Int -> a -> m b
f z :: b
z xs :: [a]
xs = (m b -> Int -> a -> m b) -> m b -> [a] -> m b
forall a b. (b -> Int -> a -> b) -> b -> [a] -> b
ifoldl m b -> Int -> a -> m b
k (b -> m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
z) [a]
xs
where
k :: m b -> Int -> a -> m b
k a :: m b
a i :: Int
i r :: a
r = do b
a' <- m b
a; b -> Int -> a -> m b
f b
a' Int
i a
r
{-# INLINE ifoldlM #-}
imapAccumL
:: (acc -> Int -> x -> (acc, y))
-> acc
-> [x]
-> (acc, [y])
imapAccumL :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
imapAccumL f :: acc -> Int -> x -> (acc, y)
f z :: acc
z xs :: [x]
xs =
(x -> ((Int, acc) -> (acc, [y])) -> (Int, acc) -> (acc, [y]))
-> ((Int, acc) -> (acc, [y])) -> [x] -> (Int, acc) -> (acc, [y])
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\(x
x::a) ((Int, acc) -> (acc, [y])
r :: (Int,acc) -> (acc,[y])) ->
((Int, acc) -> (acc, [y])) -> (Int, acc) -> (acc, [y])
oneShot (\((!Int
i)::Int, acc
s::acc) ->
let (s' :: acc
s', y :: y
y) = acc -> Int -> x -> (acc, y)
f acc
s Int
i x
x
(s'' :: acc
s'', ys :: [y]
ys) = (Int, acc) -> (acc, [y])
r (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+1, acc
s')
in (acc
s'', y
yy -> [y] -> [y]
forall a. a -> [a] -> [a]
:[y]
ys)))
((\(_, a :: acc
a) -> (acc
a, [])) :: (Int,acc) -> (acc,[y]))
[x]
xs
(0, acc
z)
{-# INLINE imapAccumL #-}
ifilter :: (Int -> a -> Bool) -> [a] -> [a]
ifilter :: (Int -> a -> Bool) -> [a] -> [a]
ifilter p :: Int -> a -> Bool
p ls :: [a]
ls = Int# -> [a] -> [a]
go 0# [a]
ls
where
go :: Int# -> [a] -> [a]
go i :: Int#
i (x :: a
x:xs :: [a]
xs) | Int -> a -> Bool
p (Int# -> Int
I# Int#
i) a
x = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [a]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
| Bool
otherwise = Int# -> [a] -> [a]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
go _ _ = []
{-# NOINLINE [1] ifilter #-}
ifilterFB
:: (a -> t -> t) -> (Int -> a -> Bool) -> a -> (Int# -> t) -> Int# -> t
ifilterFB :: (a -> t -> t)
-> (Int -> a -> Bool) -> a -> (Int# -> t) -> Int# -> t
ifilterFB c :: a -> t -> t
c p :: Int -> a -> Bool
p = \x :: a
x r :: Int# -> t
r k :: Int#
k ->
if Int -> a -> Bool
p (Int# -> Int
I# Int#
k) a
x then a
x a -> t -> t
`c` Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#) else Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE [0] ifilterFB #-}
{-# RULES
"ifilter" [~1] forall p xs. ifilter p xs = build (\c n -> foldr (ifilterFB c p) (\_ -> n) xs 0#)
"ifilterList" [1] forall p xs. foldr (ifilterFB (:) p) (\_ -> []) xs 0# = ifilter p xs
#-}
itakeWhile :: (Int -> a -> Bool) -> [a] -> [a]
itakeWhile :: (Int -> a -> Bool) -> [a] -> [a]
itakeWhile p :: Int -> a -> Bool
p ls :: [a]
ls = Int# -> [a] -> [a]
go 0# [a]
ls
where
go :: Int# -> [a] -> [a]
go i :: Int#
i (x :: a
x:xs :: [a]
xs) | Int -> a -> Bool
p (Int# -> Int
I# Int#
i) a
x = a
x a -> [a] -> [a]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [a]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
| Bool
otherwise = []
go _ _ = []
{-# NOINLINE [1] itakeWhile #-}
itakeWhileFB
:: (a -> t -> t) -> (Int -> a -> Bool) -> t -> a -> (Int# -> t) -> Int# -> t
itakeWhileFB :: (a -> t -> t)
-> (Int -> a -> Bool) -> t -> a -> (Int# -> t) -> Int# -> t
itakeWhileFB c :: a -> t -> t
c p :: Int -> a -> Bool
p n :: t
n = \x :: a
x r :: Int# -> t
r k :: Int#
k ->
if Int -> a -> Bool
p (Int# -> Int
I# Int#
k) a
x then a
x a -> t -> t
`c` Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#) else t
n
{-# INLINE [0] itakeWhileFB #-}
{-# RULES
"itakeWhile" [~1] forall p xs. itakeWhile p xs = build (\c n -> foldr (itakeWhileFB c p n) (\_ -> n) xs 0#)
"itakeWhileList" [1] forall p xs. foldr (itakeWhileFB (:) p []) (\_ -> []) xs 0# = itakeWhile p xs
#-}
idropWhile :: (Int -> a -> Bool) -> [a] -> [a]
idropWhile :: (Int -> a -> Bool) -> [a] -> [a]
idropWhile p :: Int -> a -> Bool
p ls :: [a]
ls = Int# -> [a] -> [a]
go 0# [a]
ls
where
go :: Int# -> [a] -> [a]
go i :: Int#
i (x :: a
x:xs :: [a]
xs) | Int -> a -> Bool
p (Int# -> Int
I# Int#
i) a
x = Int# -> [a] -> [a]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
| Bool
otherwise = a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs
go _ [] = []
{-# INLINE idropWhile #-}
ipartition :: (Int -> a -> Bool) -> [a] -> ([a],[a])
ipartition :: (Int -> a -> Bool) -> [a] -> ([a], [a])
ipartition p :: Int -> a -> Bool
p xs :: [a]
xs = (Int -> a -> ([a], [a]) -> ([a], [a]))
-> ([a], [a]) -> [a] -> ([a], [a])
forall a b. (Int -> a -> b -> b) -> b -> [a] -> b
ifoldr ((Int -> a -> Bool) -> Int -> a -> ([a], [a]) -> ([a], [a])
forall a.
(Int -> a -> Bool) -> Int -> a -> ([a], [a]) -> ([a], [a])
iselect Int -> a -> Bool
p) ([],[]) [a]
xs
{-# INLINE ipartition #-}
iselect :: (Int -> a -> Bool) -> Int -> a -> ([a], [a]) -> ([a], [a])
iselect :: (Int -> a -> Bool) -> Int -> a -> ([a], [a]) -> ([a], [a])
iselect p :: Int -> a -> Bool
p i :: Int
i x :: a
x ~(ts :: [a]
ts,fs :: [a]
fs) | Int -> a -> Bool
p Int
i a
x = (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
ts,[a]
fs)
| Bool
otherwise = ([a]
ts, a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
fs)
ifind :: (Int -> a -> Bool) -> [a] -> Maybe (Int, a)
ifind :: (Int -> a -> Bool) -> [a] -> Maybe (Int, a)
ifind p :: Int -> a -> Bool
p ls :: [a]
ls = Int# -> [a] -> Maybe (Int, a)
go 0# [a]
ls
where
go :: Int# -> [a] -> Maybe (Int, a)
go i :: Int#
i (x :: a
x:xs :: [a]
xs) | Int -> a -> Bool
p (Int# -> Int
I# Int#
i) a
x = (Int, a) -> Maybe (Int, a)
forall a. a -> Maybe a
Just (Int# -> Int
I# Int#
i, a
x)
| Bool
otherwise = Int# -> [a] -> Maybe (Int, a)
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
go _ _ = Maybe (Int, a)
forall a. Maybe a
Nothing
{-# INLINE ifind #-}
ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int
ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int
ifindIndex p :: Int -> a -> Bool
p = [Int] -> Maybe Int
forall a. [a] -> Maybe a
listToMaybe ([Int] -> Maybe Int) -> ([a] -> [Int]) -> [a] -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> a -> Bool) -> [a] -> [Int]
forall a. (Int -> a -> Bool) -> [a] -> [Int]
ifindIndices Int -> a -> Bool
p
ifindIndices :: (Int -> a -> Bool) -> [a] -> [Int]
ifindIndices :: (Int -> a -> Bool) -> [a] -> [Int]
ifindIndices p :: Int -> a -> Bool
p ls :: [a]
ls = Int# -> [a] -> [Int]
go 0# [a]
ls
where
go :: Int# -> [a] -> [Int]
go _ [] = []
go i :: Int#
i (x :: a
x:xs :: [a]
xs) | Int -> a -> Bool
p (Int# -> Int
I# Int#
i) a
x = Int# -> Int
I# Int#
i Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [Int]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
| Bool
otherwise = Int# -> [a] -> [Int]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
xs
{-# NOINLINE [1] ifindIndices #-}
ifindIndicesFB
:: (Int -> t -> t) -> (Int -> a -> Bool) -> a -> (Int# -> t) -> Int# -> t
ifindIndicesFB :: (Int -> t -> t)
-> (Int -> a -> Bool) -> a -> (Int# -> t) -> Int# -> t
ifindIndicesFB c :: Int -> t -> t
c p :: Int -> a -> Bool
p = \x :: a
x r :: Int# -> t
r k :: Int#
k ->
if Int -> a -> Bool
p (Int# -> Int
I# Int#
k) a
x then Int# -> Int
I# Int#
k Int -> t -> t
`c` Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#) else Int# -> t
r (Int#
k Int# -> Int# -> Int#
+# 1#)
{-# INLINE [0] ifindIndicesFB #-}
{-# RULES
"ifindIndices" [~1] forall p xs. ifindIndices p xs = build (\c n -> foldr (ifindIndicesFB c p) (\_ -> n) xs 0#)
"ifindIndicesList" [1] forall p xs. foldr (ifindIndicesFB (:) p) (\_ -> []) xs 0# = ifindIndices p xs
#-}
izipWith :: (Int -> a -> b -> c) -> [a] -> [b] -> [c]
izipWith :: (Int -> a -> b -> c) -> [a] -> [b] -> [c]
izipWith fun :: Int -> a -> b -> c
fun xs :: [a]
xs ys :: [b]
ys = Int# -> [a] -> [b] -> [c]
go 0# [a]
xs [b]
ys
where
go :: Int# -> [a] -> [b] -> [c]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) = Int -> a -> b -> c
fun (Int# -> Int
I# Int#
i) a
a b
b c -> [c] -> [c]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs
go _ _ _ = []
{-# NOINLINE [1] izipWith #-}
izipWithFB
:: (c -> t -> t) -> (Int -> a -> b -> c) -> a -> b -> (Int# -> t) -> Int# -> t
izipWithFB :: (c -> t -> t)
-> (Int -> a -> b -> c) -> a -> b -> (Int# -> t) -> Int# -> t
izipWithFB c :: c -> t -> t
c fun :: Int -> a -> b -> c
fun = \x :: a
x y :: b
y cont :: Int# -> t
cont i :: Int#
i -> Int -> a -> b -> c
fun (Int# -> Int
I# Int#
i) a
x b
y c -> t -> t
`c` Int# -> t
cont (Int#
i Int# -> Int# -> Int#
+# 1#)
{-# INLINE [0] izipWithFB #-}
{-# RULES
"izipWith" [~1] forall f xs ys. izipWith f xs ys = build (\c n -> foldr2 (izipWithFB c f) (\_ -> n) xs ys 0#)
"izipWithList" [1] forall f xs ys. foldr2 (izipWithFB (:) f) (\_ -> []) xs ys 0# = izipWith f xs ys
#-}
foldr2 :: (a -> b -> c -> c) -> c -> [a] -> [b] -> c
foldr2 :: (a -> b -> c -> c) -> c -> [a] -> [b] -> c
foldr2 k :: a -> b -> c -> c
k z :: c
z = [a] -> [b] -> c
go
where
go :: [a] -> [b] -> c
go [] _ys :: [b]
_ys = c
z
go _xs :: [a]
_xs [] = c
z
go (x :: a
x:xs :: [a]
xs) (y :: b
y:ys :: [b]
ys) = a -> b -> c -> c
k a
x b
y ([a] -> [b] -> c
go [a]
xs [b]
ys)
{-# INLINE [0] foldr2 #-}
foldr2_left :: (a -> b -> c -> d) -> d -> a -> ([b] -> c) -> [b] -> d
foldr2_left :: (a -> b -> c -> d) -> d -> a -> ([b] -> c) -> [b] -> d
foldr2_left _k :: a -> b -> c -> d
_k z :: d
z _x :: a
_x _r :: [b] -> c
_r [] = d
z
foldr2_left k :: a -> b -> c -> d
k _z :: d
_z x :: a
x r :: [b] -> c
r (y :: b
y:ys :: [b]
ys) = a -> b -> c -> d
k a
x b
y ([b] -> c
r [b]
ys)
{-# RULES
"foldr2/left" forall k z ys (g::forall b.(a->b->b)->b->b) .
foldr2 k z (build g) ys = g (foldr2_left k z) (\_ -> z) ys
#-}
izipWith3
:: (Int -> a -> b -> c -> d)
-> [a] -> [b] -> [c] -> [d]
izipWith3 :: (Int -> a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
izipWith3 fun :: Int -> a -> b -> c -> d
fun = Int# -> [a] -> [b] -> [c] -> [d]
go 0#
where
go :: Int# -> [a] -> [b] -> [c] -> [d]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) (c :: c
c:cs :: [c]
cs) =
Int -> a -> b -> c -> d
fun (Int# -> Int
I# Int#
i) a
a b
b c
c d -> [d] -> [d]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c] -> [d]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs [c]
cs
go _ _ _ _ = []
{-# INLINE izipWith3 #-}
izipWith4
:: (Int -> a -> b -> c -> d -> e)
-> [a] -> [b] -> [c] -> [d] -> [e]
izipWith4 :: (Int -> a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
izipWith4 fun :: Int -> a -> b -> c -> d -> e
fun = Int# -> [a] -> [b] -> [c] -> [d] -> [e]
go 0#
where
go :: Int# -> [a] -> [b] -> [c] -> [d] -> [e]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) (c :: c
c:cs :: [c]
cs) (d :: d
d:ds :: [d]
ds) =
Int -> a -> b -> c -> d -> e
fun (Int# -> Int
I# Int#
i) a
a b
b c
c d
d e -> [e] -> [e]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c] -> [d] -> [e]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs [c]
cs [d]
ds
go _ _ _ _ _ = []
{-# INLINE izipWith4 #-}
izipWith5
:: (Int -> a -> b -> c -> d -> e -> f)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
izipWith5 :: (Int -> a -> b -> c -> d -> e -> f)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
izipWith5 fun :: Int -> a -> b -> c -> d -> e -> f
fun = Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
go 0#
where
go :: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) (c :: c
c:cs :: [c]
cs) (d :: d
d:ds :: [d]
ds) (e :: e
e:es :: [e]
es) =
Int -> a -> b -> c -> d -> e -> f
fun (Int# -> Int
I# Int#
i) a
a b
b c
c d
d e
e f -> [f] -> [f]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs [c]
cs [d]
ds [e]
es
go _ _ _ _ _ _ = []
{-# INLINE izipWith5 #-}
izipWith6
:: (Int -> a -> b -> c -> d -> e -> f -> g)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
izipWith6 fun :: Int -> a -> b -> c -> d -> e -> f -> g
fun = Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
go 0#
where
go :: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) (c :: c
c:cs :: [c]
cs) (d :: d
d:ds :: [d]
ds) (e :: e
e:es :: [e]
es) (f :: f
f:fs :: [f]
fs) =
Int -> a -> b -> c -> d -> e -> f -> g
fun (Int# -> Int
I# Int#
i) a
a b
b c
c d
d e
e f
f g -> [g] -> [g]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs [c]
cs [d]
ds [e]
es [f]
fs
go _ _ _ _ _ _ _ = []
{-# INLINE izipWith6 #-}
izipWith7
:: (Int -> a -> b -> c -> d -> e -> f -> g -> h)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
izipWith7 :: (Int -> a -> b -> c -> d -> e -> f -> g -> h)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
izipWith7 fun :: Int -> a -> b -> c -> d -> e -> f -> g -> h
fun = Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
go 0#
where
go :: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
go i :: Int#
i (a :: a
a:as :: [a]
as) (b :: b
b:bs :: [b]
bs) (c :: c
c:cs :: [c]
cs) (d :: d
d:ds :: [d]
ds) (e :: e
e:es :: [e]
es) (f :: f
f:fs :: [f]
fs) (g :: g
g:gs :: [g]
gs) =
Int -> a -> b -> c -> d -> e -> f -> g -> h
fun (Int# -> Int
I# Int#
i) a
a b
b c
c d
d e
e f
f g
g h -> [h] -> [h]
forall a. a -> [a] -> [a]
: Int# -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
go (Int#
i Int# -> Int# -> Int#
+# 1#) [a]
as [b]
bs [c]
cs [d]
ds [e]
es [f]
fs [g]
gs
go _ _ _ _ _ _ _ _ = []
{-# INLINE izipWith7 #-}
izipWithM :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f [c]
izipWithM :: (Int -> a -> b -> f c) -> [a] -> [b] -> f [c]
izipWithM f :: Int -> a -> b -> f c
f as :: [a]
as bs :: [b]
bs = [f c] -> f [c]
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA ((Int -> a -> b -> f c) -> [a] -> [b] -> [f c]
forall a b c. (Int -> a -> b -> c) -> [a] -> [b] -> [c]
izipWith Int -> a -> b -> f c
f [a]
as [b]
bs)
{-# INLINE izipWithM #-}
izipWithM_ :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f ()
izipWithM_ :: (Int -> a -> b -> f c) -> [a] -> [b] -> f ()
izipWithM_ f :: Int -> a -> b -> f c
f as :: [a]
as bs :: [b]
bs = [f c] -> f ()
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Applicative f) =>
t (f a) -> f ()
sequenceA_ ((Int -> a -> b -> f c) -> [a] -> [b] -> [f c]
forall a b c. (Int -> a -> b -> c) -> [a] -> [b] -> [c]
izipWith Int -> a -> b -> f c
f [a]
as [b]
bs)
{-# INLINE izipWithM_ #-}