packages feed

bizzlelude 1.2.0 → 1.3.0

raw patch · 2 files changed

+157/−13 lines, 2 filesdep +regexprPVP ok

version bump matches the API change (PVP)

Dependencies added: regexpr

API changes (from Hackage documentation)

+ Prelude: ($!) :: () => a -> b -> a -> b
+ Prelude: ($) :: () => a -> b -> a -> b
+ Prelude: ($>) :: Functor f => f a -> b -> f b
+ Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ Prelude: (&&) :: Bool -> Bool -> Bool
+ Prelude: (*) :: Num a => a -> a -> a
+ Prelude: (**) :: Floating a => a -> a -> a
+ Prelude: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ Prelude: (*>) :: Applicative f => f a -> f b -> f b
+ Prelude: (+) :: Num a => a -> a -> a
+ Prelude: (-) :: Num a => a -> a -> a
+ Prelude: (.) :: () => b -> c -> a -> b -> a -> c
+ Prelude: (/) :: Fractional a => a -> a -> a
+ Prelude: (/=) :: Eq a => a -> a -> Bool
+ Prelude: (<$) :: Functor f => a -> f b -> f a
+ Prelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ Prelude: (<) :: Ord a => a -> a -> Bool
+ Prelude: (<*) :: Applicative f => f a -> f b -> f a
+ Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Prelude: (<=) :: Ord a => a -> a -> Bool
+ Prelude: (<>) :: Semigroup a => a -> a -> a
+ Prelude: (<|>) :: Alternative f => f a -> f a -> f a
+ Prelude: (==) :: Eq a => a -> a -> Bool
+ Prelude: (>) :: Ord a => a -> a -> Bool
+ Prelude: (>=) :: Ord a => a -> a -> Bool
+ Prelude: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ Prelude: (>>) :: Monad m => m a -> m b -> m b
+ Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Prelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c
+ Prelude: (^) :: (Num a, Integral b) => a -> b -> a
+ Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Prelude: (||) :: Bool -> Bool -> Bool
+ Prelude: EQ :: Ordering
+ Prelude: False :: Bool
+ Prelude: GT :: Ordering
+ Prelude: Just :: a -> Maybe a
+ Prelude: LT :: Ordering
+ Prelude: Left :: a -> Either a b
+ Prelude: Nothing :: Maybe a
+ Prelude: Right :: b -> Either a b
+ Prelude: True :: Bool
+ Prelude: abs :: Num a => a -> a
+ Prelude: acos :: Floating a => a -> a
+ Prelude: acosh :: Floating a => a -> a
+ Prelude: all :: Foldable t => a -> Bool -> t a -> Bool
+ Prelude: and :: Foldable t => t Bool -> Bool
+ Prelude: any :: Foldable t => a -> Bool -> t a -> Bool
+ Prelude: asin :: Floating a => a -> a
+ Prelude: asinh :: Floating a => a -> a
+ Prelude: atan :: Floating a => a -> a
+ Prelude: atanh :: Floating a => a -> a
+ Prelude: bimap :: Bifunctor p => a -> b -> c -> d -> p a c -> p b d
+ Prelude: cartProduct :: [a] -> [b] -> [(a, b)]
+ Prelude: catMaybes :: () => [Maybe a] -> [a]
+ Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ Prelude: class Applicative f => Alternative (f :: * -> *)
+ Prelude: class Functor f => Applicative (f :: * -> *)
+ Prelude: class Bifunctor (p :: * -> * -> *)
+ Prelude: class Eq a
+ Prelude: class Fractional a => Floating a
+ Prelude: class Foldable (t :: * -> *)
+ Prelude: class Num a => Fractional a
+ Prelude: class Functor (f :: * -> *)
+ Prelude: class (Real a, Enum a) => Integral a
+ Prelude: class Applicative m => Monad (m :: * -> *)
+ Prelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ Prelude: class Semigroup a => Monoid a
+ Prelude: class Num a
+ Prelude: class Eq a => Ord a
+ Prelude: class (Real a, Fractional a) => RealFrac a
+ Prelude: class Semigroup a
+ Prelude: class Show a
+ Prelude: compare :: Ord a => a -> a -> Ordering
+ Prelude: const :: () => a -> b -> a
+ Prelude: cos :: Floating a => a -> a
+ Prelude: cosh :: Floating a => a -> a
+ Prelude: curry :: () => (a, b) -> c -> a -> b -> c
+ Prelude: curry3 :: ((a, b, c) -> x) -> a -> b -> c -> x
+ Prelude: curry4 :: ((a, b, c, d) -> x) -> a -> b -> c -> d -> x
+ Prelude: data Bool
+ Prelude: data Char
+ Prelude: data Double
+ Prelude: data Either a b
+ Prelude: data Float
+ Prelude: data IO a
+ Prelude: data Int
+ Prelude: data Int16
+ Prelude: data Int32
+ Prelude: data Int64
+ Prelude: data Int8
+ Prelude: data IntSet
+ Prelude: data Integer
+ Prelude: data Map k a
+ Prelude: data Maybe a
+ Prelude: data Ordering
+ Prelude: data Set a
+ Prelude: data Text
+ Prelude: digitToInt :: Char -> Int
+ Prelude: div :: Integral a => a -> a -> a
+ Prelude: divMod :: Integral a => a -> a -> (a, a)
+ Prelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Prelude: exp :: Floating a => a -> a
+ Prelude: filterM :: Applicative m => a -> m Bool -> [a] -> m [a]
+ Prelude: find :: Foldable t => a -> Bool -> t a -> Maybe a
+ Prelude: first :: Bifunctor p => a -> b -> p a c -> p b c
+ Prelude: flip :: () => a -> b -> c -> b -> a -> c
+ Prelude: floor :: (RealFrac a, Integral b) => a -> b
+ Prelude: fmap :: Functor f => a -> b -> f a -> f b
+ Prelude: fold :: (Foldable t, Monoid m) => t m -> m
+ Prelude: foldM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b
+ Prelude: foldM_ :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m ()
+ Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Prelude: foldl' :: Foldable t => b -> a -> b -> b -> t a -> b
+ Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Prelude: foldlM :: (Foldable t, Monad m) => b -> a -> m b -> b -> t a -> m b
+ Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Prelude: foldr' :: Foldable t => a -> b -> b -> b -> t a -> b
+ Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Prelude: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b
+ Prelude: forM_ :: (Foldable t, Monad m) => t a -> a -> m b -> m ()
+ Prelude: for_ :: (Foldable t, Applicative f) => t a -> a -> f b -> f ()
+ Prelude: fromInteger :: Num a => Integer -> a
+ Prelude: fromIntegral :: (Integral a, Num b) => a -> b
+ Prelude: fromMaybe :: () => a -> Maybe a -> a
+ Prelude: fromRational :: Fractional a => Rational -> a
+ Prelude: frt4 :: (a, b, c, d) -> d
+ Prelude: fst :: () => (a, b) -> a
+ Prelude: fst3 :: (a, b, c) -> a
+ Prelude: fst4 :: (a, b, c, d) -> a
+ Prelude: guard :: Alternative f => Bool -> f ()
+ Prelude: id :: () => a -> a
+ Prelude: infixl 0 `on`
+ Prelude: infixl 4 <$>
+ Prelude: infixr 0 $!
+ Prelude: infixr 1 >=>
+ Prelude: infixr 2 ||
+ Prelude: infixr 3 &&
+ Prelude: infixr 8 ^
+ Prelude: infixr 9 .
+ Prelude: intToDigit :: Int -> Char
+ Prelude: ioError :: () => IOError -> IO a
+ Prelude: isJust :: () => Maybe a -> Bool
+ Prelude: isLeft :: () => Either a b -> Bool
+ Prelude: isNothing :: () => Maybe a -> Bool
+ Prelude: isRight :: () => Either a b -> Bool
+ Prelude: join :: Monad m => m m a -> m a
+ Prelude: lefts :: () => [Either a b] -> [a]
+ Prelude: length :: Foldable t => t a -> Int
+ Prelude: liftIO :: MonadIO m => IO a -> m a
+ Prelude: lines :: Text -> [Text]
+ Prelude: listToMaybe :: () => [a] -> Maybe a
+ Prelude: log :: Floating a => a -> a
+ Prelude: logBase :: Floating a => a -> a -> a
+ Prelude: mapAllFour :: (a -> x) -> (b -> y) -> (c -> z) -> (d -> l) -> (a, b, c, d) -> (x, y, z, l)
+ Prelude: mapAllThree :: (a -> x) -> (b -> y) -> (c -> z) -> (a, b, c) -> (x, y, z)
+ Prelude: mapBoth :: (a -> x) -> (b -> y) -> (a, b) -> (x, y)
+ Prelude: mapFrt4 :: (d -> x) -> (a, b, c, d) -> (a, b, c, x)
+ Prelude: mapFrtF4 :: Functor f => (d -> f x) -> (a, b, c, d) -> f (a, b, c, x)
+ Prelude: mapFst :: (a -> x) -> (a, b) -> (x, b)
+ Prelude: mapFst3 :: (a -> x) -> (a, b, c) -> (x, b, c)
+ Prelude: mapFst4 :: (a -> x) -> (a, b, c, d) -> (x, b, c, d)
+ Prelude: mapFstF :: Functor f => (a -> f x) -> (a, b) -> f (x, b)
+ Prelude: mapFstF3 :: Functor f => (a -> f x) -> (a, b, c) -> f (x, b, c)
+ Prelude: mapFstF4 :: Functor f => (a -> f x) -> (a, b, c, d) -> f (x, b, c, d)
+ Prelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ Prelude: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Prelude: mapSnd :: (b -> x) -> (a, b) -> (a, x)
+ Prelude: mapSnd3 :: (b -> x) -> (a, b, c) -> (a, x, c)
+ Prelude: mapSnd4 :: (b -> x) -> (a, b, c, d) -> (a, x, c, d)
+ Prelude: mapSndF :: Functor f => (b -> f x) -> (a, b) -> f (a, x)
+ Prelude: mapSndF3 :: Functor f => (b -> f x) -> (a, b, c) -> f (a, x, c)
+ Prelude: mapSndF4 :: Functor f => (b -> f x) -> (a, b, c, d) -> f (a, x, c, d)
+ Prelude: mapThd3 :: (c -> x) -> (a, b, c) -> (a, b, x)
+ Prelude: mapThd4 :: (c -> x) -> (a, b, c, d) -> (a, b, x, d)
+ Prelude: mapThdF3 :: Functor f => (c -> f x) -> (a, b, c) -> f (a, b, x)
+ Prelude: mapThdF4 :: Functor f => (c -> f x) -> (a, b, c, d) -> f (a, b, x, d)
+ Prelude: mappend :: Monoid a => a -> a -> a
+ Prelude: max :: Ord a => a -> a -> a
+ Prelude: maximum :: (Foldable t, Ord a) => t a -> a
+ Prelude: maximumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Prelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ Prelude: maybeToList :: () => Maybe a -> [a]
+ Prelude: mempty :: Monoid a => a
+ Prelude: min :: Ord a => a -> a -> a
+ Prelude: minimum :: (Foldable t, Ord a) => t a -> a
+ Prelude: minimumBy :: Foldable t => a -> a -> Ordering -> t a -> a
+ Prelude: mod :: Integral a => a -> a -> a
+ Prelude: negate :: Num a => a -> a
+ Prelude: not :: Bool -> Bool
+ Prelude: null :: Foldable t => t a -> Bool
+ Prelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c
+ Prelude: or :: Foldable t => t Bool -> Bool
+ Prelude: otherwise :: Bool
+ Prelude: pam :: Functor f => f a -> (a -> b) -> f b
+ Prelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ Prelude: pi :: Floating a => a
+ Prelude: product :: (Foldable t, Num a) => t a -> a
+ Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Prelude: pure :: Applicative f => a -> f a
+ Prelude: quot :: Integral a => a -> a -> a
+ Prelude: quotRem :: Integral a => a -> a -> (a, a)
+ Prelude: read :: Read a => String -> a
+ Prelude: recip :: Fractional a => a -> a
+ Prelude: regexMatch :: Text -> Text -> Maybe [Text]
+ Prelude: rem :: Integral a => a -> a -> a
+ Prelude: return :: Monad m => a -> m a
+ Prelude: rights :: () => [Either a b] -> [b]
+ Prelude: round :: (RealFrac a, Integral b) => a -> b
+ Prelude: second :: Bifunctor p => b -> c -> p a b -> p a c
+ Prelude: seq :: () => a -> b -> b
+ Prelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Prelude: sequenceA_ :: (Foldable t, Applicative f) => t f a -> f ()
+ Prelude: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Prelude: show :: Show a => a -> String
+ Prelude: signum :: Num a => a -> a
+ Prelude: sin :: Floating a => a -> a
+ Prelude: sinh :: Floating a => a -> a
+ Prelude: snd :: () => (a, b) -> b
+ Prelude: snd3 :: (a, b, c) -> b
+ Prelude: snd4 :: (a, b, c, d) -> b
+ Prelude: sqrt :: Floating a => a -> a
+ Prelude: subtract :: Num a => a -> a -> a
+ Prelude: sum :: (Foldable t, Num a) => t a -> a
+ Prelude: swap :: () => (a, b) -> (b, a)
+ Prelude: tan :: Floating a => a -> a
+ Prelude: tanh :: Floating a => a -> a
+ Prelude: thd3 :: (a, b, c) -> c
+ Prelude: thd4 :: (a, b, c, d) -> c
+ Prelude: toInteger :: Integral a => a -> Integer
+ Prelude: trace :: () => String -> a -> a
+ Prelude: traceEvent :: () => String -> a -> a
+ Prelude: traceEventIO :: String -> IO ()
+ Prelude: traceIO :: String -> IO ()
+ Prelude: traceId :: String -> String
+ Prelude: traceM :: Applicative f => String -> f ()
+ Prelude: traceMarker :: () => String -> a -> a
+ Prelude: traceMarkerIO :: String -> IO ()
+ Prelude: traceShow :: Show a => a -> b -> b
+ Prelude: traceShowId :: Show a => a -> a
+ Prelude: traceShowM :: (Show a, Applicative f) => a -> f ()
+ Prelude: traceStack :: () => String -> a -> a
+ Prelude: truncate :: (RealFrac a, Integral b) => a -> b
+ Prelude: tuple2To3a :: (a, b) -> x -> (x, a, b)
+ Prelude: tuple2To3b :: (a, b) -> x -> (a, x, b)
+ Prelude: tuple2To3c :: (a, b) -> x -> (a, b, x)
+ Prelude: tuple3To4a :: (a, b, c) -> x -> (x, a, b, c)
+ Prelude: tuple3To4b :: (a, b, c) -> x -> (a, x, b, c)
+ Prelude: tuple3To4c :: (a, b, c) -> x -> (a, b, x, c)
+ Prelude: tuple3To4d :: (a, b, c) -> x -> (a, b, c, x)
+ Prelude: tuple4To5a :: (a, b, c, d) -> x -> (x, a, b, c, d)
+ Prelude: tuple4To5b :: (a, b, c, d) -> x -> (a, x, b, c, d)
+ Prelude: tuple4To5c :: (a, b, c, d) -> x -> (a, b, x, c, d)
+ Prelude: tuple4To5d :: (a, b, c, d) -> x -> (a, b, c, x, d)
+ Prelude: tuple4To5e :: (a, b, c, d) -> x -> (a, b, c, d, x)
+ Prelude: type FilePath = String
+ Prelude: type IOError = IOException
+ Prelude: type String = [Char]
+ Prelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Prelude: undefined :: HasCallStack => a
+ Prelude: unless :: Applicative f => Bool -> f () -> f ()
+ Prelude: unlines :: [Text] -> Text
+ Prelude: unwords :: [Text] -> Text
+ Prelude: userError :: String -> IOError
+ Prelude: void :: Functor f => f a -> f ()
+ Prelude: when :: Applicative f => Bool -> f () -> f ()
+ Prelude: words :: Text -> [Text]
- Prelude: uncurry3 :: (a -> b -> c -> d) -> ((a, b, c) -> d)
+ Prelude: uncurry3 :: (a -> b -> c -> x) -> ((a, b, c) -> x)
- Prelude: uncurry4 :: (a -> b -> c -> d -> e) -> ((a, b, c, d) -> e)
+ Prelude: uncurry4 :: (a -> b -> c -> d -> x) -> ((a, b, c, d) -> x)

Files

bizzlelude.cabal view
@@ -1,5 +1,5 @@ Name:                bizzlelude-Version:             1.2.0+Version:             1.3.0 Cabal-version:       >=1.22.0 License:             BSD3 License-File:        LICENSE.txt@@ -30,9 +30,9 @@     -Wredundant-constraints     -fno-warn-name-shadowing     -funbox-strict-fields-    -O2   Build-depends:     base-noprelude >= 4.8    && < 5,     containers     >= 0.5.11 && < 0.6.0,     directory      >= 1.3.2  && < 1.4.0,+    regexpr        >= 0.5.4  && < 0.6.0,     text           >= 1.2.3  && < 1.3.0
src/main/Prelude.hs view
@@ -1,9 +1,10 @@-module Prelude((|>), (<&>), asPath, asString, asText, concat, error, groupOn, listDirsRecursively, map, putStrFlush, return', scalaGroupBy, showText, uncurry3, uncurry4, uncurry5, unsafeRead-  , module Control.Arrow, module Control.Applicative, module Control.Monad, module Data.Bifunctor, module Data.Bool, module Data.Char, module Data.Either, module Data.Eq, module Data.Foldable, module Data.Function, module Data.Functor, module Data.Int, module Data.IntSet, module Data.Map, module Data.Maybe, module Data.Monoid, module Data.Ord, module Data.Semigroup, module Data.Set, module Data.Text, module Data.Tuple, module Debug.Trace, module GHC.Base, module GHC.Err, module GHC.Float, module GHC.IO, module GHC.Num, module GHC.Real, module GHC.Show, module Numeric, module System.IO.Error, module Text.Read) where+module Prelude((|>), (<&>), asPath, asString, asText, cartProduct, concat, curry3, curry4, error, frt4, fst3, fst4, groupOn, listDirsRecursively, map, mapAllFour, mapAllThree, mapBoth, mapFrt4, mapFrtF4, mapFst, mapFst3, mapFst4, mapFstF, mapFstF3, mapFstF4, mapSnd, mapSnd3, mapSnd4, mapSndF, mapSndF3, mapSndF4, mapThd3, mapThd4, mapThdF3, mapThdF4, pam, putStrFlush, regexMatch, return', scalaGroupBy, showText, snd3, snd4, thd3, thd4, tuple2To3a, tuple2To3b, tuple2To3c, tuple3To4a, tuple3To4b, tuple3To4c, tuple3To4d, tuple4To5a, tuple4To5b, tuple4To5c, tuple4To5d, tuple4To5e, uncurry3, uncurry4, uncurry5, unsafeRead+  , module Control.Arrow, module Control.Applicative, module Control.Monad, module Control.Monad.IO.Class, module Data.Bifunctor, module Data.Bool, module Data.Char, module Data.Either, module Data.Eq, module Data.Foldable, module Data.Function, module Data.Functor, module Data.Int, module Data.IntSet, module Data.Map, module Data.Maybe, module Data.Monoid, module Data.Ord, module Data.Semigroup, module Data.Set, module Data.Text, module Data.Tuple, module Debug.Trace, module GHC.Base, module GHC.Err, module GHC.Float, module GHC.IO, module GHC.Num, module GHC.Real, module GHC.Show, module Numeric, module System.IO.Error, module Text.Read) where  import Control.Arrow((&&&), (***), (>>>)) import Control.Applicative(Alternative((<|>)), Applicative((<*>), (<*), (*>), pure)) import Control.Monad((>=>), filterM, foldM, foldM_, forM, forM_, guard, join, mapM, mapM_, Monad((>>), (>>=), return), MonadPlus(), sequence, sequence_, unless, when)+import Control.Monad.IO.Class(liftIO)  import Data.Bifunctor(Bifunctor(bimap, first, second)) import Data.Bool(Bool(False, True), (&&), (||), not, otherwise)@@ -16,7 +17,7 @@ import Data.Int(Int, Int8, Int16, Int32, Int64) import Data.IntSet(IntSet) import Data.Map(Map)-import Data.Maybe(catMaybes, fromMaybe, isJust, isNothing, maybe, Maybe(Just, Nothing))+import Data.Maybe(catMaybes, fromMaybe, isJust, isNothing, listToMaybe, maybe, maybeToList, Maybe(Just, Nothing)) import Data.Monoid(Monoid(mappend, mempty)) import Data.Ord(Ord((<), (<=), (>), (>=), compare, max, min), Ordering(EQ, GT, LT)) import Data.Semigroup(Semigroup((<>)))@@ -31,7 +32,7 @@ import GHC.Float(Double, Float) import GHC.IO(FilePath, IO) import GHC.Num(Integer, Num((+), (-), (*), abs, signum, fromInteger, negate), subtract)-import GHC.Real((^), Fractional((/), recip, fromRational), fromIntegral, Integral(quot, rem, div, mod, quotRem, divMod, toInteger), RealFrac(properFraction, truncate, round, ceiling, floor))+import GHC.Real((^), (^^), Fractional((/), recip, fromRational), fromIntegral, Integral(quot, rem, div, mod, quotRem, divMod, toInteger), RealFrac(properFraction, truncate, round, ceiling, floor)) import GHC.Show(Show(show))  import Numeric(Floating, pi, exp, log, sqrt, (**), logBase, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh)@@ -39,6 +40,7 @@ import System.IO.Error(IOError, ioError, userError)  import Text.Read(read)+import Text.RegexPR(matchRegexPR)  import qualified Data.Either      as Either import qualified Data.Foldable    as Foldable@@ -52,6 +54,7 @@  (|>) :: a -> (a -> b) -> b a |> f = f a+infixr 1 |>  asString :: Text -> String asString = Text.unpack@@ -74,9 +77,156 @@ map :: (Functor f) => (a -> b) -> f a -> f b map = fmap -(<&>) :: Functor f => f a -> (a -> b) -> f b+pam, (<&>) :: Functor f => f a -> (a -> b) -> f b+pam   = flip map (<&>) = flip map +cartProduct :: [a] -> [b] -> [(a, b)]+cartProduct xs ys = [(x, y) | x <- xs, y <- ys]++regexMatch :: Text -> Text -> Maybe [Text]+regexMatch regex = asString >>> (matchRegexPR $ asString regex) >>> (map $ snd >>> (map $ snd >>> asText))++-- Tuple2 --++mapFst :: (a -> x) -> (a, b) -> (x, b)+mapFst f (a, b) = (f a, b)++mapSnd :: (b -> x) -> (a, b) -> (a, x)+mapSnd f (a, b) = (a, f b)++mapBoth :: (a -> x) -> (b -> y) -> (a, b) -> (x, y)+mapBoth f g (a, b) = (f a, g b)++mapFstF :: Functor f => (a -> f x) -> (a, b) -> f (x, b)+mapFstF f (a, b) = (f a) <&> (\x -> (x, b))++mapSndF :: Functor f => (b -> f x) -> (a, b) -> f (a, x)+mapSndF f (a, b) = (f b) <&> (\x -> (a, x))++tuple2To3a :: (a, b) -> x -> (x, a, b)+tuple2To3a (a, b) x = (x, a, b)++tuple2To3b :: (a, b) -> x -> (a, x, b)+tuple2To3b (a, b) x = (a, x, b)++tuple2To3c :: (a, b) -> x -> (a, b, x)+tuple2To3c (a, b) x = (a, b, x)++-- Tuple3 --++mapFst3 :: (a -> x) -> (a, b, c) -> (x, b, c)+mapFst3 f (a, b, c) = (f a, b, c)++mapSnd3 :: (b -> x) -> (a, b, c) -> (a, x, c)+mapSnd3 f (a, b, c) = (a, f b, c)++mapThd3 :: (c -> x) -> (a, b, c) -> (a, b, x)+mapThd3 f (a, b, c) = (a, b, f c)++mapAllThree :: (a -> x) -> (b -> y) -> (c -> z) -> (a, b, c) -> (x, y, z)+mapAllThree f g h (a, b, c) = (f a, g b, h c)++mapFstF3 :: Functor f => (a -> f x) -> (a, b, c) -> f (x, b, c)+mapFstF3 f (a, b, c) = (f a) <&> (\x -> (x, b, c))++mapSndF3 :: Functor f => (b -> f x) -> (a, b, c) -> f (a, x, c)+mapSndF3 f (a, b, c) = (f b) <&> (\x -> (a, x, c))++mapThdF3 :: Functor f => (c -> f x) -> (a, b, c) -> f (a, b, x)+mapThdF3 f (a, b, c) = (f c) <&> (\x -> (a, b, x))++tuple3To4a :: (a, b, c) -> x -> (x, a, b, c)+tuple3To4a (a, b, c) x = (x, a, b, c)++tuple3To4b :: (a, b, c) -> x -> (a, x, b, c)+tuple3To4b (a, b, c) x = (a, x, b, c)++tuple3To4c :: (a, b, c) -> x -> (a, b, x, c)+tuple3To4c (a, b, c) x = (a, b, x, c)++tuple3To4d :: (a, b, c) -> x -> (a, b, c, x)+tuple3To4d (a, b, c) x = (a, b, c, x)++curry3 :: ((a, b, c) -> x) -> a -> b -> c -> x+curry3 f a b c = f (a, b, c)++uncurry3 :: (a -> b -> c -> x) -> ((a, b, c) -> x)+uncurry3 f (a, b, c) = f a b c++fst3 :: (a, b, c) -> a+fst3 (a, _, _) = a++snd3 :: (a, b, c) -> b+snd3 (_, b, _) = b++thd3 :: (a, b, c) -> c+thd3 (_, _, c) = c++-- Tuple4 --++mapFst4 :: (a -> x) -> (a, b, c, d) -> (x, b, c, d)+mapFst4 f (a, b, c, d) = (f a, b, c, d)++mapSnd4 :: (b -> x) -> (a, b, c, d) -> (a, x, c, d)+mapSnd4 f (a, b, c, d) = (a, f b, c, d)++mapThd4 :: (c -> x) -> (a, b, c, d) -> (a, b, x, d)+mapThd4 f (a, b, c, d) = (a, b, f c, d)++mapFrt4 :: (d -> x) -> (a, b, c, d) -> (a, b, c, x)+mapFrt4 f (a, b, c, d) = (a, b, c, f d)++mapAllFour :: (a -> x) -> (b -> y) -> (c -> z) -> (d -> l) -> (a, b, c, d) -> (x, y, z, l)+mapAllFour f g h i (a, b, c, d) = (f a, g b, h c, i d)++mapFstF4 :: Functor f => (a -> f x) -> (a, b, c, d) -> f (x, b, c, d)+mapFstF4 f (a, b, c, d) = (f a) <&> (\x -> (x, b, c, d))++mapSndF4 :: Functor f => (b -> f x) -> (a, b, c, d) -> f (a, x, c, d)+mapSndF4 f (a, b, c, d) = (f b) <&> (\x -> (a, x, c, d))++mapThdF4 :: Functor f => (c -> f x) -> (a, b, c, d) -> f (a, b, x, d)+mapThdF4 f (a, b, c, d) = (f c) <&> (\x -> (a, b, x, d))++mapFrtF4 :: Functor f => (d -> f x) -> (a, b, c, d) -> f (a, b, c, x)+mapFrtF4 f (a, b, c, d) = (f d) <&> (\x -> (a, b, c, x))++tuple4To5a :: (a, b, c, d) -> x -> (x, a, b, c, d)+tuple4To5a (a, b, c, d) x = (x, a, b, c, d)++tuple4To5b :: (a, b, c, d) -> x -> (a, x, b, c, d)+tuple4To5b (a, b, c, d) x = (a, x, b, c, d)++tuple4To5c :: (a, b, c, d) -> x -> (a, b, x, c, d)+tuple4To5c (a, b, c, d) x = (a, b, x, c, d)++tuple4To5d :: (a, b, c, d) -> x -> (a, b, c, x, d)+tuple4To5d (a, b, c, d) x = (a, b, c, x, d)++tuple4To5e :: (a, b, c, d) -> x -> (a, b, c, d, x)+tuple4To5e (a, b, c, d) x = (a, b, c, d, x)++curry4 :: ((a, b, c, d) -> x) -> a -> b -> c -> d -> x+curry4 f a b c d = f (a, b, c, d)++uncurry4 :: (a -> b -> c -> d -> x) -> ((a, b, c, d) -> x)+uncurry4 f (a, b, c, d) = f a b c d++fst4 :: (a, b, c, d) -> a+fst4 (a, _, _, _) = a++snd4 :: (a, b, c, d) -> b+snd4 (_, b, _, _) = b++thd4 :: (a, b, c, d) -> c+thd4 (_, _, c, _) = c++frt4 :: (a, b, c, d) -> d+frt4 (_, _, _, d) = d++-- Misc. Again --+ groupOn :: Ord criterion => (item -> criterion) -> [item] -> [[item]] groupOn f = sort >>> group   where@@ -106,12 +256,6 @@     dirs     <- paths |> ((map $ \x -> filepath <> "/" <> x) >>> (filterM SD.doesDirectoryExist))     children <- mapM listDirsRecursively dirs     return $ dirs <> (concat children)--uncurry3 :: (a -> b -> c -> d) -> ((a, b, c) -> d)-uncurry3 f (a, b, c) = f a b c--uncurry4 :: (a -> b -> c -> d -> e) -> ((a, b, c, d) -> e)-uncurry4 f (a, b, c, d) = f a b c d  uncurry5 :: (a -> b -> c -> d -> e -> f) -> ((a, b, c, d, e) -> f) uncurry5 f (a, b, c, d, e) = f a b c d e