loc 0.1.3.2 → 0.1.3.3

raw patch · 2 files changed

+6/−4 lines, 2 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

- Data.Loc.Area: instance Data.Semigroup.Semigroup Data.Loc.Area.Area

+ Data.Loc.Area: instance GHC.Base.Semigroup Data.Loc.Area.Area

+ Data.Loc.Internal.Prelude: ($) :: () => a -> b -> a -> b

+ Data.Loc.Internal.Prelude: ($>) :: Functor f => f a -> b -> f b

+ Data.Loc.Internal.Prelude: (&&) :: Bool -> Bool -> Bool

+ Data.Loc.Internal.Prelude: (&) :: () => a -> a -> b -> b

+ Data.Loc.Internal.Prelude: (*>) :: Applicative f => f a -> f b -> f b

+ Data.Loc.Internal.Prelude: (.) :: () => b -> c -> a -> b -> a -> c

+ Data.Loc.Internal.Prelude: (/) :: Fractional a => a -> a -> a

+ Data.Loc.Internal.Prelude: (/=) :: Eq a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (:|) :: a -> [a] -> NonEmpty a

+ Data.Loc.Internal.Prelude: (<$) :: Functor f => a -> f b -> f a

+ Data.Loc.Internal.Prelude: (<$>) :: Functor f => a -> b -> f a -> f b

+ Data.Loc.Internal.Prelude: (<) :: Ord a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (<*) :: Applicative f => f a -> f b -> f a

+ Data.Loc.Internal.Prelude: (<*>) :: Applicative f => f a -> b -> f a -> f b

+ Data.Loc.Internal.Prelude: (<<<) :: Category cat => cat b c -> cat a b -> cat a c

+ Data.Loc.Internal.Prelude: (<=) :: Ord a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (<>) :: Semigroup a => a -> a -> a

+ Data.Loc.Internal.Prelude: (==) :: Eq a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (>) :: Ord a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (>=) :: Ord a => a -> a -> Bool

+ Data.Loc.Internal.Prelude: (>>) :: Monad m => m a -> m b -> m b

+ Data.Loc.Internal.Prelude: (>>=) :: Monad m => m a -> a -> m b -> m b

+ Data.Loc.Internal.Prelude: (>>>) :: Category cat => cat a b -> cat b c -> cat a c

+ Data.Loc.Internal.Prelude: (||) :: Bool -> Bool -> Bool

+ Data.Loc.Internal.Prelude: Denormal :: ArithException

+ Data.Loc.Internal.Prelude: DivideByZero :: ArithException

+ Data.Loc.Internal.Prelude: EQ :: Ordering

+ Data.Loc.Internal.Prelude: False :: Bool

+ Data.Loc.Internal.Prelude: GT :: Ordering

+ Data.Loc.Internal.Prelude: Just :: a -> Maybe a

+ Data.Loc.Internal.Prelude: LT :: Ordering

+ Data.Loc.Internal.Prelude: LossOfPrecision :: ArithException

+ Data.Loc.Internal.Prelude: Nothing :: Maybe a

+ Data.Loc.Internal.Prelude: Overflow :: ArithException

+ Data.Loc.Internal.Prelude: RatioZeroDenominator :: ArithException

+ Data.Loc.Internal.Prelude: True :: Bool

+ Data.Loc.Internal.Prelude: Underflow :: ArithException

+ Data.Loc.Internal.Prelude: bimap :: Bifunctor p => a -> b -> c -> d -> p a c -> p b d

+ Data.Loc.Internal.Prelude: catMaybes :: () => [Maybe a] -> [a]

+ Data.Loc.Internal.Prelude: class Bifunctor (p :: * -> * -> *)

+ Data.Loc.Internal.Prelude: class Enum a

+ Data.Loc.Internal.Prelude: class Eq a

+ Data.Loc.Internal.Prelude: class (Typeable e, Show e) => Exception e

+ Data.Loc.Internal.Prelude: class Foldable (t :: * -> *)

+ Data.Loc.Internal.Prelude: class Functor (f :: * -> *)

+ Data.Loc.Internal.Prelude: class (Real a, Enum a) => Integral a

+ Data.Loc.Internal.Prelude: class Applicative m => Monad (m :: * -> *)

+ Data.Loc.Internal.Prelude: class Semigroup a => Monoid a

+ Data.Loc.Internal.Prelude: class Eq a => Ord a

+ Data.Loc.Internal.Prelude: class Read a

+ Data.Loc.Internal.Prelude: class (Num a, Ord a) => Real a

+ Data.Loc.Internal.Prelude: class Semigroup a

+ Data.Loc.Internal.Prelude: class Show a

+ Data.Loc.Internal.Prelude: compare :: Ord a => a -> a -> Ordering

+ Data.Loc.Internal.Prelude: const :: () => a -> b -> a

+ Data.Loc.Internal.Prelude: data ArithException

+ Data.Loc.Internal.Prelude: data Bool

+ Data.Loc.Internal.Prelude: data Double

+ Data.Loc.Internal.Prelude: data IO a

+ Data.Loc.Internal.Prelude: data Int

+ Data.Loc.Internal.Prelude: data Map k a

+ Data.Loc.Internal.Prelude: data Maybe a

+ Data.Loc.Internal.Prelude: data Natural

+ Data.Loc.Internal.Prelude: data NonEmpty a

+ Data.Loc.Internal.Prelude: data Ordering

+ Data.Loc.Internal.Prelude: data ReadPrec a

+ Data.Loc.Internal.Prelude: data Set a

+ Data.Loc.Internal.Prelude: div :: Integral a => a -> a -> a

+ Data.Loc.Internal.Prelude: elem :: (Foldable t, Eq a) => a -> t a -> Bool

+ Data.Loc.Internal.Prelude: empty :: Alternative f => f a

+ Data.Loc.Internal.Prelude: enumFrom :: Enum a => a -> [a]

+ Data.Loc.Internal.Prelude: enumFromThen :: Enum a => a -> a -> [a]

+ Data.Loc.Internal.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]

+ Data.Loc.Internal.Prelude: enumFromTo :: Enum a => a -> a -> [a]

+ Data.Loc.Internal.Prelude: exitFailure :: () => IO a

+ Data.Loc.Internal.Prelude: fail :: Monad m => String -> m a

+ Data.Loc.Internal.Prelude: first :: Bifunctor p => a -> b -> p a c -> p b c

+ Data.Loc.Internal.Prelude: flip :: () => a -> b -> c -> b -> a -> c

+ Data.Loc.Internal.Prelude: fmap :: Functor f => a -> b -> f a -> f b

+ Data.Loc.Internal.Prelude: fold :: (Foldable t, Monoid m) => t m -> m

+ Data.Loc.Internal.Prelude: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m

+ Data.Loc.Internal.Prelude: foldl :: Foldable t => b -> a -> b -> b -> t a -> b

+ Data.Loc.Internal.Prelude: foldl' :: Foldable t => b -> a -> b -> b -> t a -> b

+ Data.Loc.Internal.Prelude: foldl1 :: Foldable t => a -> a -> a -> t a -> a

+ Data.Loc.Internal.Prelude: foldr :: Foldable t => a -> b -> b -> b -> t a -> b

+ Data.Loc.Internal.Prelude: foldr' :: Foldable t => a -> b -> b -> b -> t a -> b

+ Data.Loc.Internal.Prelude: foldr1 :: Foldable t => a -> a -> a -> t a -> a

+ Data.Loc.Internal.Prelude: fromEnum :: Enum a => a -> Int

+ Data.Loc.Internal.Prelude: fromIntegral :: (Integral a, Num b) => a -> b

+ Data.Loc.Internal.Prelude: fst :: () => (a, b) -> a

+ Data.Loc.Internal.Prelude: guard :: Alternative f => Bool -> f ()

+ Data.Loc.Internal.Prelude: id :: () => a -> a

+ Data.Loc.Internal.Prelude: infixl 0 `on`

+ Data.Loc.Internal.Prelude: infixl 1 &

+ Data.Loc.Internal.Prelude: infixl 4 <$>

+ Data.Loc.Internal.Prelude: infixl 7 /

+ Data.Loc.Internal.Prelude: infixr 0 $

+ Data.Loc.Internal.Prelude: infixr 1 <<<

+ Data.Loc.Internal.Prelude: infixr 2 ||

+ Data.Loc.Internal.Prelude: infixr 3 &&

+ Data.Loc.Internal.Prelude: infixr 9 .

+ Data.Loc.Internal.Prelude: length :: Foldable t => t a -> Int

+ Data.Loc.Internal.Prelude: mapAccumL :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)

+ Data.Loc.Internal.Prelude: mappend :: Monoid a => a -> a -> a

+ Data.Loc.Internal.Prelude: max :: Ord a => a -> a -> a

+ Data.Loc.Internal.Prelude: maximum :: (Foldable t, Ord a) => t a -> a

+ Data.Loc.Internal.Prelude: maybe :: () => b -> a -> b -> Maybe a -> b

+ Data.Loc.Internal.Prelude: mconcat :: Monoid a => [a] -> a

+ Data.Loc.Internal.Prelude: mempty :: Monoid a => a

+ Data.Loc.Internal.Prelude: mfilter :: MonadPlus m => a -> Bool -> m a -> m a

+ Data.Loc.Internal.Prelude: min :: Ord a => a -> a -> a

+ Data.Loc.Internal.Prelude: minPrec :: Prec

+ Data.Loc.Internal.Prelude: minimum :: (Foldable t, Ord a) => t a -> a

+ Data.Loc.Internal.Prelude: not :: Bool -> Bool

+ Data.Loc.Internal.Prelude: null :: Foldable t => t a -> Bool

+ Data.Loc.Internal.Prelude: on :: () => b -> b -> c -> a -> b -> a -> a -> c

+ Data.Loc.Internal.Prelude: otherwise :: Bool

+ Data.Loc.Internal.Prelude: pred :: Enum a => a -> a

+ Data.Loc.Internal.Prelude: print :: Show a => a -> IO ()

+ Data.Loc.Internal.Prelude: product :: (Foldable t, Num a) => t a -> a

+ Data.Loc.Internal.Prelude: pure :: Applicative f => a -> f a

+ Data.Loc.Internal.Prelude: quotRem :: Integral a => a -> a -> (a, a)

+ Data.Loc.Internal.Prelude: read :: Read a => String -> a

+ Data.Loc.Internal.Prelude: readList :: Read a => ReadS [a]

+ Data.Loc.Internal.Prelude: readListPrec :: Read a => ReadPrec [a]

+ Data.Loc.Internal.Prelude: readP_to_Prec :: () => Int -> ReadP a -> ReadPrec a

+ Data.Loc.Internal.Prelude: readPrec :: Read a => ReadPrec a

+ Data.Loc.Internal.Prelude: readPrec_to_S :: () => ReadPrec a -> Int -> ReadS a

+ Data.Loc.Internal.Prelude: readsPrec :: Read a => Int -> ReadS a

+ Data.Loc.Internal.Prelude: return :: Monad m => a -> m a

+ Data.Loc.Internal.Prelude: round :: (RealFrac a, Integral b) => a -> b

+ Data.Loc.Internal.Prelude: sconcat :: Semigroup a => NonEmpty a -> a

+ Data.Loc.Internal.Prelude: second :: Bifunctor p => b -> c -> p a b -> p a c

+ Data.Loc.Internal.Prelude: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a

+ Data.Loc.Internal.Prelude: show :: Show a => a -> String

+ Data.Loc.Internal.Prelude: showList :: Show a => [a] -> ShowS

+ Data.Loc.Internal.Prelude: showString :: String -> ShowS

+ Data.Loc.Internal.Prelude: shows :: Show a => a -> ShowS

+ Data.Loc.Internal.Prelude: showsPrec :: Show a => Int -> a -> ShowS

+ Data.Loc.Internal.Prelude: snd :: () => (a, b) -> b

+ Data.Loc.Internal.Prelude: sqrt :: Floating a => a -> a

+ Data.Loc.Internal.Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a

+ Data.Loc.Internal.Prelude: succ :: Enum a => a -> a

+ Data.Loc.Internal.Prelude: sum :: (Foldable t, Num a) => t a -> a

+ Data.Loc.Internal.Prelude: throw :: Exception e => e -> a

+ Data.Loc.Internal.Prelude: toEnum :: Enum a => Int -> a

+ Data.Loc.Internal.Prelude: toInteger :: Integral a => a -> Integer

+ Data.Loc.Internal.Prelude: toList :: Foldable t => t a -> [a]

+ Data.Loc.Internal.Prelude: toRational :: Real a => a -> Rational

+ Data.Loc.Internal.Prelude: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b

+ Data.Loc.Internal.Prelude: traverse_ :: (Foldable t, Applicative f) => a -> f b -> t a -> f ()

+ Data.Loc.Internal.Prelude: type ShowS = String -> String

+ Data.Loc.Internal.Prelude: type String = [Char]

+ Data.Loc.Internal.Prelude: undefined :: HasCallStack => a

+ Data.Loc.Internal.Prelude: void :: Functor f => f a -> f ()

+ Data.Loc.Internal.Prelude: when :: Applicative f => Bool -> f () -> f ()

Files

loc.cabal +4/−4
src/Data/Loc/Area.hs +2/−0

loc.cabal view

@@ -1,5 +1,5 @@ name: loc-version: 0.1.3.2+version: 0.1.3.3  synopsis: Types representing line and column positions and ranges in text files. @@ -34,7 +34,7 @@   default-extensions: NoImplicitPrelude   ghc-options: -Wall   build-depends:-      base >=4.9 && <4.11+      base >=4.9 && <4.12     , containers   exposed-modules:       Data.Loc@@ -57,7 +57,7 @@   default-extensions: NoImplicitPrelude   ghc-options: -Wall -threaded   build-depends:-      base >=4.9 && <4.11+      base >=4.9 && <4.12     , containers     , doctest     , loc@@ -70,7 +70,7 @@   default-extensions: NoImplicitPrelude   ghc-options: -Wall -threaded   build-depends:-      base >=4.9 && <4.11+      base >=4.9 && <4.12     , containers     , hedgehog     , loc

src/Data/Loc/Area.hs view

@@ -73,6 +73,8 @@  -- | '<>' = '+' instance Semigroup Area+  where+    (<>) = (+)  areaShowsPrec :: Int -> Area -> ShowS areaShowsPrec _ a =