packages feed

aeson-better-errors 0.9.1.3 → 0.9.1.4

raw patch · 4 files changed

+26/−6 lines, 4 filesdep ~aesonPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: aeson

API changes (from Hackage documentation)

- Data.Aeson.BetterErrors: (.!) :: Functor m => ParseT err m a -> (err -> err') -> ParseT err' m a
+ Data.Aeson.BetterErrors: (.!) :: forall (m :: Type -> Type) err a err'. Functor m => ParseT err m a -> (err -> err') -> ParseT err' m a
- Data.Aeson.BetterErrors: (<|>) :: Monad m => ParseT err m a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors: (<|>) :: forall (m :: Type -> Type) err a. Monad m => ParseT err m a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors: asArray :: (Functor m, Monad m) => ParseT err m Array
+ Data.Aeson.BetterErrors: asArray :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Array
- Data.Aeson.BetterErrors: asBool :: (Functor m, Monad m) => ParseT err m Bool
+ Data.Aeson.BetterErrors: asBool :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Bool
- Data.Aeson.BetterErrors: asIntegral :: (Functor m, Monad m, Integral a) => ParseT err m a
+ Data.Aeson.BetterErrors: asIntegral :: forall (m :: Type -> Type) a err. (Functor m, Monad m, Integral a) => ParseT err m a
- Data.Aeson.BetterErrors: asNull :: (Functor m, Monad m) => ParseT err m ()
+ Data.Aeson.BetterErrors: asNull :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m ()
- Data.Aeson.BetterErrors: asObject :: (Functor m, Monad m) => ParseT err m Object
+ Data.Aeson.BetterErrors: asObject :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Object
- Data.Aeson.BetterErrors: asRealFloat :: (Functor m, Monad m, RealFloat a) => ParseT err m a
+ Data.Aeson.BetterErrors: asRealFloat :: forall (m :: Type -> Type) a err. (Functor m, Monad m, RealFloat a) => ParseT err m a
- Data.Aeson.BetterErrors: asScientific :: (Functor m, Monad m) => ParseT err m Scientific
+ Data.Aeson.BetterErrors: asScientific :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Scientific
- Data.Aeson.BetterErrors: asString :: (Functor m, Monad m) => ParseT err m String
+ Data.Aeson.BetterErrors: asString :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m String
- Data.Aeson.BetterErrors: asText :: (Functor m, Monad m) => ParseT err m Text
+ Data.Aeson.BetterErrors: asText :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Text
- Data.Aeson.BetterErrors: asValue :: (Functor m, Monad m) => ParseT err m Value
+ Data.Aeson.BetterErrors: asValue :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Value
- Data.Aeson.BetterErrors: data ParseT err m a
+ Data.Aeson.BetterErrors: data ParseT err (m :: Type -> Type) a
- Data.Aeson.BetterErrors: eachInArray :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [a]
+ Data.Aeson.BetterErrors: eachInArray :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m [a]
- Data.Aeson.BetterErrors: eachInObject :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]
+ Data.Aeson.BetterErrors: eachInObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]
- Data.Aeson.BetterErrors: eachInObjectWithKey :: (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]
+ Data.Aeson.BetterErrors: eachInObjectWithKey :: forall (m :: Type -> Type) err k a. (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]
- Data.Aeson.BetterErrors: forEachInObject :: (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]
+ Data.Aeson.BetterErrors: forEachInObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]
- Data.Aeson.BetterErrors: fromAesonParser :: (Functor m, Monad m) => FromJSON a => ParseT e m a
+ Data.Aeson.BetterErrors: fromAesonParser :: forall (m :: Type -> Type) a e. (Functor m, Monad m, FromJSON a) => ParseT e m a
- Data.Aeson.BetterErrors: key :: (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors: key :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors: keyMay :: (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors: keyMay :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors: keyOrDefault :: (Functor m, Monad m) => Text -> a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors: keyOrDefault :: forall (m :: Type -> Type) a err. (Functor m, Monad m) => Text -> a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors: mapError :: Functor m => (err -> err') -> ParseT err m a -> ParseT err' m a
+ Data.Aeson.BetterErrors: mapError :: forall (m :: Type -> Type) err err' a. Functor m => (err -> err') -> ParseT err m a -> ParseT err' m a
- Data.Aeson.BetterErrors: nth :: (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors: nth :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors: nthMay :: (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors: nthMay :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors: nthOrDefault :: (Functor m, Monad m) => Int -> a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors: nthOrDefault :: forall (m :: Type -> Type) a err. (Functor m, Monad m) => Int -> a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors: perhaps :: (Functor m, Monad m) => ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors: perhaps :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors: throwCustomError :: (Functor m, Monad m) => err -> ParseT err m a
+ Data.Aeson.BetterErrors: throwCustomError :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => err -> ParseT err m a
- Data.Aeson.BetterErrors: withArray :: (Functor m, Monad m) => (Array -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withArray :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Array -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withBool :: (Functor m, Monad m) => (Bool -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withBool :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Bool -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withIntegral :: (Functor m, Monad m, Integral a) => (a -> Either err b) -> ParseT err m b
+ Data.Aeson.BetterErrors: withIntegral :: forall (m :: Type -> Type) a err b. (Functor m, Monad m, Integral a) => (a -> Either err b) -> ParseT err m b
- Data.Aeson.BetterErrors: withObject :: (Functor m, Monad m) => (Object -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Object -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withRealFloat :: (Functor m, Monad m, RealFloat a) => (a -> Either err b) -> ParseT err m b
+ Data.Aeson.BetterErrors: withRealFloat :: forall (m :: Type -> Type) a err b. (Functor m, Monad m, RealFloat a) => (a -> Either err b) -> ParseT err m b
- Data.Aeson.BetterErrors: withScientific :: (Functor m, Monad m) => (Scientific -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withScientific :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Scientific -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withString :: (Functor m, Monad m) => (String -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withString :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (String -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withText :: (Functor m, Monad m) => (Text -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withText :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Text -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors: withValue :: (Functor m, Monad m) => (Value -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors: withValue :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Value -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: (.!) :: Functor m => ParseT err m a -> (err -> err') -> ParseT err' m a
+ Data.Aeson.BetterErrors.Internal: (.!) :: forall (m :: Type -> Type) err a err'. Functor m => ParseT err m a -> (err -> err') -> ParseT err' m a
- Data.Aeson.BetterErrors.Internal: (<|>) :: Monad m => ParseT err m a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: (<|>) :: forall (m :: Type -> Type) err a. Monad m => ParseT err m a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: ParseT :: ReaderT ParseReader (ExceptT (ParseError err) m) a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: ParseT :: ReaderT ParseReader (ExceptT (ParseError err) m) a -> ParseT err (m :: Type -> Type) a
- Data.Aeson.BetterErrors.Internal: as :: (Functor m, Monad m) => (Value -> Maybe a) -> JSONType -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: as :: forall (m :: Type -> Type) a err. (Functor m, Monad m) => (Value -> Maybe a) -> JSONType -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: asArray :: (Functor m, Monad m) => ParseT err m Array
+ Data.Aeson.BetterErrors.Internal: asArray :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Array
- Data.Aeson.BetterErrors.Internal: asBool :: (Functor m, Monad m) => ParseT err m Bool
+ Data.Aeson.BetterErrors.Internal: asBool :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Bool
- Data.Aeson.BetterErrors.Internal: asIntegral :: (Functor m, Monad m, Integral a) => ParseT err m a
+ Data.Aeson.BetterErrors.Internal: asIntegral :: forall (m :: Type -> Type) a err. (Functor m, Monad m, Integral a) => ParseT err m a
- Data.Aeson.BetterErrors.Internal: asNull :: (Functor m, Monad m) => ParseT err m ()
+ Data.Aeson.BetterErrors.Internal: asNull :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m ()
- Data.Aeson.BetterErrors.Internal: asObject :: (Functor m, Monad m) => ParseT err m Object
+ Data.Aeson.BetterErrors.Internal: asObject :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Object
- Data.Aeson.BetterErrors.Internal: asRealFloat :: (Functor m, Monad m, RealFloat a) => ParseT err m a
+ Data.Aeson.BetterErrors.Internal: asRealFloat :: forall (m :: Type -> Type) a err. (Functor m, Monad m, RealFloat a) => ParseT err m a
- Data.Aeson.BetterErrors.Internal: asScientific :: (Functor m, Monad m) => ParseT err m Scientific
+ Data.Aeson.BetterErrors.Internal: asScientific :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Scientific
- Data.Aeson.BetterErrors.Internal: asString :: (Functor m, Monad m) => ParseT err m String
+ Data.Aeson.BetterErrors.Internal: asString :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m String
- Data.Aeson.BetterErrors.Internal: asText :: (Functor m, Monad m) => ParseT err m Text
+ Data.Aeson.BetterErrors.Internal: asText :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Text
- Data.Aeson.BetterErrors.Internal: asValue :: (Functor m, Monad m) => ParseT err m Value
+ Data.Aeson.BetterErrors.Internal: asValue :: forall (m :: Type -> Type) err. (Functor m, Monad m) => ParseT err m Value
- Data.Aeson.BetterErrors.Internal: badSchema :: (Functor m, Monad m) => ErrorSpecifics err -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: badSchema :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ErrorSpecifics err -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: eachInArray :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [a]
+ Data.Aeson.BetterErrors.Internal: eachInArray :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m [a]
- Data.Aeson.BetterErrors.Internal: eachInObject :: (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]
+ Data.Aeson.BetterErrors.Internal: eachInObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m [(Text, a)]
- Data.Aeson.BetterErrors.Internal: eachInObjectWithKey :: (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]
+ Data.Aeson.BetterErrors.Internal: eachInObjectWithKey :: forall (m :: Type -> Type) err k a. (Functor m, Monad m) => (Text -> Either err k) -> ParseT err m a -> ParseT err m [(k, a)]
- Data.Aeson.BetterErrors.Internal: forEachInObject :: (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]
+ Data.Aeson.BetterErrors.Internal: forEachInObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Text -> ParseT err m a) -> ParseT err m [a]
- Data.Aeson.BetterErrors.Internal: fromAesonParser :: (Functor m, Monad m) => FromJSON a => ParseT e m a
+ Data.Aeson.BetterErrors.Internal: fromAesonParser :: forall (m :: Type -> Type) a e. (Functor m, Monad m, FromJSON a) => ParseT e m a
- Data.Aeson.BetterErrors.Internal: key :: (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: key :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: key' :: (Functor m, Monad m) => ParseT err m a -> Text -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: key' :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> Text -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: keyMay :: (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors.Internal: keyMay :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Text -> ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors.Internal: keyOrDefault :: (Functor m, Monad m) => Text -> a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: keyOrDefault :: forall (m :: Type -> Type) a err. (Functor m, Monad m) => Text -> a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: liftCustomT :: (Functor m, Monad m) => ExceptT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: liftCustomT :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ExceptT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: liftEither :: (Functor m, Monad m) => Either err a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: liftEither :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Either err a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: liftParse :: (Functor m, Monad m) => (Value -> Either (ErrorSpecifics err) a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: liftParse :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Value -> Either (ErrorSpecifics err) a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: liftParseT :: (Functor m, Monad m) => (Value -> ExceptT (ErrorSpecifics err) m a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: liftParseT :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Value -> ExceptT (ErrorSpecifics err) m a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: mapError :: Functor m => (err -> err') -> ParseT err m a -> ParseT err' m a
+ Data.Aeson.BetterErrors.Internal: mapError :: forall (m :: Type -> Type) err err' a. Functor m => (err -> err') -> ParseT err m a -> ParseT err' m a
- Data.Aeson.BetterErrors.Internal: mapParseT :: (ReaderT ParseReader (ExceptT (ParseError err) m) a -> ReaderT ParseReader (ExceptT (ParseError err') m') a') -> ParseT err m a -> ParseT err' m' a'
+ Data.Aeson.BetterErrors.Internal: mapParseT :: forall err (m :: Type -> Type) a err' (m' :: Type -> Type) a'. (ReaderT ParseReader (ExceptT (ParseError err) m) a -> ReaderT ParseReader (ExceptT (ParseError err') m') a') -> ParseT err m a -> ParseT err' m' a'
- Data.Aeson.BetterErrors.Internal: newtype ParseT err m a
+ Data.Aeson.BetterErrors.Internal: newtype ParseT err (m :: Type -> Type) a
- Data.Aeson.BetterErrors.Internal: nth :: (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: nth :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: nth' :: (Functor m, Monad m) => ParseT err m a -> Int -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: nth' :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> Int -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: nthMay :: (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors.Internal: nthMay :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => Int -> ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors.Internal: nthOrDefault :: (Functor m, Monad m) => Int -> a -> ParseT err m a -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: nthOrDefault :: forall (m :: Type -> Type) a err. (Functor m, Monad m) => Int -> a -> ParseT err m a -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: perhaps :: (Functor m, Monad m) => ParseT err m a -> ParseT err m (Maybe a)
+ Data.Aeson.BetterErrors.Internal: perhaps :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => ParseT err m a -> ParseT err m (Maybe a)
- Data.Aeson.BetterErrors.Internal: throwCustomError :: (Functor m, Monad m) => err -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: throwCustomError :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => err -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: with :: (Functor m, Monad m) => ParseT err m a -> (a -> Either err b) -> ParseT err m b
+ Data.Aeson.BetterErrors.Internal: with :: forall (m :: Type -> Type) err a b. (Functor m, Monad m) => ParseT err m a -> (a -> Either err b) -> ParseT err m b
- Data.Aeson.BetterErrors.Internal: withArray :: (Functor m, Monad m) => (Array -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withArray :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Array -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withBool :: (Functor m, Monad m) => (Bool -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withBool :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Bool -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withIntegral :: (Functor m, Monad m, Integral a) => (a -> Either err b) -> ParseT err m b
+ Data.Aeson.BetterErrors.Internal: withIntegral :: forall (m :: Type -> Type) a err b. (Functor m, Monad m, Integral a) => (a -> Either err b) -> ParseT err m b
- Data.Aeson.BetterErrors.Internal: withObject :: (Functor m, Monad m) => (Object -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withObject :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Object -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withRealFloat :: (Functor m, Monad m, RealFloat a) => (a -> Either err b) -> ParseT err m b
+ Data.Aeson.BetterErrors.Internal: withRealFloat :: forall (m :: Type -> Type) a err b. (Functor m, Monad m, RealFloat a) => (a -> Either err b) -> ParseT err m b
- Data.Aeson.BetterErrors.Internal: withScientific :: (Functor m, Monad m) => (Scientific -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withScientific :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Scientific -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withString :: (Functor m, Monad m) => (String -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withString :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (String -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withText :: (Functor m, Monad m) => (Text -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withText :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Text -> Either err a) -> ParseT err m a
- Data.Aeson.BetterErrors.Internal: withValue :: (Functor m, Monad m) => (Value -> Either err a) -> ParseT err m a
+ Data.Aeson.BetterErrors.Internal: withValue :: forall (m :: Type -> Type) err a. (Functor m, Monad m) => (Value -> Either err a) -> ParseT err m a

Files

CHANGELOG.md view
@@ -1,5 +1,14 @@ # Revision history for aeson-better-errors +## 0.9.1.4++* Drop aeson upper bound++  Yes I know that PVP wants me to not do this, but it's practically extremely+  unlikely that a new version of aeson will ever break the parts of it that+  this package depends on++ ## 0.9.1.3  * Make compabible with aeson <2.3
LICENSE view
@@ -1,4 +1,4 @@-Copyright (c) 2015 Harry Garrood+Copyright (c) 2026 Harry Garrood  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the
README.md view
@@ -5,3 +5,9 @@  * Announcement blog post / tutorial: <http://harry.garrood.me/blog/aeson-better-errors/> * Hackage: <https://hackage.haskell.org/package/aeson-better-errors>++Note that since this package was released, aeson's default error output has+become much better. However, this library's error types provide more structure+than aeson's. If your use case benefits from structured errors, this library is+likely still a good choice, but otherwise, it's probably easier to use stock+aeson.
aeson-better-errors.cabal view
@@ -1,5 +1,6 @@+cabal-version:       3.0 name:                aeson-better-errors-version:             0.9.1.3+version:             0.9.1.4 synopsis:            Better error messages when decoding JSON values. license:             MIT license-file:        LICENSE@@ -8,9 +9,13 @@ homepage:            https://github.com/hdgarrood/aeson-better-errors category:            Text, Web, JSON build-type:          Simple-cabal-version:       >=1.10-extra-source-files:  README.md-                   , CHANGELOG.md+extra-doc-files:+  , README.md+  , CHANGELOG.md+tested-with:+  , GHC == 9.12.4+  , GHC == 9.10.3+  , GHC == 9.8.4  description:   A small package which gives you the tools to build parsers to decode JSON@@ -27,7 +32,7 @@                      Data.Aeson.BetterErrors.Internal   other-modules:     Data.Aeson.BetterErrors.Utils   build-depends:     base >=4.5 && <5-                   , aeson >=0.7 && <1.6 || >=2.0 && <2.3+                   , aeson >=0.7 && <1.6 || >=2.0                    , unordered-containers >=0.2                    , dlist >=1.0                    , text >=2.0