packages feed

classy-prelude 1.5.0 → 1.5.0.1

raw patch · 3 files changed

+37/−22 lines, 3 filesdep −semigroupsdep ~basedep ~timePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies removed: semigroups

Dependency ranges changed: base, time

API changes (from Hackage documentation)

- ClassyPrelude: fail :: Monad m => String -> m a
- ClassyPrelude: newtype ReaderT r (m :: k -> *) (a :: k) :: forall k. () => * -> k -> * -> k -> *
+ ClassyPrelude: [getDown] :: Down a -> a
+ ClassyPrelude: infix 4 >=
+ ClassyPrelude: infixl 1 >>
+ ClassyPrelude: infixl 6 +
+ ClassyPrelude: infixl 7 *
+ ClassyPrelude: infixr 6 <>
+ ClassyPrelude: isResourceVanishedError :: IOError -> Bool
+ ClassyPrelude: isResourceVanishedErrorType :: IOErrorType -> Bool
+ ClassyPrelude: newtype ReaderT r (m :: Type -> Type) a
+ ClassyPrelude: resourceVanishedErrorType :: IOErrorType
- ClassyPrelude: ($!!) :: NFData a => a -> b -> a -> b
+ ClassyPrelude: ($!!) :: NFData a => (a -> b) -> a -> b
- ClassyPrelude: ($!) :: () => a -> b -> a -> b
+ ClassyPrelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- ClassyPrelude: ($) :: () => a -> b -> a -> b
+ ClassyPrelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- ClassyPrelude: (.) :: Category cat => cat b c -> cat a b -> cat a c
+ ClassyPrelude: (.) :: forall (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- ClassyPrelude: (<$>) :: Functor f => a -> b -> f a -> f b
+ ClassyPrelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
- ClassyPrelude: (<**>) :: Applicative f => f a -> f a -> b -> f b
+ ClassyPrelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- ClassyPrelude: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ ClassyPrelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- ClassyPrelude: (<=<) :: Monad m => b -> m c -> a -> m b -> a -> m c
+ ClassyPrelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- ClassyPrelude: (=<<) :: Monad m => a -> m b -> m a -> m b
+ ClassyPrelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- ClassyPrelude: (>=>) :: Monad m => a -> m b -> b -> m c -> a -> m c
+ ClassyPrelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- ClassyPrelude: (>>=) :: Monad m => m a -> a -> m b -> m b
+ ClassyPrelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- ClassyPrelude: ReaderT :: r -> m a -> ReaderT r
+ ClassyPrelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- ClassyPrelude: [runReaderT] :: ReaderT r -> r -> m a
+ ClassyPrelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- ClassyPrelude: ap :: Monad m => m a -> b -> m a -> m b
+ ClassyPrelude: ap :: Monad m => m (a -> b) -> m a -> m b
- ClassyPrelude: asTypeOf :: () => a -> a -> a
+ ClassyPrelude: asTypeOf :: a -> a -> a
- ClassyPrelude: asks :: MonadReader r m => r -> a -> m a
+ ClassyPrelude: asks :: MonadReader r m => (r -> a) -> m a
- ClassyPrelude: asum :: (Foldable t, Alternative f) => t f a -> f a
+ ClassyPrelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
- ClassyPrelude: bool :: () => a -> a -> Bool -> a
+ ClassyPrelude: bool :: a -> a -> Bool -> a
- ClassyPrelude: class Applicative f => Alternative (f :: * -> *)
+ ClassyPrelude: class Applicative f => Alternative (f :: Type -> Type)
- ClassyPrelude: class Functor f => Applicative (f :: * -> *)
+ ClassyPrelude: class Functor f => Applicative (f :: Type -> Type)
- ClassyPrelude: class Foldable (t :: * -> *)
+ ClassyPrelude: class Foldable (t :: Type -> Type)
- ClassyPrelude: class Functor (f :: * -> *)
+ ClassyPrelude: class Functor (f :: Type -> Type)
- ClassyPrelude: class Hashable a
+ ClassyPrelude: class Eq a => Hashable a
- ClassyPrelude: class Applicative m => Monad (m :: * -> *)
+ ClassyPrelude: class Applicative m => Monad (m :: Type -> Type)
- ClassyPrelude: class Monad m => MonadIO (m :: * -> *)
+ ClassyPrelude: class Monad m => MonadIO (m :: Type -> Type)
- ClassyPrelude: class (Alternative m, Monad m) => MonadPlus (m :: * -> *)
+ ClassyPrelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
- ClassyPrelude: class Monad m => MonadReader r (m :: * -> *) | m -> r
+ ClassyPrelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
- ClassyPrelude: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ ClassyPrelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- ClassyPrelude: comparing :: Ord a => b -> a -> b -> b -> Ordering
+ ClassyPrelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- ClassyPrelude: const :: () => a -> b -> a
+ ClassyPrelude: const :: a -> b -> a
- ClassyPrelude: curry :: () => (a, b) -> c -> a -> b -> c
+ ClassyPrelude: curry :: ((a, b) -> c) -> a -> b -> c
- ClassyPrelude: either :: () => a -> c -> b -> c -> Either a b -> c
+ ClassyPrelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- ClassyPrelude: equating :: Eq a => b -> a -> b -> b -> Bool
+ ClassyPrelude: equating :: Eq a => (b -> a) -> b -> b -> Bool
- ClassyPrelude: error :: HasCallStack => [Char] -> a
+ ClassyPrelude: error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a
- ClassyPrelude: flip :: () => a -> b -> c -> b -> a -> c
+ ClassyPrelude: flip :: (a -> b -> c) -> b -> a -> c
- ClassyPrelude: fmap :: Functor f => a -> b -> f a -> f 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: 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: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- ClassyPrelude: fromMaybe :: () => a -> Maybe a -> a
+ ClassyPrelude: fromMaybe :: a -> Maybe a -> a
- ClassyPrelude: fst :: () => (a, b) -> a
+ ClassyPrelude: fst :: (a, b) -> a
- ClassyPrelude: id :: Category cat => cat a a
+ ClassyPrelude: id :: forall (a :: k). Category cat => cat a a
- ClassyPrelude: infixl 0 `on`
+ ClassyPrelude: infixl 0 `hashWithSalt`
- ClassyPrelude: ioError :: () => IOError -> IO a
+ ClassyPrelude: ioError :: IOError -> IO a
- ClassyPrelude: isJust :: () => Maybe a -> Bool
+ ClassyPrelude: isJust :: Maybe a -> Bool
- ClassyPrelude: isNothing :: () => Maybe a -> Bool
+ ClassyPrelude: isNothing :: Maybe a -> Bool
- ClassyPrelude: join :: Monad m => m m a -> m a
+ ClassyPrelude: join :: Monad m => m (m a) -> m a
- ClassyPrelude: lefts :: () => [Either a b] -> [a]
+ ClassyPrelude: lefts :: [Either a b] -> [a]
- ClassyPrelude: liftA :: Applicative f => a -> b -> f a -> f b
+ ClassyPrelude: liftA :: Applicative f => (a -> b) -> f a -> f b
- ClassyPrelude: liftA2 :: Applicative f => a -> b -> c -> f a -> f b -> f c
+ 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: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- ClassyPrelude: liftM :: Monad m => a1 -> r -> m a1 -> m r
+ ClassyPrelude: liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- ClassyPrelude: liftM2 :: Monad m => a1 -> a2 -> r -> m a1 -> m a2 -> 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: 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: 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: 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: listToMaybe :: [a] -> Maybe a
- ClassyPrelude: mapM :: (Traversable t, Monad m) => a -> m b -> t a -> m t b
+ ClassyPrelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- ClassyPrelude: mapMaybe :: () => a -> Maybe b -> [a] -> [b]
+ ClassyPrelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- ClassyPrelude: maybe :: () => b -> a -> b -> Maybe a -> b
+ ClassyPrelude: maybe :: b -> (a -> b) -> Maybe a -> b
- ClassyPrelude: maybeToList :: () => Maybe a -> [a]
+ ClassyPrelude: maybeToList :: Maybe a -> [a]
- ClassyPrelude: modifyIOError :: () => IOError -> IOError -> IO a -> IO a
+ ClassyPrelude: modifyIOError :: (IOError -> IOError) -> IO a -> IO a
- ClassyPrelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c
+ ClassyPrelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- ClassyPrelude: optional :: Alternative f => f a -> f Maybe a
+ ClassyPrelude: optional :: Alternative f => f a -> f (Maybe a)
- ClassyPrelude: ordNub :: (Ord a) => [a] -> [a]
+ ClassyPrelude: ordNub :: Ord a => [a] -> [a]
- ClassyPrelude: ordNubBy :: (Ord b) => (a -> b) -> (a -> a -> Bool) -> [a] -> [a]
+ ClassyPrelude: ordNubBy :: Ord b => (a -> b) -> (a -> a -> Bool) -> [a] -> [a]
- ClassyPrelude: parseTimeM :: (Monad m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
+ ClassyPrelude: parseTimeM :: (MonadFail m, ParseTime t) => Bool -> TimeLocale -> String -> String -> m t
- ClassyPrelude: partitionEithers :: () => [Either a b] -> ([a], [b])
+ ClassyPrelude: partitionEithers :: [Either a b] -> ([a], [b])
- ClassyPrelude: primToST :: PrimBase m => m a -> ST PrimState m a
+ ClassyPrelude: primToST :: PrimBase m => m a -> ST (PrimState m) a
- ClassyPrelude: repeat :: () => a -> [a]
+ ClassyPrelude: repeat :: a -> [a]
- ClassyPrelude: rights :: () => [Either a b] -> [b]
+ ClassyPrelude: rights :: [Either a b] -> [b]
- ClassyPrelude: seq :: () => a -> b -> b
+ ClassyPrelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- ClassyPrelude: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ 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: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- ClassyPrelude: snd :: () => (a, b) -> b
+ ClassyPrelude: snd :: (a, b) -> b
- ClassyPrelude: swap :: () => (a, b) -> (b, a)
+ ClassyPrelude: swap :: (a, b) -> (b, a)
- ClassyPrelude: traceM :: (Monad m) => String -> m ()
+ ClassyPrelude: traceM :: Monad m => String -> m ()
- ClassyPrelude: traceShowId :: (Show a) => a -> a
+ ClassyPrelude: traceShowId :: Show a => a -> a
- ClassyPrelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ ClassyPrelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- ClassyPrelude: tryIOError :: () => IO a -> IO Either IOError a
+ ClassyPrelude: tryIOError :: IO a -> IO (Either IOError a)
- ClassyPrelude: uncurry :: () => a -> b -> c -> (a, b) -> c
+ ClassyPrelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- ClassyPrelude: until :: () => a -> Bool -> a -> a -> a -> a
+ ClassyPrelude: until :: (a -> Bool) -> (a -> a) -> a -> a
- ClassyPrelude: zipWith :: Zip f => 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 => 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 => 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 => 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 => 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 => 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,10 @@+# ChangeLog for classy-prelude++## 1.5.0.1++* Export a compatiblity shim for `parseTime` as it has been removed in `time-1.10`.+  See <https://hackage.haskell.org/package/time-1.12/changelog>+ ## 1.5.0  * Removed `alwaysSTM` and `alwaysSucceedsSTM`. See
classy-prelude.cabal view
@@ -1,13 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.30.0.+-- This file has been generated from package.yaml by hpack version 0.34.4. -- -- see: https://github.com/sol/hpack------ hash: ed4a6b0e0086b4db58b2d21752faef28ac85000cdbd0a8397428671944432494  name:           classy-prelude-version:        1.5.0+version:        1.5.0.1 synopsis:       A typeclass-based Prelude. description:    See docs and README at <http://www.stackage.org/package/classy-prelude> category:       Control, Prelude@@ -27,12 +25,16 @@   location: https://github.com/snoyberg/mono-traversable  library+  exposed-modules:+      ClassyPrelude+  other-modules:+      Paths_classy_prelude   hs-source-dirs:       src   ghc-options: -Wall -fno-warn-orphans   build-depends:       async-    , base >=4.9 && <5+    , base >=4.13 && <5     , basic-prelude >=0.7     , bifunctors     , bytestring@@ -45,10 +47,9 @@     , mono-traversable >=1.0     , mono-traversable-instances     , mtl-    , mutable-containers >=0.3 && <0.4+    , mutable-containers ==0.3.*     , primitive     , say-    , semigroups     , stm     , stm-chans >=3     , text@@ -58,26 +59,22 @@     , unordered-containers     , vector     , vector-instances-  exposed-modules:-      ClassyPrelude-  other-modules:-      Paths_classy_prelude   default-language: Haskell2010  test-suite test   type: exitcode-stdio-1.0   main-is: main.hs+  other-modules:+      Paths_classy_prelude   hs-source-dirs:       test   ghc-options: -Wall   build-depends:       QuickCheck-    , base >=4.9 && <5+    , base >=4.13 && <5     , classy-prelude     , containers     , hspec >=1.3     , transformers     , unordered-containers-  other-modules:-      Paths_classy_prelude   default-language: Haskell2010
src/ClassyPrelude.hs view
@@ -47,6 +47,9 @@     , traceShowM       -- ** Time (since 0.6.1)     , module Data.Time+#if MIN_VERSION_time(1,10,0)+    , parseTime+#endif       -- ** Generics (since 0.8.1)     , Generic       -- ** Transformers (since 0.9.4)@@ -190,7 +193,9 @@     , toGregorian     , fromGregorian     , formatTime+#if !MIN_VERSION_time(1,10,0)     , parseTime+#endif     , parseTimeM     , getCurrentTime     , defaultTimeLocale@@ -201,6 +206,7 @@ import qualified Data.HashSet as HashSet  import GHC.Generics (Generic)+import GHC.Stack (HasCallStack)  import Control.Monad.Primitive (primToPrim, primToIO, primToST) import Data.Primitive.MutVar@@ -218,10 +224,6 @@ import Control.Concurrent.STM.TMQueue import qualified Control.Concurrent -#if MIN_VERSION_base(4,9,0)-import GHC.Stack (HasCallStack)-#endif- tshow :: Show a => a -> Text tshow = fromList . Prelude.show @@ -334,11 +336,7 @@ -- @"Prelude".'Prelude.undefined'@. -- -- Since 0.5.5-#if MIN_VERSION_base(4,9,0) undefined :: HasCallStack => a-#else-undefined :: a-#endif undefined = error "ClassyPrelude.undefined" {-# DEPRECATED undefined "It is highly recommended that you either avoid partial functions or provide meaningful error messages" #-} @@ -627,3 +625,16 @@ -- @since 1.3.1 interact :: MonadIO m => (LText -> LText) -> m () interact = liftIO . LTextIO.interact+++#if MIN_VERSION_time(1,10,0)+parseTime +  :: ParseTime t+  => TimeLocale -- ^ Time locale.+  -> String -- ^ Format string.+  -> String -- ^ Input string.+  -> Maybe t -- ^ The time value, or 'Nothing' if the input could not be parsed using the given format.+parseTime = parseTimeM True+#endif++