rio 0.1.19.0 → 0.1.20.0
raw patch · 3 files changed
+14/−4 lines, 3 filesdep ~unliftioPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: unliftio
API changes (from Hackage documentation)
- RIO.Prelude.Types: data Proxy (t :: k) :: forall k. () => k -> Type
- RIO.Prelude.Types: newtype ReaderT r (m :: k -> Type) (a :: k) :: forall k. () => Type -> k -> Type -> k -> Type
- RIO.Seq: pattern (:|>) :: forall a. () => () => Seq a -> a -> Seq a
- RIO.Seq: pattern (:<|) :: forall a. () => () => a -> Seq a -> Seq a
- RIO.Time: buildTime :: ParseTime t => TimeLocale -> [(Char, String)] -> Maybe t
- RIO.Time: formatCharacter :: FormatTime t => Char -> Maybe (TimeLocale -> Maybe NumericPadOption -> Maybe Int -> t -> String)
- RIO.Time: type NumericPadOption = Maybe Char
+ RIO.Prelude: [getDown] :: Down a -> a
+ RIO.Prelude.Types: data Proxy (t :: k)
+ RIO.Prelude.Types: newtype Const a (b :: k)
+ RIO.Prelude.Types: newtype ReaderT r (m :: Type -> Type) a
+ RIO.Seq: pattern (:<|) :: a -> Seq a -> Seq a
+ RIO.Seq: pattern Empty :: Seq a
+ RIO.Time: CalendarDiffDays :: Integer -> Integer -> CalendarDiffDays
+ RIO.Time: CalendarDiffTime :: Integer -> NominalDiffTime -> CalendarDiffTime
+ RIO.Time: Friday :: DayOfWeek
+ RIO.Time: Monday :: DayOfWeek
+ RIO.Time: Saturday :: DayOfWeek
+ RIO.Time: Sunday :: DayOfWeek
+ RIO.Time: Thursday :: DayOfWeek
+ RIO.Time: Tuesday :: DayOfWeek
+ RIO.Time: Wednesday :: DayOfWeek
+ RIO.Time: [cdDays] :: CalendarDiffDays -> Integer
+ RIO.Time: [cdMonths] :: CalendarDiffDays -> Integer
+ RIO.Time: [ctMonths] :: CalendarDiffTime -> Integer
+ RIO.Time: [ctTime] :: CalendarDiffTime -> NominalDiffTime
+ RIO.Time: addGregorianDurationClip :: CalendarDiffDays -> Day -> Day
+ RIO.Time: addGregorianDurationRollOver :: CalendarDiffDays -> Day -> Day
+ RIO.Time: addLocalTime :: NominalDiffTime -> LocalTime -> LocalTime
+ RIO.Time: calendarDay :: CalendarDiffDays
+ RIO.Time: calendarMonth :: CalendarDiffDays
+ RIO.Time: calendarTimeDays :: CalendarDiffDays -> CalendarDiffTime
+ RIO.Time: calendarTimeTime :: NominalDiffTime -> CalendarDiffTime
+ RIO.Time: calendarWeek :: CalendarDiffDays
+ RIO.Time: calendarYear :: CalendarDiffDays
+ RIO.Time: data CalendarDiffDays
+ RIO.Time: data CalendarDiffTime
+ RIO.Time: data DayOfWeek
+ RIO.Time: dayOfWeek :: Day -> DayOfWeek
+ RIO.Time: daysAndTimeOfDayToTime :: Integer -> TimeOfDay -> NominalDiffTime
+ RIO.Time: diffGregorianDurationClip :: Day -> Day -> CalendarDiffDays
+ RIO.Time: diffGregorianDurationRollOver :: Day -> Day -> CalendarDiffDays
+ RIO.Time: diffLocalTime :: LocalTime -> LocalTime -> NominalDiffTime
+ RIO.Time: nominalDiffTimeToSeconds :: NominalDiffTime -> Pico
+ RIO.Time: scaleCalendarDiffDays :: Integer -> CalendarDiffDays -> CalendarDiffDays
+ RIO.Time: scaleCalendarDiffTime :: Integer -> CalendarDiffTime -> CalendarDiffTime
+ RIO.Time: secondsToNominalDiffTime :: Pico -> NominalDiffTime
+ RIO.Time: timeToDaysAndTimeOfDay :: NominalDiffTime -> (Integer, TimeOfDay)
- RIO: (%~) :: () => ASetter s t a b -> (a -> b) -> s -> t
+ RIO: (%~) :: ASetter s t a b -> (a -> b) -> s -> t
- RIO: (.~) :: () => ASetter s t a b -> b -> s -> t
+ RIO: (.~) :: ASetter s t a b -> b -> s -> t
- RIO: (^.) :: () => s -> Getting a s a -> a
+ RIO: (^.) :: s -> Getting a s a -> a
- RIO: (^..) :: () => s -> Getting (Endo [a]) s a -> [a]
+ RIO: (^..) :: s -> Getting (Endo [a]) s a -> [a]
- RIO: (^?) :: () => s -> Getting (First a) s a -> Maybe a
+ RIO: (^?) :: s -> Getting (First a) s a -> Maybe a
- RIO: lens :: () => (s -> a) -> (s -> b -> t) -> Lens s t a b
+ RIO: lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
- RIO: over :: () => ASetter s t a b -> (a -> b) -> s -> t
+ RIO: over :: ASetter s t a b -> (a -> b) -> s -> t
- RIO: set :: () => ASetter s t a b -> b -> s -> t
+ RIO: set :: ASetter s t a b -> b -> s -> t
- RIO: sets :: () => ((a -> b) -> s -> t) -> ASetter s t a b
+ RIO: sets :: ((a -> b) -> s -> t) -> ASetter s t a b
- RIO: to :: () => (s -> a) -> SimpleGetter s a
+ RIO: to :: (s -> a) -> SimpleGetter s a
- RIO.ByteString: foldl :: () => (a -> Word8 -> a) -> a -> ByteString -> a
+ RIO.ByteString: foldl :: (a -> Word8 -> a) -> a -> ByteString -> a
- RIO.ByteString: foldl' :: () => (a -> Word8 -> a) -> a -> ByteString -> a
+ RIO.ByteString: foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
- RIO.ByteString: foldr :: () => (Word8 -> a -> a) -> a -> ByteString -> a
+ RIO.ByteString: foldr :: (Word8 -> a -> a) -> a -> ByteString -> a
- RIO.ByteString: foldr' :: () => (Word8 -> a -> a) -> a -> ByteString -> a
+ RIO.ByteString: foldr' :: (Word8 -> a -> a) -> a -> ByteString -> a
- RIO.ByteString: mapAccumL :: () => (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
+ RIO.ByteString: mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- RIO.ByteString: mapAccumR :: () => (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
+ RIO.ByteString: mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- RIO.ByteString: unfoldr :: () => (a -> Maybe (Word8, a)) -> a -> ByteString
+ RIO.ByteString: unfoldr :: (a -> Maybe (Word8, a)) -> a -> ByteString
- RIO.ByteString: unfoldrN :: () => Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a)
+ RIO.ByteString: unfoldrN :: Int -> (a -> Maybe (Word8, a)) -> a -> (ByteString, Maybe a)
- RIO.ByteString: zipWith :: () => (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
+ RIO.ByteString: zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
- RIO.ByteString.Lazy: foldl :: () => (a -> Word8 -> a) -> a -> ByteString -> a
+ RIO.ByteString.Lazy: foldl :: (a -> Word8 -> a) -> a -> ByteString -> a
- RIO.ByteString.Lazy: foldl' :: () => (a -> Word8 -> a) -> a -> ByteString -> a
+ RIO.ByteString.Lazy: foldl' :: (a -> Word8 -> a) -> a -> ByteString -> a
- RIO.ByteString.Lazy: foldlChunks :: () => (a -> ByteString -> a) -> a -> ByteString -> a
+ RIO.ByteString.Lazy: foldlChunks :: (a -> ByteString -> a) -> a -> ByteString -> a
- RIO.ByteString.Lazy: foldr :: () => (Word8 -> a -> a) -> a -> ByteString -> a
+ RIO.ByteString.Lazy: foldr :: (Word8 -> a -> a) -> a -> ByteString -> a
- RIO.ByteString.Lazy: foldrChunks :: () => (ByteString -> a -> a) -> a -> ByteString -> a
+ RIO.ByteString.Lazy: foldrChunks :: (ByteString -> a -> a) -> a -> ByteString -> a
- RIO.ByteString.Lazy: mapAccumL :: () => (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
+ RIO.ByteString.Lazy: mapAccumL :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- RIO.ByteString.Lazy: mapAccumR :: () => (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
+ RIO.ByteString.Lazy: mapAccumR :: (acc -> Word8 -> (acc, Word8)) -> acc -> ByteString -> (acc, ByteString)
- RIO.ByteString.Lazy: unfoldr :: () => (a -> Maybe (Word8, a)) -> a -> ByteString
+ RIO.ByteString.Lazy: unfoldr :: (a -> Maybe (Word8, a)) -> a -> ByteString
- RIO.ByteString.Lazy: zipWith :: () => (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
+ RIO.ByteString.Lazy: zipWith :: (Word8 -> Word8 -> a) -> ByteString -> ByteString -> [a]
- RIO.HashMap: elems :: () => HashMap k v -> [v]
+ RIO.HashMap: elems :: HashMap k v -> [v]
- RIO.HashMap: empty :: () => HashMap k v
+ RIO.HashMap: empty :: HashMap k v
- RIO.HashMap: filter :: () => (v -> Bool) -> HashMap k v -> HashMap k v
+ RIO.HashMap: filter :: (v -> Bool) -> HashMap k v -> HashMap k v
- RIO.HashMap: filterWithKey :: () => (k -> v -> Bool) -> HashMap k v -> HashMap k v
+ RIO.HashMap: filterWithKey :: (k -> v -> Bool) -> HashMap k v -> HashMap k v
- RIO.HashMap: foldl' :: () => (a -> v -> a) -> a -> HashMap k v -> a
+ RIO.HashMap: foldl' :: (a -> v -> a) -> a -> HashMap k v -> a
- RIO.HashMap: foldlWithKey' :: () => (a -> k -> v -> a) -> a -> HashMap k v -> a
+ RIO.HashMap: foldlWithKey' :: (a -> k -> v -> a) -> a -> HashMap k v -> a
- RIO.HashMap: foldr :: () => (v -> a -> a) -> a -> HashMap k v -> a
+ RIO.HashMap: foldr :: (v -> a -> a) -> a -> HashMap k v -> a
- RIO.HashMap: foldrWithKey :: () => (k -> v -> a -> a) -> a -> HashMap k v -> a
+ RIO.HashMap: foldrWithKey :: (k -> v -> a -> a) -> a -> HashMap k v -> a
- RIO.HashMap: keys :: () => HashMap k v -> [k]
+ RIO.HashMap: keys :: HashMap k v -> [k]
- RIO.HashMap: map :: () => (v1 -> v2) -> HashMap k v1 -> HashMap k v2
+ RIO.HashMap: map :: (v1 -> v2) -> HashMap k v1 -> HashMap k v2
- RIO.HashMap: mapMaybe :: () => (v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
+ RIO.HashMap: mapMaybe :: (v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
- RIO.HashMap: mapMaybeWithKey :: () => (k -> v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
+ RIO.HashMap: mapMaybeWithKey :: (k -> v1 -> Maybe v2) -> HashMap k v1 -> HashMap k v2
- RIO.HashMap: mapWithKey :: () => (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
+ RIO.HashMap: mapWithKey :: (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2
- RIO.HashMap: null :: () => HashMap k v -> Bool
+ RIO.HashMap: null :: HashMap k v -> Bool
- RIO.HashMap: size :: () => HashMap k v -> Int
+ RIO.HashMap: size :: HashMap k v -> Int
- RIO.HashMap: toList :: () => HashMap k v -> [(k, v)]
+ RIO.HashMap: toList :: HashMap k v -> [(k, v)]
- RIO.HashSet: empty :: () => HashSet a
+ RIO.HashSet: empty :: HashSet a
- RIO.HashSet: filter :: () => (a -> Bool) -> HashSet a -> HashSet a
+ RIO.HashSet: filter :: (a -> Bool) -> HashSet a -> HashSet a
- RIO.HashSet: foldl' :: () => (a -> b -> a) -> a -> HashSet b -> a
+ RIO.HashSet: foldl' :: (a -> b -> a) -> a -> HashSet b -> a
- RIO.HashSet: foldr :: () => (b -> a -> a) -> a -> HashSet b -> a
+ RIO.HashSet: foldr :: (b -> a -> a) -> a -> HashSet b -> a
- RIO.HashSet: fromMap :: () => HashMap a () -> HashSet a
+ RIO.HashSet: fromMap :: HashMap a () -> HashSet a
- RIO.HashSet: null :: () => HashSet a -> Bool
+ RIO.HashSet: null :: HashSet a -> Bool
- RIO.HashSet: size :: () => HashSet a -> Int
+ RIO.HashSet: size :: HashSet a -> Int
- RIO.HashSet: toList :: () => HashSet a -> [a]
+ RIO.HashSet: toList :: HashSet a -> [a]
- RIO.HashSet: toMap :: () => HashSet a -> HashMap a ()
+ RIO.HashSet: toMap :: HashSet a -> HashMap a ()
- RIO.Lens: _Just :: () => Traversal (Maybe a) (Maybe a') a a'
+ RIO.Lens: _Just :: Traversal (Maybe a) (Maybe a') a a'
- RIO.Lens: _Left :: () => Traversal (Either a b) (Either a' b) a a'
+ RIO.Lens: _Left :: Traversal (Either a b) (Either a' b) a a'
- RIO.Lens: _Nothing :: () => Traversal' (Maybe a) ()
+ RIO.Lens: _Nothing :: Traversal' (Maybe a) ()
- RIO.Lens: _Right :: () => Traversal (Either a b) (Either a b') b b'
+ RIO.Lens: _Right :: Traversal (Either a b) (Either a b') b b'
- RIO.Lens: both :: () => Traversal (a, a) (b, b) a b
+ RIO.Lens: both :: Traversal (a, a) (b, b) a b
- RIO.Lens: failing :: () => Traversal s t a b -> Traversal s t a b -> Traversal s t a b
+ RIO.Lens: failing :: Traversal s t a b -> Traversal s t a b -> Traversal s t a b
- RIO.Lens: filtered :: () => (a -> Bool) -> Traversal' a a
+ RIO.Lens: filtered :: (a -> Bool) -> Traversal' a a
- RIO.Lens: has :: () => Getting Any s a -> s -> Bool
+ RIO.Lens: has :: Getting Any s a -> s -> Bool
- RIO.Lens: lens :: () => (s -> a) -> (s -> b -> t) -> Lens s t a b
+ RIO.Lens: lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
- RIO.Lens: toListOf :: () => Getting (Endo [a]) s a -> s -> [a]
+ RIO.Lens: toListOf :: Getting (Endo [a]) s a -> s -> [a]
- RIO.Lens: traversed :: Traversable f => Traversal (f a) (f b) a b
+ RIO.Lens: traversed :: forall (f :: Type -> Type) a b. Traversable f => Traversal (f a) (f b) a b
- RIO.List: (++) :: () => [a] -> [a] -> [a]
+ RIO.List: (++) :: [a] -> [a] -> [a]
- RIO.List: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ RIO.List: break :: (a -> Bool) -> [a] -> ([a], [a])
- RIO.List: cycle :: () => [a] -> [a]
+ RIO.List: cycle :: [a] -> [a]
- RIO.List: deleteBy :: () => (a -> a -> Bool) -> a -> [a] -> [a]
+ RIO.List: deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- RIO.List: deleteFirstsBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ RIO.List: deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- RIO.List: drop :: () => Int -> [a] -> [a]
+ RIO.List: drop :: Int -> [a] -> [a]
- RIO.List: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ RIO.List: dropWhile :: (a -> Bool) -> [a] -> [a]
- RIO.List: dropWhileEnd :: () => (a -> Bool) -> [a] -> [a]
+ RIO.List: dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- RIO.List: filter :: () => (a -> Bool) -> [a] -> [a]
+ RIO.List: filter :: (a -> Bool) -> [a] -> [a]
- RIO.List: findIndex :: () => (a -> Bool) -> [a] -> Maybe Int
+ RIO.List: findIndex :: (a -> Bool) -> [a] -> Maybe Int
- RIO.List: findIndices :: () => (a -> Bool) -> [a] -> [Int]
+ RIO.List: findIndices :: (a -> Bool) -> [a] -> [Int]
- RIO.List: groupBy :: () => (a -> a -> Bool) -> [a] -> [[a]]
+ RIO.List: groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- RIO.List: inits :: () => [a] -> [[a]]
+ RIO.List: inits :: [a] -> [[a]]
- RIO.List: insertBy :: () => (a -> a -> Ordering) -> a -> [a] -> [a]
+ RIO.List: insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- RIO.List: intercalate :: () => [a] -> [[a]] -> [a]
+ RIO.List: intercalate :: [a] -> [[a]] -> [a]
- RIO.List: intersectBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ RIO.List: intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- RIO.List: intersperse :: () => a -> [a] -> [a]
+ RIO.List: intersperse :: a -> [a] -> [a]
- RIO.List: iterate :: () => (a -> a) -> a -> [a]
+ RIO.List: iterate :: (a -> a) -> a -> [a]
- RIO.List: map :: () => (a -> b) -> [a] -> [b]
+ RIO.List: map :: (a -> b) -> [a] -> [b]
- RIO.List: nubBy :: () => (a -> a -> Bool) -> [a] -> [a]
+ RIO.List: nubBy :: (a -> a -> Bool) -> [a] -> [a]
- RIO.List: partition :: () => (a -> Bool) -> [a] -> ([a], [a])
+ RIO.List: partition :: (a -> Bool) -> [a] -> ([a], [a])
- RIO.List: permutations :: () => [a] -> [[a]]
+ RIO.List: permutations :: [a] -> [[a]]
- RIO.List: repeat :: () => a -> [a]
+ RIO.List: repeat :: a -> [a]
- RIO.List: replicate :: () => Int -> a -> [a]
+ RIO.List: replicate :: Int -> a -> [a]
- RIO.List: reverse :: () => [a] -> [a]
+ RIO.List: reverse :: [a] -> [a]
- RIO.List: scanl :: () => (b -> a -> b) -> b -> [a] -> [b]
+ RIO.List: scanl :: (b -> a -> b) -> b -> [a] -> [b]
- RIO.List: scanl' :: () => (b -> a -> b) -> b -> [a] -> [b]
+ RIO.List: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- RIO.List: scanl1 :: () => (a -> a -> a) -> [a] -> [a]
+ RIO.List: scanl1 :: (a -> a -> a) -> [a] -> [a]
- RIO.List: scanr :: () => (a -> b -> b) -> b -> [a] -> [b]
+ RIO.List: scanr :: (a -> b -> b) -> b -> [a] -> [b]
- RIO.List: scanr1 :: () => (a -> a -> a) -> [a] -> [a]
+ RIO.List: scanr1 :: (a -> a -> a) -> [a] -> [a]
- RIO.List: sortBy :: () => (a -> a -> Ordering) -> [a] -> [a]
+ RIO.List: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- RIO.List: span :: () => (a -> Bool) -> [a] -> ([a], [a])
+ RIO.List: span :: (a -> Bool) -> [a] -> ([a], [a])
- RIO.List: splitAt :: () => Int -> [a] -> ([a], [a])
+ RIO.List: splitAt :: Int -> [a] -> ([a], [a])
- RIO.List: subsequences :: () => [a] -> [[a]]
+ RIO.List: subsequences :: [a] -> [[a]]
- RIO.List: tails :: () => [a] -> [[a]]
+ RIO.List: tails :: [a] -> [[a]]
- RIO.List: take :: () => Int -> [a] -> [a]
+ RIO.List: take :: Int -> [a] -> [a]
- RIO.List: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ RIO.List: takeWhile :: (a -> Bool) -> [a] -> [a]
- RIO.List: transpose :: () => [[a]] -> [[a]]
+ RIO.List: transpose :: [[a]] -> [[a]]
- RIO.List: uncons :: () => [a] -> Maybe (a, [a])
+ RIO.List: uncons :: [a] -> Maybe (a, [a])
- RIO.List: unfoldr :: () => (b -> Maybe (a, b)) -> b -> [a]
+ RIO.List: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- RIO.List: unionBy :: () => (a -> a -> Bool) -> [a] -> [a] -> [a]
+ RIO.List: unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- RIO.List: unzip :: () => [(a, b)] -> ([a], [b])
+ RIO.List: unzip :: [(a, b)] -> ([a], [b])
- RIO.List: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ RIO.List: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- RIO.List: unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])
+ RIO.List: unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- RIO.List: unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
+ RIO.List: unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- RIO.List: unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
+ RIO.List: unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- RIO.List: unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
+ RIO.List: unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- RIO.List: zip :: () => [a] -> [b] -> [(a, b)]
+ RIO.List: zip :: [a] -> [b] -> [(a, b)]
- RIO.List: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ RIO.List: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- RIO.List: zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
+ RIO.List: zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- RIO.List: zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
+ RIO.List: zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- RIO.List: zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
+ RIO.List: zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- RIO.List: zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
+ RIO.List: zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- RIO.List: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ RIO.List: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- RIO.List: zipWith3 :: () => (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+ RIO.List: zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- RIO.List: zipWith4 :: () => (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
+ RIO.List: zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- RIO.List: zipWith5 :: () => (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
+ RIO.List: zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- RIO.List: zipWith6 :: () => (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
+ RIO.List: zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- RIO.List: zipWith7 :: () => (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
+ RIO.List: zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- RIO.List.Partial: (!!) :: () => [a] -> Int -> a
+ RIO.List.Partial: (!!) :: [a] -> Int -> a
- RIO.List.Partial: foldl1' :: () => (a -> a -> a) -> [a] -> a
+ RIO.List.Partial: foldl1' :: (a -> a -> a) -> [a] -> a
- RIO.List.Partial: head :: () => [a] -> a
+ RIO.List.Partial: head :: [a] -> a
- RIO.List.Partial: init :: () => [a] -> [a]
+ RIO.List.Partial: init :: [a] -> [a]
- RIO.List.Partial: last :: () => [a] -> a
+ RIO.List.Partial: last :: [a] -> a
- RIO.List.Partial: scanl1 :: () => (a -> a -> a) -> [a] -> [a]
+ RIO.List.Partial: scanl1 :: (a -> a -> a) -> [a] -> [a]
- RIO.List.Partial: scanr1 :: () => (a -> a -> a) -> [a] -> [a]
+ RIO.List.Partial: scanr1 :: (a -> a -> a) -> [a] -> [a]
- RIO.List.Partial: tail :: () => [a] -> [a]
+ RIO.List.Partial: tail :: [a] -> [a]
- RIO.Map: assocs :: () => Map k a -> [(k, a)]
+ RIO.Map: assocs :: Map k a -> [(k, a)]
- RIO.Map: deleteAt :: () => Int -> Map k a -> Map k a
+ RIO.Map: deleteAt :: Int -> Map k a -> Map k a
- RIO.Map: deleteMax :: () => Map k a -> Map k a
+ RIO.Map: deleteMax :: Map k a -> Map k a
- RIO.Map: deleteMin :: () => Map k a -> Map k a
+ RIO.Map: deleteMin :: Map k a -> Map k a
- RIO.Map: drop :: () => Int -> Map k a -> Map k a
+ RIO.Map: drop :: Int -> Map k a -> Map k a
- RIO.Map: dropWhileAntitone :: () => (k -> Bool) -> Map k a -> Map k a
+ RIO.Map: dropWhileAntitone :: (k -> Bool) -> Map k a -> Map k a
- RIO.Map: elemAt :: () => Int -> Map k a -> (k, a)
+ RIO.Map: elemAt :: Int -> Map k a -> (k, a)
- RIO.Map: elems :: () => Map k a -> [a]
+ RIO.Map: elems :: Map k a -> [a]
- RIO.Map: empty :: () => Map k a
+ RIO.Map: empty :: Map k a
- RIO.Map: filter :: () => (a -> Bool) -> Map k a -> Map k a
+ RIO.Map: filter :: (a -> Bool) -> Map k a -> Map k a
- RIO.Map: filterWithKey :: () => (k -> a -> Bool) -> Map k a -> Map k a
+ RIO.Map: filterWithKey :: (k -> a -> Bool) -> Map k a -> Map k a
- RIO.Map: foldl :: () => (a -> b -> a) -> a -> Map k b -> a
+ RIO.Map: foldl :: (a -> b -> a) -> a -> Map k b -> a
- RIO.Map: foldl' :: () => (a -> b -> a) -> a -> Map k b -> a
+ RIO.Map: foldl' :: (a -> b -> a) -> a -> Map k b -> a
- RIO.Map: foldlWithKey :: () => (a -> k -> b -> a) -> a -> Map k b -> a
+ RIO.Map: foldlWithKey :: (a -> k -> b -> a) -> a -> Map k b -> a
- RIO.Map: foldlWithKey' :: () => (a -> k -> b -> a) -> a -> Map k b -> a
+ RIO.Map: foldlWithKey' :: (a -> k -> b -> a) -> a -> Map k b -> a
- RIO.Map: foldr :: () => (a -> b -> b) -> b -> Map k a -> b
+ RIO.Map: foldr :: (a -> b -> b) -> b -> Map k a -> b
- RIO.Map: foldr' :: () => (a -> b -> b) -> b -> Map k a -> b
+ RIO.Map: foldr' :: (a -> b -> b) -> b -> Map k a -> b
- RIO.Map: foldrWithKey :: () => (k -> a -> b -> b) -> b -> Map k a -> b
+ RIO.Map: foldrWithKey :: (k -> a -> b -> b) -> b -> Map k a -> b
- RIO.Map: foldrWithKey' :: () => (k -> a -> b -> b) -> b -> Map k a -> b
+ RIO.Map: foldrWithKey' :: (k -> a -> b -> b) -> b -> Map k a -> b
- RIO.Map: fromSet :: () => (k -> a) -> Set k -> Map k a
+ RIO.Map: fromSet :: (k -> a) -> Set k -> Map k a
- RIO.Map: keys :: () => Map k a -> [k]
+ RIO.Map: keys :: Map k a -> [k]
- RIO.Map: keysSet :: () => Map k a -> Set k
+ RIO.Map: keysSet :: Map k a -> Set k
- RIO.Map: lookupMax :: () => Map k a -> Maybe (k, a)
+ RIO.Map: lookupMax :: Map k a -> Maybe (k, a)
- RIO.Map: lookupMin :: () => Map k a -> Maybe (k, a)
+ RIO.Map: lookupMin :: Map k a -> Maybe (k, a)
- RIO.Map: map :: () => (a -> b) -> Map k a -> Map k b
+ RIO.Map: map :: (a -> b) -> Map k a -> Map k b
- RIO.Map: mapAccum :: () => (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
+ RIO.Map: mapAccum :: (a -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
- RIO.Map: mapAccumRWithKey :: () => (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
+ RIO.Map: mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
- RIO.Map: mapAccumWithKey :: () => (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
+ RIO.Map: mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)
- RIO.Map: mapEither :: () => (a -> Either b c) -> Map k a -> (Map k b, Map k c)
+ RIO.Map: mapEither :: (a -> Either b c) -> Map k a -> (Map k b, Map k c)
- RIO.Map: mapEitherWithKey :: () => (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
+ RIO.Map: mapEitherWithKey :: (k -> a -> Either b c) -> Map k a -> (Map k b, Map k c)
- RIO.Map: mapMaybe :: () => (a -> Maybe b) -> Map k a -> Map k b
+ RIO.Map: mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b
- RIO.Map: mapMaybeWithKey :: () => (k -> a -> Maybe b) -> Map k a -> Map k b
+ RIO.Map: mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b
- RIO.Map: mapWithKey :: () => (k -> a -> b) -> Map k a -> Map k b
+ RIO.Map: mapWithKey :: (k -> a -> b) -> Map k a -> Map k b
- RIO.Map: maxView :: () => Map k a -> Maybe (a, Map k a)
+ RIO.Map: maxView :: Map k a -> Maybe (a, Map k a)
- RIO.Map: maxViewWithKey :: () => Map k a -> Maybe ((k, a), Map k a)
+ RIO.Map: maxViewWithKey :: Map k a -> Maybe ((k, a), Map k a)
- RIO.Map: minView :: () => Map k a -> Maybe (a, Map k a)
+ RIO.Map: minView :: Map k a -> Maybe (a, Map k a)
- RIO.Map: minViewWithKey :: () => Map k a -> Maybe ((k, a), Map k a)
+ RIO.Map: minViewWithKey :: Map k a -> Maybe ((k, a), Map k a)
- RIO.Map: null :: () => Map k a -> Bool
+ RIO.Map: null :: Map k a -> Bool
- RIO.Map: partition :: () => (a -> Bool) -> Map k a -> (Map k a, Map k a)
+ RIO.Map: partition :: (a -> Bool) -> Map k a -> (Map k a, Map k a)
- RIO.Map: partitionWithKey :: () => (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
+ RIO.Map: partitionWithKey :: (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
- RIO.Map: singleton :: () => k -> a -> Map k a
+ RIO.Map: singleton :: k -> a -> Map k a
- RIO.Map: size :: () => Map k a -> Int
+ RIO.Map: size :: Map k a -> Int
- RIO.Map: spanAntitone :: () => (k -> Bool) -> Map k a -> (Map k a, Map k a)
+ RIO.Map: spanAntitone :: (k -> Bool) -> Map k a -> (Map k a, Map k a)
- RIO.Map: splitAt :: () => Int -> Map k a -> (Map k a, Map k a)
+ RIO.Map: splitAt :: Int -> Map k a -> (Map k a, Map k a)
- RIO.Map: splitRoot :: () => Map k b -> [Map k b]
+ RIO.Map: splitRoot :: Map k b -> [Map k b]
- RIO.Map: take :: () => Int -> Map k a -> Map k a
+ RIO.Map: take :: Int -> Map k a -> Map k a
- RIO.Map: takeWhileAntitone :: () => (k -> Bool) -> Map k a -> Map k a
+ RIO.Map: takeWhileAntitone :: (k -> Bool) -> Map k a -> Map k a
- RIO.Map: toAscList :: () => Map k a -> [(k, a)]
+ RIO.Map: toAscList :: Map k a -> [(k, a)]
- RIO.Map: toDescList :: () => Map k a -> [(k, a)]
+ RIO.Map: toDescList :: Map k a -> [(k, a)]
- RIO.Map: toList :: () => Map k a -> [(k, a)]
+ RIO.Map: toList :: Map k a -> [(k, a)]
- RIO.Map: updateMax :: () => (a -> Maybe a) -> Map k a -> Map k a
+ RIO.Map: updateMax :: (a -> Maybe a) -> Map k a -> Map k a
- RIO.Map: updateMaxWithKey :: () => (k -> a -> Maybe a) -> Map k a -> Map k a
+ RIO.Map: updateMaxWithKey :: (k -> a -> Maybe a) -> Map k a -> Map k a
- RIO.Map: updateMin :: () => (a -> Maybe a) -> Map k a -> Map k a
+ RIO.Map: updateMin :: (a -> Maybe a) -> Map k a -> Map k a
- RIO.Map: updateMinWithKey :: () => (k -> a -> Maybe a) -> Map k a -> Map k a
+ RIO.Map: updateMinWithKey :: (k -> a -> Maybe a) -> Map k a -> Map k a
- RIO.Map.Partial: deleteAt :: () => Int -> Map k a -> Map k a
+ RIO.Map.Partial: deleteAt :: Int -> Map k a -> Map k a
- RIO.Map.Partial: deleteFindMax :: () => Map k a -> ((k, a), Map k a)
+ RIO.Map.Partial: deleteFindMax :: Map k a -> ((k, a), Map k a)
- RIO.Map.Partial: deleteFindMin :: () => Map k a -> ((k, a), Map k a)
+ RIO.Map.Partial: deleteFindMin :: Map k a -> ((k, a), Map k a)
- RIO.Map.Partial: elemAt :: () => Int -> Map k a -> (k, a)
+ RIO.Map.Partial: elemAt :: Int -> Map k a -> (k, a)
- RIO.Map.Partial: findMax :: () => Map k a -> (k, a)
+ RIO.Map.Partial: findMax :: Map k a -> (k, a)
- RIO.Map.Partial: findMin :: () => Map k a -> (k, a)
+ RIO.Map.Partial: findMin :: Map k a -> (k, a)
- RIO.Map.Partial: updateAt :: () => (k -> a -> Maybe a) -> Int -> Map k a -> Map k a
+ RIO.Map.Partial: updateAt :: (k -> a -> Maybe a) -> Int -> Map k a -> Map k a
- RIO.Map.Unchecked: fromDistinctAscList :: () => [(k, a)] -> Map k a
+ RIO.Map.Unchecked: fromDistinctAscList :: [(k, a)] -> Map k a
- RIO.Map.Unchecked: fromDistinctDescList :: () => [(k, a)] -> Map k a
+ RIO.Map.Unchecked: fromDistinctDescList :: [(k, a)] -> Map k a
- RIO.Map.Unchecked: mapKeysMonotonic :: () => (k1 -> k2) -> Map k1 a -> Map k2 a
+ RIO.Map.Unchecked: mapKeysMonotonic :: (k1 -> k2) -> Map k1 a -> Map k2 a
- RIO.Map.Unchecked: toAscList :: () => Map k a -> [(k, a)]
+ RIO.Map.Unchecked: toAscList :: Map k a -> [(k, a)]
- RIO.Map.Unchecked: toDescList :: () => Map k a -> [(k, a)]
+ RIO.Map.Unchecked: toDescList :: Map k a -> [(k, a)]
- RIO.NonEmpty: (<|) :: () => a -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: (<|) :: a -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: break :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ RIO.NonEmpty: break :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- RIO.NonEmpty: cons :: () => a -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: cons :: a -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: cycle :: () => NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: cycle :: NonEmpty a -> NonEmpty a
- RIO.NonEmpty: drop :: () => Int -> NonEmpty a -> [a]
+ RIO.NonEmpty: drop :: Int -> NonEmpty a -> [a]
- RIO.NonEmpty: dropWhile :: () => (a -> Bool) -> NonEmpty a -> [a]
+ RIO.NonEmpty: dropWhile :: (a -> Bool) -> NonEmpty a -> [a]
- RIO.NonEmpty: filter :: () => (a -> Bool) -> NonEmpty a -> [a]
+ RIO.NonEmpty: filter :: (a -> Bool) -> NonEmpty a -> [a]
- RIO.NonEmpty: groupBy1 :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
+ RIO.NonEmpty: groupBy1 :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty (NonEmpty a)
- RIO.NonEmpty: head :: () => NonEmpty a -> a
+ RIO.NonEmpty: head :: NonEmpty a -> a
- RIO.NonEmpty: init :: () => NonEmpty a -> [a]
+ RIO.NonEmpty: init :: NonEmpty a -> [a]
- RIO.NonEmpty: intersperse :: () => a -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: intersperse :: a -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: iterate :: () => (a -> a) -> a -> NonEmpty a
+ RIO.NonEmpty: iterate :: (a -> a) -> a -> NonEmpty a
- RIO.NonEmpty: last :: () => NonEmpty a -> a
+ RIO.NonEmpty: last :: NonEmpty a -> a
- RIO.NonEmpty: length :: () => NonEmpty a -> Int
+ RIO.NonEmpty: length :: NonEmpty a -> Int
- RIO.NonEmpty: map :: () => (a -> b) -> NonEmpty a -> NonEmpty b
+ RIO.NonEmpty: map :: (a -> b) -> NonEmpty a -> NonEmpty b
- RIO.NonEmpty: nonEmpty :: () => [a] -> Maybe (NonEmpty a)
+ RIO.NonEmpty: nonEmpty :: [a] -> Maybe (NonEmpty a)
- RIO.NonEmpty: nubBy :: () => (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: nubBy :: (a -> a -> Bool) -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: partition :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ RIO.NonEmpty: partition :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- RIO.NonEmpty: repeat :: () => a -> NonEmpty a
+ RIO.NonEmpty: repeat :: a -> NonEmpty a
- RIO.NonEmpty: reverse :: () => NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: reverse :: NonEmpty a -> NonEmpty a
- RIO.NonEmpty: scanl1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: scanl1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: scanr1 :: () => (a -> a -> a) -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: scanr1 :: (a -> a -> a) -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: sortBy :: () => (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
+ RIO.NonEmpty: sortBy :: (a -> a -> Ordering) -> NonEmpty a -> NonEmpty a
- RIO.NonEmpty: span :: () => (a -> Bool) -> NonEmpty a -> ([a], [a])
+ RIO.NonEmpty: span :: (a -> Bool) -> NonEmpty a -> ([a], [a])
- RIO.NonEmpty: splitAt :: () => Int -> NonEmpty a -> ([a], [a])
+ RIO.NonEmpty: splitAt :: Int -> NonEmpty a -> ([a], [a])
- RIO.NonEmpty: tail :: () => NonEmpty a -> [a]
+ RIO.NonEmpty: tail :: NonEmpty a -> [a]
- RIO.NonEmpty: take :: () => Int -> NonEmpty a -> [a]
+ RIO.NonEmpty: take :: Int -> NonEmpty a -> [a]
- RIO.NonEmpty: takeWhile :: () => (a -> Bool) -> NonEmpty a -> [a]
+ RIO.NonEmpty: takeWhile :: (a -> Bool) -> NonEmpty a -> [a]
- RIO.NonEmpty: toList :: () => NonEmpty a -> [a]
+ RIO.NonEmpty: toList :: NonEmpty a -> [a]
- RIO.NonEmpty: transpose :: () => NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
+ RIO.NonEmpty: transpose :: NonEmpty (NonEmpty a) -> NonEmpty (NonEmpty a)
- RIO.NonEmpty: uncons :: () => NonEmpty a -> (a, Maybe (NonEmpty a))
+ RIO.NonEmpty: uncons :: NonEmpty a -> (a, Maybe (NonEmpty a))
- RIO.NonEmpty: unfoldr :: () => (a -> (b, Maybe a)) -> a -> NonEmpty b
+ RIO.NonEmpty: unfoldr :: (a -> (b, Maybe a)) -> a -> NonEmpty b
- RIO.NonEmpty: zip :: () => NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
+ RIO.NonEmpty: zip :: NonEmpty a -> NonEmpty b -> NonEmpty (a, b)
- RIO.NonEmpty: zipWith :: () => (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
+ RIO.NonEmpty: zipWith :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c
- RIO.NonEmpty.Partial: (!!) :: () => NonEmpty a -> Int -> a
+ RIO.NonEmpty.Partial: (!!) :: NonEmpty a -> Int -> a
- RIO.NonEmpty.Partial: fromList :: () => [a] -> NonEmpty a
+ RIO.NonEmpty.Partial: fromList :: [a] -> NonEmpty a
- RIO.Partial: fromJust :: () => Maybe a -> a
+ RIO.Partial: fromJust :: HasCallStack => Maybe a -> a
- RIO.Prelude: ($!) :: () => (a -> b) -> a -> b
+ RIO.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- RIO.Prelude: ($) :: () => (a -> b) -> a -> b
+ RIO.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- RIO.Prelude: (&) :: () => a -> (a -> b) -> b
+ RIO.Prelude: (&) :: a -> (a -> b) -> b
- RIO.Prelude: (++) :: () => [a] -> [a] -> [a]
+ RIO.Prelude: (++) :: [a] -> [a] -> [a]
- RIO.Prelude: (.) :: () => (b -> c) -> (a -> b) -> a -> c
+ RIO.Prelude: (.) :: (b -> c) -> (a -> b) -> a -> c
- RIO.Prelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c
+ RIO.Prelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- RIO.Prelude: absurd :: () => Void -> a
+ RIO.Prelude: absurd :: Void -> a
- RIO.Prelude: asTypeOf :: () => a -> a -> a
+ RIO.Prelude: asTypeOf :: a -> a -> a
- RIO.Prelude: bool :: () => a -> a -> Bool -> a
+ RIO.Prelude: bool :: a -> a -> Bool -> a
- RIO.Prelude: break :: () => (a -> Bool) -> [a] -> ([a], [a])
+ RIO.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])
- RIO.Prelude: catMaybes :: () => [Maybe a] -> [a]
+ RIO.Prelude: catMaybes :: [Maybe a] -> [a]
- RIO.Prelude: const :: () => a -> b -> a
+ RIO.Prelude: const :: a -> b -> a
- RIO.Prelude: curry :: () => ((a, b) -> c) -> a -> b -> c
+ RIO.Prelude: curry :: ((a, b) -> c) -> a -> b -> c
- RIO.Prelude: drop :: () => Int -> [a] -> [a]
+ RIO.Prelude: drop :: Int -> [a] -> [a]
- RIO.Prelude: dropWhile :: () => (a -> Bool) -> [a] -> [a]
+ RIO.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]
- RIO.Prelude: either :: () => (a -> c) -> (b -> c) -> Either a b -> c
+ RIO.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- RIO.Prelude: error :: HasCallStack => [Char] -> a
+ RIO.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- RIO.Prelude: fail :: Monad m => String -> m a
+ RIO.Prelude: fail :: MonadFail m => String -> m a
- RIO.Prelude: filter :: () => (a -> Bool) -> [a] -> [a]
+ RIO.Prelude: filter :: (a -> Bool) -> [a] -> [a]
- RIO.Prelude: fix :: () => (a -> a) -> a
+ RIO.Prelude: fix :: (a -> a) -> a
- RIO.Prelude: flip :: () => (a -> b -> c) -> b -> a -> c
+ RIO.Prelude: flip :: (a -> b -> c) -> b -> a -> c
- RIO.Prelude: fromLeft :: () => a -> Either a b -> a
+ RIO.Prelude: fromLeft :: a -> Either a b -> a
- RIO.Prelude: fromMaybe :: () => a -> Maybe a -> a
+ RIO.Prelude: fromMaybe :: a -> Maybe a -> a
- RIO.Prelude: fromRight :: () => b -> Either a b -> b
+ RIO.Prelude: fromRight :: b -> Either a b -> b
- RIO.Prelude: fst :: () => (a, b) -> a
+ RIO.Prelude: fst :: (a, b) -> a
- RIO.Prelude: id :: () => a -> a
+ RIO.Prelude: id :: a -> a
- RIO.Prelude: isJust :: () => Maybe a -> Bool
+ RIO.Prelude: isJust :: Maybe a -> Bool
- RIO.Prelude: isLeft :: () => Either a b -> Bool
+ RIO.Prelude: isLeft :: Either a b -> Bool
- RIO.Prelude: isNothing :: () => Maybe a -> Bool
+ RIO.Prelude: isNothing :: Maybe a -> Bool
- RIO.Prelude: isRight :: () => Either a b -> Bool
+ RIO.Prelude: isRight :: Either a b -> Bool
- RIO.Prelude: lefts :: () => [Either a b] -> [a]
+ RIO.Prelude: lefts :: [Either a b] -> [a]
- RIO.Prelude: listToMaybe :: () => [a] -> Maybe a
+ RIO.Prelude: listToMaybe :: [a] -> Maybe a
- RIO.Prelude: map :: () => (a -> b) -> [a] -> [b]
+ RIO.Prelude: map :: (a -> b) -> [a] -> [b]
- RIO.Prelude: mapMaybe :: () => (a -> Maybe b) -> [a] -> [b]
+ RIO.Prelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- RIO.Prelude: maybe :: () => b -> (a -> b) -> Maybe a -> b
+ RIO.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b
- RIO.Prelude: maybeToList :: () => Maybe a -> [a]
+ RIO.Prelude: maybeToList :: Maybe a -> [a]
- RIO.Prelude: on :: () => (b -> b -> c) -> (a -> b) -> a -> a -> c
+ RIO.Prelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- RIO.Prelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ RIO.Prelude: partitionEithers :: [Either a b] -> ([a], [b])
- RIO.Prelude: replicate :: () => Int -> a -> [a]
+ RIO.Prelude: replicate :: Int -> a -> [a]
- RIO.Prelude: reverse :: () => [a] -> [a]
+ RIO.Prelude: reverse :: [a] -> [a]
- RIO.Prelude: rights :: () => [Either a b] -> [b]
+ RIO.Prelude: rights :: [Either a b] -> [b]
- RIO.Prelude: runReader :: () => Reader r a -> r -> a
+ RIO.Prelude: runReader :: Reader r a -> r -> a
- RIO.Prelude: runST :: () => (forall s. () => ST s a) -> a
+ RIO.Prelude: runST :: (forall s. () => ST s a) -> a
- RIO.Prelude: seq :: () => a -> b -> b
+ RIO.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- RIO.Prelude: snd :: () => (a, b) -> b
+ RIO.Prelude: snd :: (a, b) -> b
- RIO.Prelude: span :: () => (a -> Bool) -> [a] -> ([a], [a])
+ RIO.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])
- RIO.Prelude: take :: () => Int -> [a] -> [a]
+ RIO.Prelude: take :: Int -> [a] -> [a]
- RIO.Prelude: takeWhile :: () => (a -> Bool) -> [a] -> [a]
+ RIO.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]
- RIO.Prelude: uncurry :: () => (a -> b -> c) -> (a, b) -> c
+ RIO.Prelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- RIO.Prelude: undefined :: HasCallStack => a
+ RIO.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- RIO.Prelude: zip :: () => [a] -> [b] -> [(a, b)]
+ RIO.Prelude: zip :: [a] -> [b] -> [(a, b)]
- RIO.Prelude: zipWith :: () => (a -> b -> c) -> [a] -> [b] -> [c]
+ RIO.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- RIO.Prelude.Types: Const :: a -> Const a
+ RIO.Prelude.Types: Const :: a -> Const a (b :: k)
- RIO.Prelude.Types: Proxy :: Proxy
+ RIO.Prelude.Types: Proxy :: Proxy (t :: k)
- RIO.Prelude.Types: ReaderT :: (r -> m a) -> ReaderT r
+ RIO.Prelude.Types: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- RIO.Prelude.Types: [getConst] :: Const a -> a
+ RIO.Prelude.Types: [getConst] :: Const a (b :: k) -> a
- RIO.Prelude.Types: gmapQr :: Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
+ RIO.Prelude.Types: gmapQr :: forall r r'. Data a => (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r
- RIO.Prelude.Types: type family PrimState (m :: Type -> Type) :: Type;
+ RIO.Prelude.Types: type family PrimState (m :: Type -> Type);
- RIO.Process: byteStringInput :: ByteString -> StreamSpec STInput ()
+ RIO.Process: byteStringInput :: ByteString -> StreamSpec 'STInput ()
- RIO.Process: byteStringOutput :: StreamSpec STOutput (STM ByteString)
+ RIO.Process: byteStringOutput :: StreamSpec 'STOutput (STM ByteString)
- RIO.Process: checkExitCodeSTM :: () => Process stdin stdout stderr -> STM ()
+ RIO.Process: checkExitCodeSTM :: Process stdin stdout stderr -> STM ()
- RIO.Process: closed :: () => StreamSpec anyStreamType ()
+ RIO.Process: closed :: forall (anyStreamType :: StreamType). StreamSpec anyStreamType ()
- RIO.Process: createPipe :: () => StreamSpec anyStreamType Handle
+ RIO.Process: createPipe :: forall (anyStreamType :: StreamType). StreamSpec anyStreamType Handle
- RIO.Process: getExitCodeSTM :: () => Process stdin stdout stderr -> STM (Maybe ExitCode)
+ RIO.Process: getExitCodeSTM :: Process stdin stdout stderr -> STM (Maybe ExitCode)
- RIO.Process: getStderr :: () => Process stdin stdout stderr -> stderr
+ RIO.Process: getStderr :: Process stdin stdout stderr -> stderr
- RIO.Process: getStdin :: () => Process stdin stdout stderr -> stdin
+ RIO.Process: getStdin :: Process stdin stdout stderr -> stdin
- RIO.Process: getStdout :: () => Process stdin stdout stderr -> stdout
+ RIO.Process: getStdout :: Process stdin stdout stderr -> stdout
- RIO.Process: inherit :: () => StreamSpec anyStreamType ()
+ RIO.Process: inherit :: forall (anyStreamType :: StreamType). StreamSpec anyStreamType ()
- RIO.Process: mkStreamSpec :: () => StdStream -> (ProcessConfig () () () -> Maybe Handle -> IO (a, IO ())) -> StreamSpec streamType a
+ RIO.Process: mkStreamSpec :: forall a (streamType :: StreamType). StdStream -> (ProcessConfig () () () -> Maybe Handle -> IO (a, IO ())) -> StreamSpec streamType a
- RIO.Process: setChildGroup :: () => GroupID -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setChildGroup :: GroupID -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setChildUser :: () => UserID -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setChildUser :: UserID -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setCloseFds :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setCloseFds :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setCreateGroup :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setCreateGroup :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setCreateNewConsole :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setCreateNewConsole :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setDelegateCtlc :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setDelegateCtlc :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setDetachConsole :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setDetachConsole :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setNewSession :: () => Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setNewSession :: Bool -> ProcessConfig stdin stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setStderr :: () => StreamSpec STOutput stderr -> ProcessConfig stdin stdout stderr0 -> ProcessConfig stdin stdout stderr
+ RIO.Process: setStderr :: StreamSpec 'STOutput stderr -> ProcessConfig stdin stdout stderr0 -> ProcessConfig stdin stdout stderr
- RIO.Process: setStdin :: () => StreamSpec STInput stdin -> ProcessConfig stdin0 stdout stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setStdin :: StreamSpec 'STInput stdin -> ProcessConfig stdin0 stdout stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: setStdout :: () => StreamSpec STOutput stdout -> ProcessConfig stdin stdout0 stderr -> ProcessConfig stdin stdout stderr
+ RIO.Process: setStdout :: StreamSpec 'STOutput stdout -> ProcessConfig stdin stdout0 stderr -> ProcessConfig stdin stdout stderr
- RIO.Process: unsafeProcessHandle :: () => Process stdin stdout stderr -> ProcessHandle
+ RIO.Process: unsafeProcessHandle :: Process stdin stdout stderr -> ProcessHandle
- RIO.Process: useHandleClose :: () => Handle -> StreamSpec anyStreamType ()
+ RIO.Process: useHandleClose :: forall (anyStreamType :: StreamType). Handle -> StreamSpec anyStreamType ()
- RIO.Process: useHandleOpen :: () => Handle -> StreamSpec anyStreamType ()
+ RIO.Process: useHandleOpen :: forall (anyStreamType :: StreamType). Handle -> StreamSpec anyStreamType ()
- RIO.Process: waitExitCodeSTM :: () => Process stdin stdout stderr -> STM ExitCode
+ RIO.Process: waitExitCodeSTM :: Process stdin stdout stderr -> STM ExitCode
- RIO.Seq: (!?) :: () => Seq a -> Int -> Maybe a
+ RIO.Seq: (!?) :: Seq a -> Int -> Maybe a
- RIO.Seq: (<|) :: () => a -> Seq a -> Seq a
+ RIO.Seq: (<|) :: a -> Seq a -> Seq a
- RIO.Seq: (><) :: () => Seq a -> Seq a -> Seq a
+ RIO.Seq: (><) :: Seq a -> Seq a -> Seq a
- RIO.Seq: (|>) :: () => Seq a -> a -> Seq a
+ RIO.Seq: (|>) :: Seq a -> a -> Seq a
- RIO.Seq: adjust :: () => (a -> a) -> Int -> Seq a -> Seq a
+ RIO.Seq: adjust :: (a -> a) -> Int -> Seq a -> Seq a
- RIO.Seq: adjust' :: () => (a -> a) -> Int -> Seq a -> Seq a
+ RIO.Seq: adjust' :: (a -> a) -> Int -> Seq a -> Seq a
- RIO.Seq: breakl :: () => (a -> Bool) -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: breakl :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
- RIO.Seq: breakr :: () => (a -> Bool) -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: breakr :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
- RIO.Seq: chunksOf :: () => Int -> Seq a -> Seq (Seq a)
+ RIO.Seq: chunksOf :: Int -> Seq a -> Seq (Seq a)
- RIO.Seq: cycleTaking :: () => Int -> Seq a -> Seq a
+ RIO.Seq: cycleTaking :: Int -> Seq a -> Seq a
- RIO.Seq: deleteAt :: () => Int -> Seq a -> Seq a
+ RIO.Seq: deleteAt :: Int -> Seq a -> Seq a
- RIO.Seq: drop :: () => Int -> Seq a -> Seq a
+ RIO.Seq: drop :: Int -> Seq a -> Seq a
- RIO.Seq: dropWhileL :: () => (a -> Bool) -> Seq a -> Seq a
+ RIO.Seq: dropWhileL :: (a -> Bool) -> Seq a -> Seq a
- RIO.Seq: dropWhileR :: () => (a -> Bool) -> Seq a -> Seq a
+ RIO.Seq: dropWhileR :: (a -> Bool) -> Seq a -> Seq a
- RIO.Seq: empty :: () => Seq a
+ RIO.Seq: empty :: Seq a
- RIO.Seq: filter :: () => (a -> Bool) -> Seq a -> Seq a
+ RIO.Seq: filter :: (a -> Bool) -> Seq a -> Seq a
- RIO.Seq: findIndexL :: () => (a -> Bool) -> Seq a -> Maybe Int
+ RIO.Seq: findIndexL :: (a -> Bool) -> Seq a -> Maybe Int
- RIO.Seq: findIndexR :: () => (a -> Bool) -> Seq a -> Maybe Int
+ RIO.Seq: findIndexR :: (a -> Bool) -> Seq a -> Maybe Int
- RIO.Seq: findIndicesL :: () => (a -> Bool) -> Seq a -> [Int]
+ RIO.Seq: findIndicesL :: (a -> Bool) -> Seq a -> [Int]
- RIO.Seq: findIndicesR :: () => (a -> Bool) -> Seq a -> [Int]
+ RIO.Seq: findIndicesR :: (a -> Bool) -> Seq a -> [Int]
- RIO.Seq: foldlWithIndex :: () => (b -> Int -> a -> b) -> b -> Seq a -> b
+ RIO.Seq: foldlWithIndex :: (b -> Int -> a -> b) -> b -> Seq a -> b
- RIO.Seq: foldrWithIndex :: () => (Int -> a -> b -> b) -> b -> Seq a -> b
+ RIO.Seq: foldrWithIndex :: (Int -> a -> b -> b) -> b -> Seq a -> b
- RIO.Seq: fromFunction :: () => Int -> (Int -> a) -> Seq a
+ RIO.Seq: fromFunction :: Int -> (Int -> a) -> Seq a
- RIO.Seq: fromList :: () => [a] -> Seq a
+ RIO.Seq: fromList :: [a] -> Seq a
- RIO.Seq: index :: () => Seq a -> Int -> a
+ RIO.Seq: index :: Seq a -> Int -> a
- RIO.Seq: inits :: () => Seq a -> Seq (Seq a)
+ RIO.Seq: inits :: Seq a -> Seq (Seq a)
- RIO.Seq: insertAt :: () => Int -> a -> Seq a -> Seq a
+ RIO.Seq: insertAt :: Int -> a -> Seq a -> Seq a
- RIO.Seq: intersperse :: () => a -> Seq a -> Seq a
+ RIO.Seq: intersperse :: a -> Seq a -> Seq a
- RIO.Seq: iterateN :: () => Int -> (a -> a) -> a -> Seq a
+ RIO.Seq: iterateN :: Int -> (a -> a) -> a -> Seq a
- RIO.Seq: length :: () => Seq a -> Int
+ RIO.Seq: length :: Seq a -> Int
- RIO.Seq: lookup :: () => Int -> Seq a -> Maybe a
+ RIO.Seq: lookup :: Int -> Seq a -> Maybe a
- RIO.Seq: mapWithIndex :: () => (Int -> a -> b) -> Seq a -> Seq b
+ RIO.Seq: mapWithIndex :: (Int -> a -> b) -> Seq a -> Seq b
- RIO.Seq: null :: () => Seq a -> Bool
+ RIO.Seq: null :: Seq a -> Bool
- RIO.Seq: partition :: () => (a -> Bool) -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: partition :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
- RIO.Seq: replicate :: () => Int -> a -> Seq a
+ RIO.Seq: replicate :: Int -> a -> Seq a
- RIO.Seq: reverse :: () => Seq a -> Seq a
+ RIO.Seq: reverse :: Seq a -> Seq a
- RIO.Seq: scanl :: () => (a -> b -> a) -> a -> Seq b -> Seq a
+ RIO.Seq: scanl :: (a -> b -> a) -> a -> Seq b -> Seq a
- RIO.Seq: scanl1 :: () => (a -> a -> a) -> Seq a -> Seq a
+ RIO.Seq: scanl1 :: (a -> a -> a) -> Seq a -> Seq a
- RIO.Seq: scanr :: () => (a -> b -> b) -> b -> Seq a -> Seq b
+ RIO.Seq: scanr :: (a -> b -> b) -> b -> Seq a -> Seq b
- RIO.Seq: scanr1 :: () => (a -> a -> a) -> Seq a -> Seq a
+ RIO.Seq: scanr1 :: (a -> a -> a) -> Seq a -> Seq a
- RIO.Seq: singleton :: () => a -> Seq a
+ RIO.Seq: singleton :: a -> Seq a
- RIO.Seq: sortBy :: () => (a -> a -> Ordering) -> Seq a -> Seq a
+ RIO.Seq: sortBy :: (a -> a -> Ordering) -> Seq a -> Seq a
- RIO.Seq: spanl :: () => (a -> Bool) -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: spanl :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
- RIO.Seq: spanr :: () => (a -> Bool) -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: spanr :: (a -> Bool) -> Seq a -> (Seq a, Seq a)
- RIO.Seq: splitAt :: () => Int -> Seq a -> (Seq a, Seq a)
+ RIO.Seq: splitAt :: Int -> Seq a -> (Seq a, Seq a)
- RIO.Seq: tails :: () => Seq a -> Seq (Seq a)
+ RIO.Seq: tails :: Seq a -> Seq (Seq a)
- RIO.Seq: take :: () => Int -> Seq a -> Seq a
+ RIO.Seq: take :: Int -> Seq a -> Seq a
- RIO.Seq: takeWhileL :: () => (a -> Bool) -> Seq a -> Seq a
+ RIO.Seq: takeWhileL :: (a -> Bool) -> Seq a -> Seq a
- RIO.Seq: takeWhileR :: () => (a -> Bool) -> Seq a -> Seq a
+ RIO.Seq: takeWhileR :: (a -> Bool) -> Seq a -> Seq a
- RIO.Seq: unfoldl :: () => (b -> Maybe (b, a)) -> b -> Seq a
+ RIO.Seq: unfoldl :: (b -> Maybe (b, a)) -> b -> Seq a
- RIO.Seq: unfoldr :: () => (b -> Maybe (a, b)) -> b -> Seq a
+ RIO.Seq: unfoldr :: (b -> Maybe (a, b)) -> b -> Seq a
- RIO.Seq: unstableSortBy :: () => (a -> a -> Ordering) -> Seq a -> Seq a
+ RIO.Seq: unstableSortBy :: (a -> a -> Ordering) -> Seq a -> Seq a
- RIO.Seq: update :: () => Int -> a -> Seq a -> Seq a
+ RIO.Seq: update :: Int -> a -> Seq a -> Seq a
- RIO.Seq: viewl :: () => Seq a -> ViewL a
+ RIO.Seq: viewl :: Seq a -> ViewL a
- RIO.Seq: viewr :: () => Seq a -> ViewR a
+ RIO.Seq: viewr :: Seq a -> ViewR a
- RIO.Seq: zip :: () => Seq a -> Seq b -> Seq (a, b)
+ RIO.Seq: zip :: Seq a -> Seq b -> Seq (a, b)
- RIO.Seq: zip3 :: () => Seq a -> Seq b -> Seq c -> Seq (a, b, c)
+ RIO.Seq: zip3 :: Seq a -> Seq b -> Seq c -> Seq (a, b, c)
- RIO.Seq: zip4 :: () => Seq a -> Seq b -> Seq c -> Seq d -> Seq (a, b, c, d)
+ RIO.Seq: zip4 :: Seq a -> Seq b -> Seq c -> Seq d -> Seq (a, b, c, d)
- RIO.Seq: zipWith :: () => (a -> b -> c) -> Seq a -> Seq b -> Seq c
+ RIO.Seq: zipWith :: (a -> b -> c) -> Seq a -> Seq b -> Seq c
- RIO.Seq: zipWith3 :: () => (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
+ RIO.Seq: zipWith3 :: (a -> b -> c -> d) -> Seq a -> Seq b -> Seq c -> Seq d
- RIO.Seq: zipWith4 :: () => (a -> b -> c -> d -> e) -> Seq a -> Seq b -> Seq c -> Seq d -> Seq e
+ RIO.Seq: zipWith4 :: (a -> b -> c -> d -> e) -> Seq a -> Seq b -> Seq c -> Seq d -> Seq e
- RIO.Set: deleteMax :: () => Set a -> Set a
+ RIO.Set: deleteMax :: Set a -> Set a
- RIO.Set: deleteMin :: () => Set a -> Set a
+ RIO.Set: deleteMin :: Set a -> Set a
- RIO.Set: drop :: () => Int -> Set a -> Set a
+ RIO.Set: drop :: Int -> Set a -> Set a
- RIO.Set: dropWhileAntitone :: () => (a -> Bool) -> Set a -> Set a
+ RIO.Set: dropWhileAntitone :: (a -> Bool) -> Set a -> Set a
- RIO.Set: elems :: () => Set a -> [a]
+ RIO.Set: elems :: Set a -> [a]
- RIO.Set: empty :: () => Set a
+ RIO.Set: empty :: Set a
- RIO.Set: filter :: () => (a -> Bool) -> Set a -> Set a
+ RIO.Set: filter :: (a -> Bool) -> Set a -> Set a
- RIO.Set: foldl :: () => (a -> b -> a) -> a -> Set b -> a
+ RIO.Set: foldl :: (a -> b -> a) -> a -> Set b -> a
- RIO.Set: foldl' :: () => (a -> b -> a) -> a -> Set b -> a
+ RIO.Set: foldl' :: (a -> b -> a) -> a -> Set b -> a
- RIO.Set: foldr :: () => (a -> b -> b) -> b -> Set a -> b
+ RIO.Set: foldr :: (a -> b -> b) -> b -> Set a -> b
- RIO.Set: foldr' :: () => (a -> b -> b) -> b -> Set a -> b
+ RIO.Set: foldr' :: (a -> b -> b) -> b -> Set a -> b
- RIO.Set: lookupMax :: () => Set a -> Maybe a
+ RIO.Set: lookupMax :: Set a -> Maybe a
- RIO.Set: lookupMin :: () => Set a -> Maybe a
+ RIO.Set: lookupMin :: Set a -> Maybe a
- RIO.Set: maxView :: () => Set a -> Maybe (a, Set a)
+ RIO.Set: maxView :: Set a -> Maybe (a, Set a)
- RIO.Set: minView :: () => Set a -> Maybe (a, Set a)
+ RIO.Set: minView :: Set a -> Maybe (a, Set a)
- RIO.Set: null :: () => Set a -> Bool
+ RIO.Set: null :: Set a -> Bool
- RIO.Set: partition :: () => (a -> Bool) -> Set a -> (Set a, Set a)
+ RIO.Set: partition :: (a -> Bool) -> Set a -> (Set a, Set a)
- RIO.Set: singleton :: () => a -> Set a
+ RIO.Set: singleton :: a -> Set a
- RIO.Set: size :: () => Set a -> Int
+ RIO.Set: size :: Set a -> Int
- RIO.Set: spanAntitone :: () => (a -> Bool) -> Set a -> (Set a, Set a)
+ RIO.Set: spanAntitone :: (a -> Bool) -> Set a -> (Set a, Set a)
- RIO.Set: splitAt :: () => Int -> Set a -> (Set a, Set a)
+ RIO.Set: splitAt :: Int -> Set a -> (Set a, Set a)
- RIO.Set: splitRoot :: () => Set a -> [Set a]
+ RIO.Set: splitRoot :: Set a -> [Set a]
- RIO.Set: take :: () => Int -> Set a -> Set a
+ RIO.Set: take :: Int -> Set a -> Set a
- RIO.Set: takeWhileAntitone :: () => (a -> Bool) -> Set a -> Set a
+ RIO.Set: takeWhileAntitone :: (a -> Bool) -> Set a -> Set a
- RIO.Set: toAscList :: () => Set a -> [a]
+ RIO.Set: toAscList :: Set a -> [a]
- RIO.Set: toDescList :: () => Set a -> [a]
+ RIO.Set: toDescList :: Set a -> [a]
- RIO.Set: toList :: () => Set a -> [a]
+ RIO.Set: toList :: Set a -> [a]
- RIO.Set.Partial: deleteAt :: () => Int -> Set a -> Set a
+ RIO.Set.Partial: deleteAt :: Int -> Set a -> Set a
- RIO.Set.Partial: deleteFindMax :: () => Set a -> (a, Set a)
+ RIO.Set.Partial: deleteFindMax :: Set a -> (a, Set a)
- RIO.Set.Partial: deleteFindMin :: () => Set a -> (a, Set a)
+ RIO.Set.Partial: deleteFindMin :: Set a -> (a, Set a)
- RIO.Set.Partial: elemAt :: () => Int -> Set a -> a
+ RIO.Set.Partial: elemAt :: Int -> Set a -> a
- RIO.Set.Partial: findMax :: () => Set a -> a
+ RIO.Set.Partial: findMax :: Set a -> a
- RIO.Set.Partial: findMin :: () => Set a -> a
+ RIO.Set.Partial: findMin :: Set a -> a
- RIO.Set.Unchecked: fromDistinctAscList :: () => [a] -> Set a
+ RIO.Set.Unchecked: fromDistinctAscList :: [a] -> Set a
- RIO.Set.Unchecked: fromDistinctDescList :: () => [a] -> Set a
+ RIO.Set.Unchecked: fromDistinctDescList :: [a] -> Set a
- RIO.Set.Unchecked: mapMonotonic :: () => (a -> b) -> Set a -> Set b
+ RIO.Set.Unchecked: mapMonotonic :: (a -> b) -> Set a -> Set b
- RIO.State: StateT :: (s -> m (a, s)) -> StateT s a
+ RIO.State: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- RIO.State: [runStateT] :: StateT s a -> s -> m (a, s)
+ RIO.State: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- RIO.State: evalState :: () => State s a -> s -> a
+ RIO.State: evalState :: State s a -> s -> a
- RIO.State: execState :: () => State s a -> s -> s
+ RIO.State: execState :: State s a -> s -> s
- RIO.State: mapState :: () => ((a, s) -> (b, s)) -> State s a -> State s b
+ RIO.State: mapState :: ((a, s) -> (b, s)) -> State s a -> State s b
- RIO.State: mapStateT :: () => (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
+ RIO.State: mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
- RIO.State: runState :: () => State s a -> s -> (a, s)
+ RIO.State: runState :: State s a -> s -> (a, s)
- RIO.State: withState :: () => (s -> s) -> State s a -> State s a
+ RIO.State: withState :: (s -> s) -> State s a -> State s a
- RIO.State: withStateT :: () => (s -> s) -> StateT s m a -> StateT s m a
+ RIO.State: withStateT :: forall s (m :: Type -> Type) a. (s -> s) -> StateT s m a -> StateT s m a
- RIO.Text: foldl :: () => (a -> Char -> a) -> a -> Text -> a
+ RIO.Text: foldl :: (a -> Char -> a) -> a -> Text -> a
- RIO.Text: foldl' :: () => (a -> Char -> a) -> a -> Text -> a
+ RIO.Text: foldl' :: (a -> Char -> a) -> a -> Text -> a
- RIO.Text: foldr :: () => (Char -> a -> a) -> a -> Text -> a
+ RIO.Text: foldr :: (Char -> a -> a) -> a -> Text -> a
- RIO.Text: mapAccumL :: () => (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
+ RIO.Text: mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
- RIO.Text: mapAccumR :: () => (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
+ RIO.Text: mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
- RIO.Text: unfoldr :: () => (a -> Maybe (Char, a)) -> a -> Text
+ RIO.Text: unfoldr :: (a -> Maybe (Char, a)) -> a -> Text
- RIO.Text: unfoldrN :: () => Int -> (a -> Maybe (Char, a)) -> a -> Text
+ RIO.Text: unfoldrN :: Int -> (a -> Maybe (Char, a)) -> a -> Text
- RIO.Text.Lazy: foldl :: () => (a -> Char -> a) -> a -> Text -> a
+ RIO.Text.Lazy: foldl :: (a -> Char -> a) -> a -> Text -> a
- RIO.Text.Lazy: foldl' :: () => (a -> Char -> a) -> a -> Text -> a
+ RIO.Text.Lazy: foldl' :: (a -> Char -> a) -> a -> Text -> a
- RIO.Text.Lazy: foldlChunks :: () => (a -> Text -> a) -> a -> Text -> a
+ RIO.Text.Lazy: foldlChunks :: (a -> Text -> a) -> a -> Text -> a
- RIO.Text.Lazy: foldr :: () => (Char -> a -> a) -> a -> Text -> a
+ RIO.Text.Lazy: foldr :: (Char -> a -> a) -> a -> Text -> a
- RIO.Text.Lazy: foldrChunks :: () => (Text -> a -> a) -> a -> Text -> a
+ RIO.Text.Lazy: foldrChunks :: (Text -> a -> a) -> a -> Text -> a
- RIO.Text.Lazy: mapAccumL :: () => (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
+ RIO.Text.Lazy: mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
- RIO.Text.Lazy: mapAccumR :: () => (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
+ RIO.Text.Lazy: mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)
- RIO.Text.Lazy: unfoldr :: () => (a -> Maybe (Char, a)) -> a -> Text
+ RIO.Text.Lazy: unfoldr :: (a -> Maybe (Char, a)) -> a -> Text
- RIO.Text.Lazy: unfoldrN :: () => Int64 -> (a -> Maybe (Char, a)) -> a -> Text
+ RIO.Text.Lazy: unfoldrN :: Int64 -> (a -> Maybe (Char, a)) -> a -> Text
- RIO.Time: parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
+ RIO.Time: parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- RIO.Vector: streamR :: Vector v a => v a -> Bundle u a
+ RIO.Vector: streamR :: forall v a (u :: Type -> Type). Vector v a => v a -> Bundle u a
- RIO.Vector.Boxed: (!?) :: () => Vector a -> Int -> Maybe a
+ RIO.Vector.Boxed: (!?) :: Vector a -> Int -> Maybe a
- RIO.Vector.Boxed: (++) :: () => Vector a -> Vector a -> Vector a
+ RIO.Vector.Boxed: (++) :: Vector a -> Vector a -> Vector a
- RIO.Vector.Boxed: all :: () => (a -> Bool) -> Vector a -> Bool
+ RIO.Vector.Boxed: all :: (a -> Bool) -> Vector a -> Bool
- RIO.Vector.Boxed: any :: () => (a -> Bool) -> Vector a -> Bool
+ RIO.Vector.Boxed: any :: (a -> Bool) -> Vector a -> Bool
- RIO.Vector.Boxed: break :: () => (a -> Bool) -> Vector a -> (Vector a, Vector a)
+ RIO.Vector.Boxed: break :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
- RIO.Vector.Boxed: concat :: () => [Vector a] -> Vector a
+ RIO.Vector.Boxed: concat :: [Vector a] -> Vector a
- RIO.Vector.Boxed: concatMap :: () => (a -> Vector b) -> Vector a -> Vector b
+ RIO.Vector.Boxed: concatMap :: (a -> Vector b) -> Vector a -> Vector b
- RIO.Vector.Boxed: cons :: () => a -> Vector a -> Vector a
+ RIO.Vector.Boxed: cons :: a -> Vector a -> Vector a
- RIO.Vector.Boxed: constructN :: () => Int -> (Vector a -> a) -> Vector a
+ RIO.Vector.Boxed: constructN :: Int -> (Vector a -> a) -> Vector a
- RIO.Vector.Boxed: constructrN :: () => Int -> (Vector a -> a) -> Vector a
+ RIO.Vector.Boxed: constructrN :: Int -> (Vector a -> a) -> Vector a
- RIO.Vector.Boxed: create :: () => (forall s. () => ST s (MVector s a)) -> Vector a
+ RIO.Vector.Boxed: create :: (forall s. () => ST s (MVector s a)) -> Vector a
- RIO.Vector.Boxed: drop :: () => Int -> Vector a -> Vector a
+ RIO.Vector.Boxed: drop :: Int -> Vector a -> Vector a
- RIO.Vector.Boxed: dropWhile :: () => (a -> Bool) -> Vector a -> Vector a
+ RIO.Vector.Boxed: dropWhile :: (a -> Bool) -> Vector a -> Vector a
- RIO.Vector.Boxed: empty :: () => Vector a
+ RIO.Vector.Boxed: empty :: Vector a
- RIO.Vector.Boxed: filter :: () => (a -> Bool) -> Vector a -> Vector a
+ RIO.Vector.Boxed: filter :: (a -> Bool) -> Vector a -> Vector a
- RIO.Vector.Boxed: find :: () => (a -> Bool) -> Vector a -> Maybe a
+ RIO.Vector.Boxed: find :: (a -> Bool) -> Vector a -> Maybe a
- RIO.Vector.Boxed: findIndex :: () => (a -> Bool) -> Vector a -> Maybe Int
+ RIO.Vector.Boxed: findIndex :: (a -> Bool) -> Vector a -> Maybe Int
- RIO.Vector.Boxed: findIndices :: () => (a -> Bool) -> Vector a -> Vector Int
+ RIO.Vector.Boxed: findIndices :: (a -> Bool) -> Vector a -> Vector Int
- RIO.Vector.Boxed: foldl :: () => (a -> b -> a) -> a -> Vector b -> a
+ RIO.Vector.Boxed: foldl :: (a -> b -> a) -> a -> Vector b -> a
- RIO.Vector.Boxed: foldl' :: () => (a -> b -> a) -> a -> Vector b -> a
+ RIO.Vector.Boxed: foldl' :: (a -> b -> a) -> a -> Vector b -> a
- RIO.Vector.Boxed: foldr :: () => (a -> b -> b) -> b -> Vector a -> b
+ RIO.Vector.Boxed: foldr :: (a -> b -> b) -> b -> Vector a -> b
- RIO.Vector.Boxed: foldr' :: () => (a -> b -> b) -> b -> Vector a -> b
+ RIO.Vector.Boxed: foldr' :: (a -> b -> b) -> b -> Vector a -> b
- RIO.Vector.Boxed: force :: () => Vector a -> Vector a
+ RIO.Vector.Boxed: force :: Vector a -> Vector a
- RIO.Vector.Boxed: fromList :: () => [a] -> Vector a
+ RIO.Vector.Boxed: fromList :: [a] -> Vector a
- RIO.Vector.Boxed: fromListN :: () => Int -> [a] -> Vector a
+ RIO.Vector.Boxed: fromListN :: Int -> [a] -> Vector a
- RIO.Vector.Boxed: generate :: () => Int -> (Int -> a) -> Vector a
+ RIO.Vector.Boxed: generate :: Int -> (Int -> a) -> Vector a
- RIO.Vector.Boxed: ifilter :: () => (Int -> a -> Bool) -> Vector a -> Vector a
+ RIO.Vector.Boxed: ifilter :: (Int -> a -> Bool) -> Vector a -> Vector a
- RIO.Vector.Boxed: ifoldl :: () => (a -> Int -> b -> a) -> a -> Vector b -> a
+ RIO.Vector.Boxed: ifoldl :: (a -> Int -> b -> a) -> a -> Vector b -> a
- RIO.Vector.Boxed: ifoldl' :: () => (a -> Int -> b -> a) -> a -> Vector b -> a
+ RIO.Vector.Boxed: ifoldl' :: (a -> Int -> b -> a) -> a -> Vector b -> a
- RIO.Vector.Boxed: ifoldr :: () => (Int -> a -> b -> b) -> b -> Vector a -> b
+ RIO.Vector.Boxed: ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b
- RIO.Vector.Boxed: ifoldr' :: () => (Int -> a -> b -> b) -> b -> Vector a -> b
+ RIO.Vector.Boxed: ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b
- RIO.Vector.Boxed: imap :: () => (Int -> a -> b) -> Vector a -> Vector b
+ RIO.Vector.Boxed: imap :: (Int -> a -> b) -> Vector a -> Vector b
- RIO.Vector.Boxed: imapMaybe :: () => (Int -> a -> Maybe b) -> Vector a -> Vector b
+ RIO.Vector.Boxed: imapMaybe :: (Int -> a -> Maybe b) -> Vector a -> Vector b
- RIO.Vector.Boxed: indexed :: () => Vector a -> Vector (Int, a)
+ RIO.Vector.Boxed: indexed :: Vector a -> Vector (Int, a)
- RIO.Vector.Boxed: iscanl :: () => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: iscanl :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: iscanl' :: () => (Int -> a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: iscanl' :: (Int -> a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: iscanr :: () => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: iscanr :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: iscanr' :: () => (Int -> a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: iscanr' :: (Int -> a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: iterateN :: () => Int -> (a -> a) -> a -> Vector a
+ RIO.Vector.Boxed: iterateN :: Int -> (a -> a) -> a -> Vector a
- RIO.Vector.Boxed: izipWith :: () => (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
+ RIO.Vector.Boxed: izipWith :: (Int -> a -> b -> c) -> Vector a -> Vector b -> Vector c
- RIO.Vector.Boxed: izipWith3 :: () => (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
+ RIO.Vector.Boxed: izipWith3 :: (Int -> a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- RIO.Vector.Boxed: izipWith4 :: () => (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+ RIO.Vector.Boxed: izipWith4 :: (Int -> a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- RIO.Vector.Boxed: izipWith5 :: () => (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
+ RIO.Vector.Boxed: izipWith5 :: (Int -> a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- RIO.Vector.Boxed: izipWith6 :: () => (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
+ RIO.Vector.Boxed: izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- RIO.Vector.Boxed: length :: () => Vector a -> Int
+ RIO.Vector.Boxed: length :: Vector a -> Int
- RIO.Vector.Boxed: map :: () => (a -> b) -> Vector a -> Vector b
+ RIO.Vector.Boxed: map :: (a -> b) -> Vector a -> Vector b
- RIO.Vector.Boxed: mapMaybe :: () => (a -> Maybe b) -> Vector a -> Vector b
+ RIO.Vector.Boxed: mapMaybe :: (a -> Maybe b) -> Vector a -> Vector b
- RIO.Vector.Boxed: modify :: () => (forall s. () => MVector s a -> ST s ()) -> Vector a -> Vector a
+ RIO.Vector.Boxed: modify :: (forall s. () => MVector s a -> ST s ()) -> Vector a -> Vector a
- RIO.Vector.Boxed: null :: () => Vector a -> Bool
+ RIO.Vector.Boxed: null :: Vector a -> Bool
- RIO.Vector.Boxed: partition :: () => (a -> Bool) -> Vector a -> (Vector a, Vector a)
+ RIO.Vector.Boxed: partition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
- RIO.Vector.Boxed: postscanl :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: postscanl :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: postscanl' :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: postscanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: postscanr :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: postscanr :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: postscanr' :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: postscanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: prescanl :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: prescanl :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: prescanl' :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: prescanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: prescanr :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: prescanr :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: prescanr' :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: prescanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: replicate :: () => Int -> a -> Vector a
+ RIO.Vector.Boxed: replicate :: Int -> a -> Vector a
- RIO.Vector.Boxed: reverse :: () => Vector a -> Vector a
+ RIO.Vector.Boxed: reverse :: Vector a -> Vector a
- RIO.Vector.Boxed: scanl :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: scanl :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: scanl' :: () => (a -> b -> a) -> a -> Vector b -> Vector a
+ RIO.Vector.Boxed: scanl' :: (a -> b -> a) -> a -> Vector b -> Vector a
- RIO.Vector.Boxed: scanr :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: scanr :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: scanr' :: () => (a -> b -> b) -> b -> Vector a -> Vector b
+ RIO.Vector.Boxed: scanr' :: (a -> b -> b) -> b -> Vector a -> Vector b
- RIO.Vector.Boxed: singleton :: () => a -> Vector a
+ RIO.Vector.Boxed: singleton :: a -> Vector a
- RIO.Vector.Boxed: slice :: () => Int -> Int -> Vector a -> Vector a
+ RIO.Vector.Boxed: slice :: Int -> Int -> Vector a -> Vector a
- RIO.Vector.Boxed: snoc :: () => Vector a -> a -> Vector a
+ RIO.Vector.Boxed: snoc :: Vector a -> a -> Vector a
- RIO.Vector.Boxed: span :: () => (a -> Bool) -> Vector a -> (Vector a, Vector a)
+ RIO.Vector.Boxed: span :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
- RIO.Vector.Boxed: splitAt :: () => Int -> Vector a -> (Vector a, Vector a)
+ RIO.Vector.Boxed: splitAt :: Int -> Vector a -> (Vector a, Vector a)
- RIO.Vector.Boxed: take :: () => Int -> Vector a -> Vector a
+ RIO.Vector.Boxed: take :: Int -> Vector a -> Vector a
- RIO.Vector.Boxed: takeWhile :: () => (a -> Bool) -> Vector a -> Vector a
+ RIO.Vector.Boxed: takeWhile :: (a -> Bool) -> Vector a -> Vector a
- RIO.Vector.Boxed: toList :: () => Vector a -> [a]
+ RIO.Vector.Boxed: toList :: Vector a -> [a]
- RIO.Vector.Boxed: unfoldr :: () => (b -> Maybe (a, b)) -> b -> Vector a
+ RIO.Vector.Boxed: unfoldr :: (b -> Maybe (a, b)) -> b -> Vector a
- RIO.Vector.Boxed: unfoldrN :: () => Int -> (b -> Maybe (a, b)) -> b -> Vector a
+ RIO.Vector.Boxed: unfoldrN :: Int -> (b -> Maybe (a, b)) -> b -> Vector a
- RIO.Vector.Boxed: unstablePartition :: () => (a -> Bool) -> Vector a -> (Vector a, Vector a)
+ RIO.Vector.Boxed: unstablePartition :: (a -> Bool) -> Vector a -> (Vector a, Vector a)
- RIO.Vector.Boxed: unzip :: () => Vector (a, b) -> (Vector a, Vector b)
+ RIO.Vector.Boxed: unzip :: Vector (a, b) -> (Vector a, Vector b)
- RIO.Vector.Boxed: unzip3 :: () => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
+ RIO.Vector.Boxed: unzip3 :: Vector (a, b, c) -> (Vector a, Vector b, Vector c)
- RIO.Vector.Boxed: unzip4 :: () => Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
+ RIO.Vector.Boxed: unzip4 :: Vector (a, b, c, d) -> (Vector a, Vector b, Vector c, Vector d)
- RIO.Vector.Boxed: unzip5 :: () => Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)
+ RIO.Vector.Boxed: unzip5 :: Vector (a, b, c, d, e) -> (Vector a, Vector b, Vector c, Vector d, Vector e)
- RIO.Vector.Boxed: unzip6 :: () => Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
+ RIO.Vector.Boxed: unzip6 :: Vector (a, b, c, d, e, f) -> (Vector a, Vector b, Vector c, Vector d, Vector e, Vector f)
- RIO.Vector.Boxed: zip :: () => Vector a -> Vector b -> Vector (a, b)
+ RIO.Vector.Boxed: zip :: Vector a -> Vector b -> Vector (a, b)
- RIO.Vector.Boxed: zip3 :: () => Vector a -> Vector b -> Vector c -> Vector (a, b, c)
+ RIO.Vector.Boxed: zip3 :: Vector a -> Vector b -> Vector c -> Vector (a, b, c)
- RIO.Vector.Boxed: zip4 :: () => Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
+ RIO.Vector.Boxed: zip4 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector (a, b, c, d)
- RIO.Vector.Boxed: zip5 :: () => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
+ RIO.Vector.Boxed: zip5 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector (a, b, c, d, e)
- RIO.Vector.Boxed: zip6 :: () => Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
+ RIO.Vector.Boxed: zip6 :: Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector (a, b, c, d, e, f)
- RIO.Vector.Boxed: zipWith :: () => (a -> b -> c) -> Vector a -> Vector b -> Vector c
+ RIO.Vector.Boxed: zipWith :: (a -> b -> c) -> Vector a -> Vector b -> Vector c
- RIO.Vector.Boxed: zipWith3 :: () => (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
+ RIO.Vector.Boxed: zipWith3 :: (a -> b -> c -> d) -> Vector a -> Vector b -> Vector c -> Vector d
- RIO.Vector.Boxed: zipWith4 :: () => (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
+ RIO.Vector.Boxed: zipWith4 :: (a -> b -> c -> d -> e) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e
- RIO.Vector.Boxed: zipWith5 :: () => (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
+ RIO.Vector.Boxed: zipWith5 :: (a -> b -> c -> d -> e -> f) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f
- RIO.Vector.Boxed: zipWith6 :: () => (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
+ RIO.Vector.Boxed: zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> Vector a -> Vector b -> Vector c -> Vector d -> Vector e -> Vector f -> Vector g
- RIO.Vector.Boxed.Partial: (!) :: () => Vector a -> Int -> a
+ RIO.Vector.Boxed.Partial: (!) :: Vector a -> Int -> a
- RIO.Vector.Boxed.Partial: (//) :: () => Vector a -> [(Int, a)] -> Vector a
+ RIO.Vector.Boxed.Partial: (//) :: Vector a -> [(Int, a)] -> Vector a
- RIO.Vector.Boxed.Partial: accum :: () => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
+ RIO.Vector.Boxed.Partial: accum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
- RIO.Vector.Boxed.Partial: accumulate :: () => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
+ RIO.Vector.Boxed.Partial: accumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
- RIO.Vector.Boxed.Partial: accumulate_ :: () => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+ RIO.Vector.Boxed.Partial: accumulate_ :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- RIO.Vector.Boxed.Partial: backpermute :: () => Vector a -> Vector Int -> Vector a
+ RIO.Vector.Boxed.Partial: backpermute :: Vector a -> Vector Int -> Vector a
- RIO.Vector.Boxed.Partial: foldl1 :: () => (a -> a -> a) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: foldl1 :: (a -> a -> a) -> Vector a -> a
- RIO.Vector.Boxed.Partial: foldl1' :: () => (a -> a -> a) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: foldl1' :: (a -> a -> a) -> Vector a -> a
- RIO.Vector.Boxed.Partial: foldr1 :: () => (a -> a -> a) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: foldr1 :: (a -> a -> a) -> Vector a -> a
- RIO.Vector.Boxed.Partial: foldr1' :: () => (a -> a -> a) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: foldr1' :: (a -> a -> a) -> Vector a -> a
- RIO.Vector.Boxed.Partial: head :: () => Vector a -> a
+ RIO.Vector.Boxed.Partial: head :: Vector a -> a
- RIO.Vector.Boxed.Partial: init :: () => Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: init :: Vector a -> Vector a
- RIO.Vector.Boxed.Partial: last :: () => Vector a -> a
+ RIO.Vector.Boxed.Partial: last :: Vector a -> a
- RIO.Vector.Boxed.Partial: maxIndexBy :: () => (a -> a -> Ordering) -> Vector a -> Int
+ RIO.Vector.Boxed.Partial: maxIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
- RIO.Vector.Boxed.Partial: maximumBy :: () => (a -> a -> Ordering) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: maximumBy :: (a -> a -> Ordering) -> Vector a -> a
- RIO.Vector.Boxed.Partial: minIndexBy :: () => (a -> a -> Ordering) -> Vector a -> Int
+ RIO.Vector.Boxed.Partial: minIndexBy :: (a -> a -> Ordering) -> Vector a -> Int
- RIO.Vector.Boxed.Partial: minimumBy :: () => (a -> a -> Ordering) -> Vector a -> a
+ RIO.Vector.Boxed.Partial: minimumBy :: (a -> a -> Ordering) -> Vector a -> a
- RIO.Vector.Boxed.Partial: scanl1 :: () => (a -> a -> a) -> Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: scanl1 :: (a -> a -> a) -> Vector a -> Vector a
- RIO.Vector.Boxed.Partial: scanl1' :: () => (a -> a -> a) -> Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: scanl1' :: (a -> a -> a) -> Vector a -> Vector a
- RIO.Vector.Boxed.Partial: scanr1 :: () => (a -> a -> a) -> Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: scanr1 :: (a -> a -> a) -> Vector a -> Vector a
- RIO.Vector.Boxed.Partial: scanr1' :: () => (a -> a -> a) -> Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: scanr1' :: (a -> a -> a) -> Vector a -> Vector a
- RIO.Vector.Boxed.Partial: tail :: () => Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: tail :: Vector a -> Vector a
- RIO.Vector.Boxed.Partial: update :: () => Vector a -> Vector (Int, a) -> Vector a
+ RIO.Vector.Boxed.Partial: update :: Vector a -> Vector (Int, a) -> Vector a
- RIO.Vector.Boxed.Partial: update_ :: () => Vector a -> Vector Int -> Vector a -> Vector a
+ RIO.Vector.Boxed.Partial: update_ :: Vector a -> Vector Int -> Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeAccum :: () => (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeAccum :: (a -> b -> a) -> Vector a -> [(Int, b)] -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeAccumulate :: () => (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeAccumulate :: (a -> b -> a) -> Vector a -> Vector (Int, b) -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeAccumulate_ :: () => (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeAccumulate_ :: (a -> b -> a) -> Vector a -> Vector Int -> Vector b -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeBackpermute :: () => Vector a -> Vector Int -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeBackpermute :: Vector a -> Vector Int -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeDrop :: () => Int -> Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeDrop :: Int -> Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeHead :: () => Vector a -> a
+ RIO.Vector.Boxed.Unsafe: unsafeHead :: Vector a -> a
- RIO.Vector.Boxed.Unsafe: unsafeIndex :: () => Vector a -> Int -> a
+ RIO.Vector.Boxed.Unsafe: unsafeIndex :: Vector a -> Int -> a
- RIO.Vector.Boxed.Unsafe: unsafeInit :: () => Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeInit :: Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeLast :: () => Vector a -> a
+ RIO.Vector.Boxed.Unsafe: unsafeLast :: Vector a -> a
- RIO.Vector.Boxed.Unsafe: unsafeSlice :: () => Int -> Int -> Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeSlice :: Int -> Int -> Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeTail :: () => Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeTail :: Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeTake :: () => Int -> Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeTake :: Int -> Vector a -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeUpd :: () => Vector a -> [(Int, a)] -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeUpd :: Vector a -> [(Int, a)] -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeUpdate :: () => Vector a -> Vector (Int, a) -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeUpdate :: Vector a -> Vector (Int, a) -> Vector a
- RIO.Vector.Boxed.Unsafe: unsafeUpdate_ :: () => Vector a -> Vector Int -> Vector a -> Vector a
+ RIO.Vector.Boxed.Unsafe: unsafeUpdate_ :: Vector a -> Vector Int -> Vector a -> Vector a
- RIO.Vector.Unboxed: data family MVector s a :: Type
+ RIO.Vector.Unboxed: data family MVector s a
- RIO.Writer: WriterT :: m (a, w) -> WriterT w a
+ RIO.Writer: WriterT :: m (a, w) -> WriterT w (m :: Type -> Type) a
- RIO.Writer: [runWriterT] :: WriterT w a -> m (a, w)
+ RIO.Writer: [runWriterT] :: WriterT w (m :: Type -> Type) a -> m (a, w)
- RIO.Writer: execWriter :: () => Writer w a -> w
+ RIO.Writer: execWriter :: Writer w a -> w
- RIO.Writer: mapWriter :: () => ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
+ RIO.Writer: mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b
- RIO.Writer: mapWriterT :: () => (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
+ RIO.Writer: mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
- RIO.Writer: runWriter :: () => Writer w a -> (a, w)
+ RIO.Writer: runWriter :: Writer w a -> (a, w)
Files
- ChangeLog.md +4/−0
- rio.cabal +4/−4
- src/RIO.hs +6/−0
ChangeLog.md view
@@ -1,5 +1,9 @@ # Changelog for rio +## 0.1.20.0++* Export `UnliftIO.QSem` and `UnliftIO.QSemN` in `RIO`+ ## 0.1.19.0 * Expose `fromLeft` and `fromRight`
rio.cabal view
@@ -4,10 +4,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 2b9ea9ee3e7bdfefbc63c62e72ff3ce7b348803d398dcc3e394879db5522fa1b+-- hash: f3c92fe72c8e7fd35fdebcde2b50c754eec24d9c4d5bc1bded6f7876503fb693 name: rio-version: 0.1.19.0+version: 0.1.20.0 synopsis: A standard library for Haskell description: See README and Haddocks at <https://www.stackage.org/package/rio> category: Control@@ -110,7 +110,7 @@ , text , time , typed-process >=0.2.5.0- , unliftio >=0.2.12+ , unliftio >=0.2.14 , unliftio-core , unordered-containers , vector@@ -160,7 +160,7 @@ , text , time , typed-process >=0.2.5.0- , unliftio >=0.2.12+ , unliftio >=0.2.14 , unliftio-core , unordered-containers , vector
src/RIO.hs view
@@ -79,6 +79,10 @@ , module UnliftIO.IORef -- ** MVar , module UnliftIO.MVar+ -- ** QSem+ , module UnliftIO.QSem+ -- ** QSemN+ , module UnliftIO.QSemN -- ** Memoize , module UnliftIO.Memoize -- ** Deque@@ -113,6 +117,8 @@ import UnliftIO.IORef import UnliftIO.Memoize import UnliftIO.MVar+import UnliftIO.QSem+import UnliftIO.QSemN import UnliftIO.STM import UnliftIO.Temporary import UnliftIO.Timeout