packages feed

classy-prelude 1.4.0 → 1.5.0

raw patch · 3 files changed

+11/−18 lines, 3 filesdep ~stmdep ~timePVP ok

version bump matches the API change (PVP)

Dependency ranges changed: stm, time

API changes (from Hackage documentation)

- ClassyPrelude: alwaysSTM :: STM Bool -> STM ()
- ClassyPrelude: alwaysSucceedsSTM :: STM a -> STM ()
+ ClassyPrelude: ($!!) :: NFData a => a -> b -> a -> b
+ ClassyPrelude: ($!) :: () => a -> b -> a -> b
+ ClassyPrelude: ($) :: () => a -> b -> a -> b
+ ClassyPrelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
+ ClassyPrelude: (&&) :: Bool -> Bool -> Bool
+ ClassyPrelude: (*) :: Num a => a -> a -> a
+ ClassyPrelude: (**) :: Floating a => a -> a -> a
+ ClassyPrelude: (***) :: Arrow a => a b c -> a b' c' -> a (b, b') (c, c')
+ ClassyPrelude: (*>) :: Applicative f => f a -> f b -> f b
+ ClassyPrelude: (+) :: Num a => a -> a -> a
+ ClassyPrelude: (-) :: Num a => a -> a -> a
+ ClassyPrelude: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ ClassyPrelude: (/) :: Fractional a => a -> a -> a
+ ClassyPrelude: (/=) :: Eq a => a -> a -> Bool
+ ClassyPrelude: (<$) :: Functor f => a -> f b -> f a
+ ClassyPrelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ ClassyPrelude: (<) :: Ord a => a -> a -> Bool
+ ClassyPrelude: (<*) :: Applicative f => f a -> f b -> f a
+ ClassyPrelude: (<**>) :: Applicative f => f a -> f a -> b -> f b
+ ClassyPrelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ ClassyPrelude: (<.>) :: FilePath -> String -> FilePath
+ ClassyPrelude: (</>) :: FilePath -> FilePath -> FilePath
+ ClassyPrelude: (<=) :: Ord a => a -> a -> Bool
+ ClassyPrelude: (<=<) :: Monad m => b -> m c -> a -> m b -> a -> m c
+ ClassyPrelude: (<|>) :: Alternative f => f a -> f a -> f a
+ ClassyPrelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ ClassyPrelude: (==) :: Eq a => a -> a -> Bool
+ ClassyPrelude: (>) :: Ord a => a -> a -> Bool
+ ClassyPrelude: (>=) :: Ord a => a -> a -> Bool
+ ClassyPrelude: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ ClassyPrelude: (>>) :: Monad m => m a -> m b -> m b
+ ClassyPrelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ ClassyPrelude: (^) :: (Num a, Integral b) => a -> b -> a
+ ClassyPrelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ ClassyPrelude: (||) :: Bool -> Bool -> Bool
+ ClassyPrelude: Down :: a -> Down a
+ ClassyPrelude: EQ :: Ordering
+ ClassyPrelude: False :: Bool
+ ClassyPrelude: GT :: Ordering
+ ClassyPrelude: Just :: a -> Maybe a
+ ClassyPrelude: LT :: Ordering
+ ClassyPrelude: Left :: a -> Either a b
+ ClassyPrelude: ModifiedJulianDay :: Integer -> Day
+ ClassyPrelude: Nothing :: Maybe a
+ ClassyPrelude: Right :: b -> Either a b
+ ClassyPrelude: True :: Bool
+ ClassyPrelude: UTCTime :: Day -> DiffTime -> UTCTime
+ ClassyPrelude: [toModifiedJulianDay] :: Day -> Integer
+ ClassyPrelude: [utctDayTime] :: UTCTime -> DiffTime
+ ClassyPrelude: [utctDay] :: UTCTime -> Day
+ ClassyPrelude: abs :: Num a => a -> a
+ ClassyPrelude: acos :: Floating a => a -> a
+ ClassyPrelude: acosh :: Floating a => a -> a
+ ClassyPrelude: alreadyExistsErrorType :: IOErrorType
+ ClassyPrelude: alreadyInUseErrorType :: IOErrorType
+ ClassyPrelude: annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ ClassyPrelude: ap :: Monad m => m a -> b -> m a -> m b
+ ClassyPrelude: asTypeOf :: () => a -> a -> a
+ ClassyPrelude: asin :: Floating a => a -> a
+ ClassyPrelude: asinh :: Floating a => a -> a
+ ClassyPrelude: asum :: (Foldable t, Alternative f) => t f a -> f a
+ ClassyPrelude: atan :: Floating a => a -> a
+ ClassyPrelude: atan2 :: RealFloat a => a -> a -> a
+ ClassyPrelude: atanh :: Floating a => a -> a
+ ClassyPrelude: bool :: () => a -> a -> Bool -> a
+ ClassyPrelude: ceiling :: (RealFrac a, Integral b) => a -> b
+ ClassyPrelude: class Applicative f => Alternative (f :: * -> *)
+ ClassyPrelude: class Functor f => Applicative (f :: * -> *)
+ ClassyPrelude: class Bounded a
+ ClassyPrelude: class Enum a
+ ClassyPrelude: class Eq a
+ ClassyPrelude: class (Typeable e, Show e) => Exception e
+ ClassyPrelude: class Fractional a => Floating a
+ ClassyPrelude: class Foldable (t :: * -> *)
+ ClassyPrelude: class Num a => Fractional a
+ ClassyPrelude: class Functor (f :: * -> *)
+ ClassyPrelude: class Hashable a
+ ClassyPrelude: class (Real a, Enum a) => Integral a
+ ClassyPrelude: class IsString a
+ ClassyPrelude: class Applicative m => Monad (m :: * -> *)
+ ClassyPrelude: class Monad m => MonadIO (m :: * -> *)
+ ClassyPrelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ ClassyPrelude: class Semigroup a => Monoid a
+ ClassyPrelude: class NFData a
+ ClassyPrelude: class Num a
+ ClassyPrelude: class Eq a => Ord a
+ ClassyPrelude: class Read a
+ ClassyPrelude: class (Num a, Ord a) => Real a
+ ClassyPrelude: class (RealFrac a, Floating a) => RealFloat a
+ ClassyPrelude: class (Real a, Fractional a) => RealFrac a
+ ClassyPrelude: class Storable a
+ ClassyPrelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ ClassyPrelude: class Typeable (a :: k)
+ ClassyPrelude: class (Vector Vector a, MVector MVector a) => Unbox a
+ ClassyPrelude: compare :: Ord a => a -> a -> Ordering
+ ClassyPrelude: comparing :: Ord a => b -> a -> b -> b -> Ordering
+ ClassyPrelude: const :: () => a -> b -> a
+ ClassyPrelude: cos :: Floating a => a -> a
+ ClassyPrelude: cosh :: Floating a => a -> a
+ ClassyPrelude: curry :: () => (a, b) -> c -> a -> b -> c
+ ClassyPrelude: data Bool
+ ClassyPrelude: data ByteString
+ ClassyPrelude: data Char
+ ClassyPrelude: data Double
+ ClassyPrelude: data Either a b
+ ClassyPrelude: data Float
+ ClassyPrelude: data HashMap k v
+ ClassyPrelude: data HashSet a
+ ClassyPrelude: data IO a
+ ClassyPrelude: data IOErrorType
+ ClassyPrelude: data IOException
+ ClassyPrelude: data Int
+ ClassyPrelude: data Int32
+ ClassyPrelude: data Int64
+ ClassyPrelude: data IntMap a
+ ClassyPrelude: data IntSet
+ ClassyPrelude: data Integer
+ ClassyPrelude: data Map k a
+ ClassyPrelude: data Maybe a
+ ClassyPrelude: data Ordering
+ ClassyPrelude: data Seq a
+ ClassyPrelude: data Set a
+ ClassyPrelude: data SomeException
+ ClassyPrelude: data Text
+ ClassyPrelude: data UTCTime
+ ClassyPrelude: data Vector a
+ ClassyPrelude: data Word
+ ClassyPrelude: data Word32
+ ClassyPrelude: data Word64
+ ClassyPrelude: data Word8
+ ClassyPrelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ ClassyPrelude: deepseq :: NFData a => a -> b -> b
+ ClassyPrelude: defaultTimeLocale :: TimeLocale
+ ClassyPrelude: displayException :: Exception e => e -> String
+ ClassyPrelude: div :: Integral a => a -> a -> a
+ ClassyPrelude: divMod :: Integral a => a -> a -> (a, a)
+ ClassyPrelude: doesNotExistErrorType :: IOErrorType
+ ClassyPrelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ ClassyPrelude: empty :: Alternative f => f a
+ ClassyPrelude: encodeFloat :: RealFloat a => Integer -> Int -> a
+ ClassyPrelude: enumFrom :: Enum a => a -> [a]
+ ClassyPrelude: enumFromThen :: Enum a => a -> a -> [a]
+ ClassyPrelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ ClassyPrelude: enumFromTo :: Enum a => a -> a -> [a]
+ ClassyPrelude: eofErrorType :: IOErrorType
+ ClassyPrelude: equating :: Eq a => b -> a -> b -> b -> Bool
+ ClassyPrelude: error :: HasCallStack => [Char] -> a
+ ClassyPrelude: even :: Integral a => a -> Bool
+ ClassyPrelude: exp :: Floating a => a -> a
+ ClassyPrelude: exponent :: RealFloat a => a -> Int
+ ClassyPrelude: fail :: Monad m => String -> m a
+ ClassyPrelude: flip :: () => a -> b -> c -> b -> a -> c
+ ClassyPrelude: floatDigits :: RealFloat a => a -> Int
+ ClassyPrelude: floatRadix :: RealFloat a => a -> Integer
+ ClassyPrelude: floatRange :: RealFloat a => a -> (Int, Int)
+ ClassyPrelude: floor :: (RealFrac a, Integral b) => a -> b
+ ClassyPrelude: fmap :: Functor f => a -> b -> f a -> f b
+ ClassyPrelude: for :: (Traversable t, Applicative f) => t a -> a -> f b -> f t b
+ ClassyPrelude: forM :: (Traversable t, Monad m) => t a -> a -> m b -> m t b
+ ClassyPrelude: force :: NFData a => a -> a
+ ClassyPrelude: forever :: Applicative f => f a -> f b
+ ClassyPrelude: formatTime :: FormatTime t => TimeLocale -> String -> t -> String
+ ClassyPrelude: fromEnum :: Enum a => a -> Int
+ ClassyPrelude: fromException :: Exception e => SomeException -> Maybe e
+ ClassyPrelude: fromGregorian :: Integer -> Int -> Int -> Day
+ ClassyPrelude: fromInteger :: Num a => Integer -> a
+ ClassyPrelude: fromIntegral :: (Integral a, Num b) => a -> b
+ ClassyPrelude: fromMaybe :: () => a -> Maybe a -> a
+ ClassyPrelude: fromRational :: Fractional a => Rational -> a
+ ClassyPrelude: fromString :: IsString a => String -> a
+ ClassyPrelude: fst :: () => (a, b) -> a
+ ClassyPrelude: fullErrorType :: IOErrorType
+ ClassyPrelude: getArgs :: MonadIO m => m [Text]
+ ClassyPrelude: getCurrentTime :: IO UTCTime
+ ClassyPrelude: guard :: Alternative f => Bool -> f ()
+ ClassyPrelude: hash :: Hashable a => a -> Int
+ ClassyPrelude: hashWithSalt :: Hashable a => Int -> a -> Int
+ ClassyPrelude: id :: Category cat => cat a a
+ ClassyPrelude: illegalOperationErrorType :: IOErrorType
+ ClassyPrelude: infixl 0 `on`
+ ClassyPrelude: infixl 3 <|>
+ ClassyPrelude: infixl 4 <**>
+ ClassyPrelude: infixr 0 $!!
+ ClassyPrelude: infixr 1 =<<
+ ClassyPrelude: infixr 7 <.>
+ ClassyPrelude: infixr 8 ^
+ ClassyPrelude: infixr 9 .
+ ClassyPrelude: ioError :: () => IOError -> IO a
+ ClassyPrelude: ioeGetErrorString :: IOError -> String
+ ClassyPrelude: ioeGetErrorType :: IOError -> IOErrorType
+ ClassyPrelude: ioeGetFileName :: IOError -> Maybe FilePath
+ ClassyPrelude: ioeGetHandle :: IOError -> Maybe Handle
+ ClassyPrelude: ioeGetLocation :: IOError -> String
+ ClassyPrelude: ioeSetErrorString :: IOError -> String -> IOError
+ ClassyPrelude: ioeSetErrorType :: IOError -> IOErrorType -> IOError
+ ClassyPrelude: ioeSetFileName :: IOError -> FilePath -> IOError
+ ClassyPrelude: ioeSetHandle :: IOError -> Handle -> IOError
+ ClassyPrelude: ioeSetLocation :: IOError -> String -> IOError
+ ClassyPrelude: isAlreadyExistsError :: IOError -> Bool
+ ClassyPrelude: isAlreadyExistsErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isAlreadyInUseError :: IOError -> Bool
+ ClassyPrelude: isAlreadyInUseErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isDenormalized :: RealFloat a => a -> Bool
+ ClassyPrelude: isDoesNotExistError :: IOError -> Bool
+ ClassyPrelude: isDoesNotExistErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isEOFError :: IOError -> Bool
+ ClassyPrelude: isEOFErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isFullError :: IOError -> Bool
+ ClassyPrelude: isFullErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isIEEE :: RealFloat a => a -> Bool
+ ClassyPrelude: isIllegalOperation :: IOError -> Bool
+ ClassyPrelude: isIllegalOperationErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isInfinite :: RealFloat a => a -> Bool
+ ClassyPrelude: isJust :: () => Maybe a -> Bool
+ ClassyPrelude: isNaN :: RealFloat a => a -> Bool
+ ClassyPrelude: isNegativeZero :: RealFloat a => a -> Bool
+ ClassyPrelude: isNothing :: () => Maybe a -> Bool
+ ClassyPrelude: isPermissionError :: IOError -> Bool
+ ClassyPrelude: isPermissionErrorType :: IOErrorType -> Bool
+ ClassyPrelude: isUserError :: IOError -> Bool
+ ClassyPrelude: isUserErrorType :: IOErrorType -> Bool
+ ClassyPrelude: join :: Monad m => m m a -> m a
+ ClassyPrelude: lefts :: () => [Either a b] -> [a]
+ ClassyPrelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
+ ClassyPrelude: liftA :: Applicative f => a -> b -> f a -> f b
+ ClassyPrelude: liftA2 :: Applicative f => a -> b -> c -> f a -> f b -> f c
+ ClassyPrelude: liftA3 :: Applicative f => a -> b -> c -> d -> f a -> f b -> f c -> f d
+ ClassyPrelude: liftIO :: MonadIO m => IO a -> m a
+ ClassyPrelude: liftM :: Monad m => a1 -> r -> m a1 -> m r
+ ClassyPrelude: liftM2 :: Monad m => a1 -> a2 -> r -> m a1 -> m a2 -> m r
+ ClassyPrelude: liftM3 :: Monad m => a1 -> a2 -> a3 -> r -> m a1 -> m a2 -> m a3 -> m r
+ ClassyPrelude: liftM4 :: Monad m => a1 -> a2 -> a3 -> a4 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m r
+ ClassyPrelude: liftM5 :: Monad m => a1 -> a2 -> a3 -> a4 -> a5 -> r -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
+ ClassyPrelude: listToMaybe :: () => [a] -> Maybe a
+ ClassyPrelude: log :: Floating a => a -> a
+ ClassyPrelude: logBase :: Floating a => a -> a -> a
+ ClassyPrelude: many :: Alternative f => f a -> f [a]
+ ClassyPrelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ ClassyPrelude: mapMaybe :: () => a -> Maybe b -> [a] -> [b]
+ ClassyPrelude: mappend :: Monoid a => a -> a -> a
+ ClassyPrelude: max :: Ord a => a -> a -> a
+ ClassyPrelude: maxBound :: Bounded a => a
+ ClassyPrelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ ClassyPrelude: maybeToList :: () => Maybe a -> [a]
+ ClassyPrelude: mconcat :: Monoid a => [a] -> a
+ ClassyPrelude: mempty :: Monoid a => a
+ ClassyPrelude: min :: Ord a => a -> a -> a
+ ClassyPrelude: minBound :: Bounded a => a
+ ClassyPrelude: mkIOError :: IOErrorType -> String -> Maybe Handle -> Maybe FilePath -> IOError
+ ClassyPrelude: mod :: Integral a => a -> a -> a
+ ClassyPrelude: modifyIOError :: () => IOError -> IOError -> IO a -> IO a
+ ClassyPrelude: mplus :: MonadPlus m => m a -> m a -> m a
+ ClassyPrelude: mzero :: MonadPlus m => m a
+ ClassyPrelude: negate :: Num a => a -> a
+ ClassyPrelude: newtype Day
+ ClassyPrelude: newtype Down a
+ ClassyPrelude: not :: Bool -> Bool
+ ClassyPrelude: odd :: Integral a => a -> Bool
+ ClassyPrelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c
+ ClassyPrelude: optional :: Alternative f => f a -> f Maybe a
+ ClassyPrelude: otherwise :: Bool
+ ClassyPrelude: parseTime :: ParseTime t => TimeLocale -> String -> String -> Maybe t
+ ClassyPrelude: parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
+ ClassyPrelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ ClassyPrelude: permissionErrorType :: IOErrorType
+ ClassyPrelude: pi :: Floating a => a
+ ClassyPrelude: pred :: Enum a => a -> a
+ ClassyPrelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ ClassyPrelude: pure :: Applicative f => a -> f a
+ ClassyPrelude: quot :: Integral a => a -> a -> a
+ ClassyPrelude: quotRem :: Integral a => a -> a -> (a, a)
+ ClassyPrelude: realToFrac :: (Real a, Fractional b) => a -> b
+ ClassyPrelude: recip :: Fractional a => a -> a
+ ClassyPrelude: rem :: Integral a => a -> a -> a
+ ClassyPrelude: replicateM_ :: Applicative m => Int -> m a -> m ()
+ ClassyPrelude: return :: Monad m => a -> m a
+ ClassyPrelude: rights :: () => [Either a b] -> [b]
+ ClassyPrelude: rnf :: NFData a => a -> ()
+ ClassyPrelude: round :: (RealFrac a, Integral b) => a -> b
+ ClassyPrelude: scaleFloat :: RealFloat a => Int -> a -> a
+ ClassyPrelude: seq :: () => a -> b -> b
+ ClassyPrelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ ClassyPrelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ ClassyPrelude: significand :: RealFloat a => a -> a
+ ClassyPrelude: signum :: Num a => a -> a
+ ClassyPrelude: sin :: Floating a => a -> a
+ ClassyPrelude: sinh :: Floating a => a -> a
+ ClassyPrelude: snd :: () => (a, b) -> b
+ ClassyPrelude: some :: Alternative f => f a -> f [a]
+ ClassyPrelude: sqrt :: Floating a => a -> a
+ ClassyPrelude: subtract :: Num a => a -> a -> a
+ ClassyPrelude: succ :: Enum a => a -> a
+ ClassyPrelude: swap :: () => (a, b) -> (b, a)
+ ClassyPrelude: tan :: Floating a => a -> a
+ ClassyPrelude: tanh :: Floating a => a -> a
+ ClassyPrelude: terror :: HasCallStack => Text -> a
+ ClassyPrelude: toEnum :: Enum a => Int -> a
+ ClassyPrelude: toException :: Exception e => e -> SomeException
+ ClassyPrelude: toGregorian :: Day -> (Integer, Int, Int)
+ ClassyPrelude: toInteger :: Integral a => a -> Integer
+ ClassyPrelude: toRational :: Real a => a -> Rational
+ ClassyPrelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ ClassyPrelude: truncate :: (RealFrac a, Integral b) => a -> b
+ ClassyPrelude: tryIOError :: () => IO a -> IO Either IOError a
+ ClassyPrelude: type FilePath = String
+ ClassyPrelude: type IOError = IOException
+ ClassyPrelude: type LByteString = ByteString
+ ClassyPrelude: type LText = Text
+ ClassyPrelude: type Rational = Ratio Integer
+ ClassyPrelude: type SVector = Vector
+ ClassyPrelude: type String = [Char]
+ ClassyPrelude: type UVector = Vector
+ ClassyPrelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ ClassyPrelude: unless :: Applicative f => Bool -> f () -> f ()
+ ClassyPrelude: until :: () => a -> Bool -> a -> a -> a -> a
+ ClassyPrelude: userError :: String -> IOError
+ ClassyPrelude: userErrorType :: IOErrorType
+ ClassyPrelude: void :: Functor f => f a -> f ()
+ ClassyPrelude: when :: Applicative f => Bool -> f () -> f ()
- ClassyPrelude: ReaderT :: (r -> m a) -> ReaderT k r
+ ClassyPrelude: ReaderT :: r -> m a -> ReaderT r
- ClassyPrelude: [runReaderT] :: ReaderT k r -> r -> m a
+ ClassyPrelude: [runReaderT] :: ReaderT r -> r -> m a
- ClassyPrelude: asks :: MonadReader r m => (r -> a) -> m a
+ ClassyPrelude: asks :: MonadReader r m => r -> a -> m a
- ClassyPrelude: data DList a :: * -> *
+ ClassyPrelude: data DList a
- ClassyPrelude: data WrappedMonoid m :: * -> *
+ ClassyPrelude: data WrappedMonoid m
- ClassyPrelude: newtype ReaderT k r (m :: k -> *) (a :: k) :: forall k. () => * -> (k -> *) -> k -> *
+ ClassyPrelude: newtype ReaderT r (m :: k -> *) (a :: k) :: forall k. () => * -> k -> * -> k -> *
- ClassyPrelude: newtype Identity a :: * -> *
+ ClassyPrelude: newtype Identity a
- ClassyPrelude: primToIO :: (PrimBase m, (~) * PrimState m RealWorld) => m a -> IO a
+ ClassyPrelude: primToIO :: (PrimBase m, PrimState m ~ RealWorld) => m a -> IO a
- ClassyPrelude: primToPrim :: (PrimBase m1, PrimMonad m2, (~) * PrimState m1 PrimState m2) => m1 a -> m2 a
+ ClassyPrelude: primToPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
- ClassyPrelude: type Reader r = ReaderT * r Identity
+ ClassyPrelude: type Reader r = ReaderT r Identity
- ClassyPrelude: unzip :: Zip f => forall a b. () => f (a, b) -> (f a, f b)
+ ClassyPrelude: unzip :: Zip f => f (a, b) -> (f a, f b)
- ClassyPrelude: unzip3 :: Zip3 f => forall a b c. () => f (a, b, c) -> (f a, f b, f c)
+ ClassyPrelude: unzip3 :: Zip3 f => f (a, b, c) -> (f a, f b, f c)
- ClassyPrelude: unzip4 :: Zip4 f => forall a b c d. () => f (a, b, c, d) -> (f a, f b, f c, f d)
+ ClassyPrelude: unzip4 :: Zip4 f => f (a, b, c, d) -> (f a, f b, f c, f d)
- ClassyPrelude: unzip5 :: Zip5 f => forall a b c d e. () => f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
+ ClassyPrelude: unzip5 :: Zip5 f => f (a, b, c, d, e) -> (f a, f b, f c, f d, f e)
- ClassyPrelude: unzip6 :: Zip6 f => forall a b c d e g. () => f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
+ ClassyPrelude: unzip6 :: Zip6 f => f (a, b, c, d, e, g) -> (f a, f b, f c, f d, f e, f g)
- ClassyPrelude: unzip7 :: Zip7 f => forall a b c d e g h. () => f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
+ ClassyPrelude: unzip7 :: Zip7 f => f (a, b, c, d, e, g, h) -> (f a, f b, f c, f d, f e, f g, f h)
- ClassyPrelude: zip :: Zip f => forall a b. () => f a -> f b -> f (a, b)
+ ClassyPrelude: zip :: Zip f => f a -> f b -> f (a, b)
- ClassyPrelude: zip3 :: Zip3 f => forall a b c. () => f a -> f b -> f c -> f (a, b, c)
+ ClassyPrelude: zip3 :: Zip3 f => f a -> f b -> f c -> f (a, b, c)
- ClassyPrelude: zip4 :: Zip4 f => forall a b c d. () => f a -> f b -> f c -> f d -> f (a, b, c, d)
+ ClassyPrelude: zip4 :: Zip4 f => f a -> f b -> f c -> f d -> f (a, b, c, d)
- ClassyPrelude: zip5 :: Zip5 f => forall a b c d e. () => f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
+ ClassyPrelude: zip5 :: Zip5 f => f a -> f b -> f c -> f d -> f e -> f (a, b, c, d, e)
- ClassyPrelude: zip6 :: Zip6 f => forall a b c d e g. () => f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
+ ClassyPrelude: zip6 :: Zip6 f => f a -> f b -> f c -> f d -> f e -> f g -> f (a, b, c, d, e, g)
- ClassyPrelude: zip7 :: Zip7 f => forall a b c d e g h. () => f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
+ ClassyPrelude: zip7 :: Zip7 f => f a -> f b -> f c -> f d -> f e -> f g -> f h -> f (a, b, c, d, e, g, h)
- ClassyPrelude: zipWith :: Zip f => forall a b c. () => (a -> b -> c) -> f a -> f b -> f c
+ ClassyPrelude: zipWith :: Zip f => a -> b -> c -> f a -> f b -> f c
- ClassyPrelude: zipWith3 :: Zip3 f => forall a b c d. () => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
+ ClassyPrelude: zipWith3 :: Zip3 f => a -> b -> c -> d -> f a -> f b -> f c -> f d
- ClassyPrelude: zipWith4 :: Zip4 f => forall a b c d e. () => (a -> b -> c -> d -> e) -> f a -> f b -> f c -> f d -> f e
+ ClassyPrelude: zipWith4 :: Zip4 f => a -> b -> c -> d -> e -> f a -> f b -> f c -> f d -> f e
- ClassyPrelude: zipWith5 :: Zip5 f => forall a b c d e g. () => (a -> b -> c -> d -> e -> g) -> f a -> f b -> f c -> f d -> f e -> f g
+ ClassyPrelude: zipWith5 :: Zip5 f => a -> b -> c -> d -> e -> g -> f a -> f b -> f c -> f d -> f e -> f g
- ClassyPrelude: zipWith6 :: Zip6 f => forall a b c d e g h. () => (a -> b -> c -> d -> e -> g -> h) -> f a -> f b -> f c -> f d -> f e -> f g -> f h
+ ClassyPrelude: zipWith6 :: Zip6 f => a -> b -> c -> d -> e -> g -> h -> f a -> f b -> f c -> f d -> f e -> f g -> f h
- ClassyPrelude: zipWith7 :: Zip7 f => forall a b c d e g h i. () => (a -> b -> c -> d -> e -> g -> h -> i) -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i
+ ClassyPrelude: zipWith7 :: Zip7 f => a -> b -> c -> d -> e -> g -> h -> i -> f a -> f b -> f c -> f d -> f e -> f g -> f h -> f i

Files

ChangeLog.md view
@@ -1,3 +1,8 @@+## 1.5.0++* Removed `alwaysSTM` and `alwaysSucceedsSTM`. See+  <https://github.com/ghc-proposals/ghc-proposals/pull/77>+ ## 1.4.0  * Switch to `MonadUnliftIO`
classy-prelude.cabal view
@@ -1,11 +1,13 @@--- This file has been generated from package.yaml by hpack version 0.20.0.+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.30.0. -- -- see: https://github.com/sol/hpack ----- hash: 647ba4603b5d219a6d274f99659ecd7683c8279bf0090aac1a69da0927940ae9+-- hash: ed4a6b0e0086b4db58b2d21752faef28ac85000cdbd0a8397428671944432494  name:           classy-prelude-version:        1.4.0+version:        1.5.0 synopsis:       A typeclass-based Prelude. description:    See docs and README at <http://www.stackage.org/package/classy-prelude> category:       Control, Prelude@@ -16,11 +18,9 @@ license:        MIT license-file:   LICENSE build-type:     Simple-cabal-version:  >= 1.10- extra-source-files:-    ChangeLog.md     README.md+    ChangeLog.md  source-repository head   type: git
src/ClassyPrelude.hs view
@@ -25,8 +25,6 @@       -- ** UnliftIO reexports     , module UnliftIO       -- ** Mutable references-    , alwaysSTM-    , alwaysSucceedsSTM     , orElseSTM     , module Data.Mutable       -- ** STM Channels@@ -432,16 +430,6 @@     elem_by :: (a -> a -> Bool) -> a -> [a] -> Bool     elem_by _  _ []     = False     elem_by eq y (x:xs) = y `eq` x || elem_by eq y xs---- | Synonym for 'STM.always'.-alwaysSTM :: STM Bool -> STM ()-alwaysSTM = STM.always-{-# INLINE alwaysSTM #-}---- | Synonym for 'STM.alwaysSucceeds'.-alwaysSucceedsSTM :: STM a -> STM ()-alwaysSucceedsSTM = STM.alwaysSucceeds-{-# INLINE alwaysSucceedsSTM #-}  -- | Synonym for 'STM.orElse'. orElseSTM :: STM a -> STM a -> STM a