    {-# LANGUAGE NoImplicitPrelude          #-}
    {-# LANGUAGE CPP                        #-}
    {-# LANGUAGE DeriveDataTypeable         #-}
    {-# LANGUAGE DeriveGeneric              #-}
    {-# LANGUAGE FlexibleContexts           #-}
    {-# LANGUAGE PolyKinds                  #-}
    {-# LANGUAGE ScopedTypeVariables        #-}
    {-# LANGUAGE Trustworthy                #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Data.Semigroup
    -- Copyright   :  (C) 2011-2015 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  libraries@haskell.org
    -- Stability   :  provisional
    -- Portability :  portable
    --
    -- A type @a@ is a 'Semigroup' if it provides an associative function ('<>')
    -- that lets you combine any two values of type @a@ into one. Where being
    -- associative means that the following must always hold:
    --
    -- prop> (a <> b) <> c == a <> (b <> c)
    --
    -- ==== __Examples__
    --
    -- The 'Min' 'Semigroup' instance for 'Int' is defined to always pick the smaller
    -- number:
    --
    -- >>> Min 1 <> Min 2 <> Min 3 <> Min 4 :: Min Int
    -- Min {getMin = 1}
    --
    -- If we need to combine multiple values we can use the 'sconcat' function
    -- to do so. We need to ensure however that we have at least one value to
    -- operate on, since otherwise our result would be undefined. It is for this
    -- reason that 'sconcat' uses "Data.List.NonEmpty.NonEmpty" - a list that
    -- can never be empty:
    --
    -- >>> (1 :| [])
    -- 1 :| []               -- equivalent to [1] but guaranteed to be non-empty.
    --
    -- >>> (1 :| [2, 3, 4])
    -- 1 :| [2,3,4]          -- equivalent to [1,2,3,4] but guaranteed to be non-empty.
    --
    -- Equipped with this guaranteed to be non-empty data structure, we can combine
    -- values using 'sconcat' and a 'Semigroup' of our choosing. We can try the 'Min'
    -- and 'Max' instances of 'Int' which pick the smallest, or largest number
    -- respectively:
    --
    -- >>> sconcat (1 :| [2, 3, 4]) :: Min Int
    -- Min {getMin = 1}
    --
    -- >>> sconcat (1 :| [2, 3, 4]) :: Max Int
    -- Max {getMax = 4}
    --
    -- String concatenation is another example of a 'Semigroup' instance:
    --
    -- >>> "foo" <> "bar"
    -- "foobar"
    --
    -- A 'Semigroup' is a generalization of a 'Monoid'. Yet unlike the 'Semigroup', the 'Monoid'
    -- requires the presence of a neutral element ('mempty') in addition to the associative
    -- operator. The requirement for a neutral element prevents many types from being a full Monoid,
    -- like "Data.List.NonEmpty.NonEmpty".
    --
    -- Note that the use of @(\<\>)@ in this module conflicts with an operator with the same
    -- name that is being exported by "Data.Monoid". However, this package
    -- re-exports (most of) the contents of Data.Monoid, so to use semigroups
    -- and monoids in the same package just
    --
    -- > import Data.Semigroup
    --
    -- @since 4.9.0.0
    ----------------------------------------------------------------------------
    module Data.Semigroup (
        Semigroup(..)
      , stimesMonoid
      , stimesIdempotent
      , stimesIdempotentMonoid
      , mtimesDefault
      -- * Semigroups
      , Min(..)
      , Max(..)
      , First(..)
      , Last(..)
      , WrappedMonoid(..)
      -- * Re-exported monoids
      , Dual(..)
      , Endo(..)
      , All(..)
      , Any(..)
      , Sum(..)
      , Product(..)
      -- * Difference lists of a semigroup
      , diff
      , cycle1
      -- * ArgMin, ArgMax
      , Arg(..)
      , ArgMin
      , ArgMax
      ) where

    import           GHC.Internal.Base hiding (Any)
    import           GHC.Internal.Enum
    import           GHC.Internal.Show
    import           GHC.Internal.Read
    import           GHC.Internal.Num
    import           GHC.Internal.Real
    import           GHC.Internal.Data.Functor ((<$>))
    import           Data.Bifoldable
    import           Data.Bifunctor
    import           Data.Bitraversable
    import           GHC.Internal.Data.Foldable
    import           GHC.Internal.Data.Traversable
    import           GHC.Internal.Data.Semigroup.Internal
    import           GHC.Internal.Control.Monad.Fix
    import           GHC.Internal.Data.Data
    import           GHC.Generics
    import qualified GHC.Internal.List as List

    -- $setup
    -- >>> import Prelude
    -- >>> import Data.List.NonEmpty (NonEmpty (..))

    -- | A generalization of 'GHC.Internal.Data.List.cycle' to an arbitrary 'Semigroup'.
    -- May fail to terminate for some values in some semigroups.
    --
    -- ==== __Examples__
    --
    -- >>> take 10 $ cycle1 [1, 2, 3]
    -- [1,2,3,1,2,3,1,2,3,1]
    --
    -- >>> cycle1 (Right 1)
    -- Right 1
    --
    -- >>> cycle1 (Left 1)
    -- * hangs forever *
    cycle1 :: Semigroup m => m -> m
    cycle1 :: forall m. Semigroup m => m -> m
    cycle1 m
    xs = m
    xs' where xs' :: m
    xs' = m
    xs m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> m
    xs'

    -- | This lets you use a difference list of a 'Semigroup' as a 'Monoid'.
    --
    -- ==== __Examples__
    --
    -- > let hello = diff "Hello, "
    --
    -- >>> appEndo hello "World!"
    -- "Hello, World!"
    --
    -- >>> appEndo (hello <> mempty) "World!"
    -- "Hello, World!"
    --
    -- >>> appEndo (mempty <> hello) "World!"
    -- "Hello, World!"
    --
    -- > let world = diff "World"
    -- > let excl = diff "!"
    --
    -- >>> appEndo (hello <> (world <> excl)) mempty
    -- "Hello, World!"
    --
    -- >>> appEndo ((hello <> world) <> excl) mempty
    -- "Hello, World!"
    diff :: Semigroup m => m -> Endo m
    diff :: forall m. Semigroup m => m -> Endo m
    diff = (m -> m) -> Endo m
    forall a. (a -> a) -> Endo a
    Endo ((m -> m) -> Endo m) -> (m -> m -> m) -> m -> Endo m
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . m -> m -> m
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | The 'Min' 'Monoid' and 'Semigroup' always choose the smaller element as
    -- by the 'Ord' instance and 'min' of the contained type.
    --
    -- ==== __Examples__
    --
    -- >>> Min 42 <> Min 3
    -- Min 3
    --
    -- >>> sconcat $ Min 1 :| [ Min n | n <- [2 .. 100]]
    -- Min {getMin = 1}
    newtype Min a = Min { forall a. Min a -> a
    getMin :: a }
      deriving ( Min a
    Min a -> Min a -> Bounded (Min a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Min a
    $cminBound :: forall a. Bounded a => Min a
    minBound :: Min a
    $cmaxBound :: forall a. Bounded a => Min a
    maxBound :: Min a
    Bounded  -- ^ @since 4.9.0.0
               , Min a -> Min a -> Bool
    (Min a -> Min a -> Bool) -> (Min a -> Min a -> Bool) -> Eq (Min a)
    forall a. Eq a => Min a -> Min a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Min a -> Min a -> Bool
    == :: Min a -> Min a -> Bool
    $c/= :: forall a. Eq a => Min a -> Min a -> Bool
    /= :: Min a -> Min a -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (Min a)
    Eq (Min a) =>
    (Min a -> Min a -> Ordering)
    -> (Min a -> Min a -> Bool)
    -> (Min a -> Min a -> Bool)
    -> (Min a -> Min a -> Bool)
    -> (Min a -> Min a -> Bool)
    -> (Min a -> Min a -> Min a)
    -> (Min a -> Min a -> Min a)
    -> Ord (Min a)
    Min a -> Min a -> Bool
    Min a -> Min a -> Ordering
    Min a -> Min a -> Min a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (Min a)
    forall a. Ord a => Min a -> Min a -> Bool
    forall a. Ord a => Min a -> Min a -> Ordering
    forall a. Ord a => Min a -> Min a -> Min a
    $ccompare :: forall a. Ord a => Min a -> Min a -> Ordering
    compare :: Min a -> Min a -> Ordering
    $c< :: forall a. Ord a => Min a -> Min a -> Bool
    < :: Min a -> Min a -> Bool
    $c<= :: forall a. Ord a => Min a -> Min a -> Bool
    <= :: Min a -> Min a -> Bool
    $c> :: forall a. Ord a => Min a -> Min a -> Bool
    > :: Min a -> Min a -> Bool
    $c>= :: forall a. Ord a => Min a -> Min a -> Bool
    >= :: Min a -> Min a -> Bool
    $cmax :: forall a. Ord a => Min a -> Min a -> Min a
    max :: Min a -> Min a -> Min a
    $cmin :: forall a. Ord a => Min a -> Min a -> Min a
    min :: Min a -> Min a -> Min a
    Ord      -- ^ @since 4.9.0.0
               , Int -> Min a -> ShowS
    [Min a] -> ShowS
    Min a -> String
    (Int -> Min a -> ShowS)
    -> (Min a -> String) -> ([Min a] -> ShowS) -> Show (Min a)
    forall a. Show a => Int -> Min a -> ShowS
    forall a. Show a => [Min a] -> ShowS
    forall a. Show a => Min a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Min a -> ShowS
    showsPrec :: Int -> Min a -> ShowS
    $cshow :: forall a. Show a => Min a -> String
    show :: Min a -> String
    $cshowList :: forall a. Show a => [Min a] -> ShowS
    showList :: [Min a] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , ReadPrec [Min a]
    ReadPrec (Min a)
    Int -> ReadS (Min a)
    ReadS [Min a]
    (Int -> ReadS (Min a))
    -> ReadS [Min a]
    -> ReadPrec (Min a)
    -> ReadPrec [Min a]
    -> Read (Min a)
    forall a. Read a => ReadPrec [Min a]
    forall a. Read a => ReadPrec (Min a)
    forall a. Read a => Int -> ReadS (Min a)
    forall a. Read a => ReadS [Min a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (Min a)
    readsPrec :: Int -> ReadS (Min a)
    $creadList :: forall a. Read a => ReadS [Min a]
    readList :: ReadS [Min a]
    $creadPrec :: forall a. Read a => ReadPrec (Min a)
    readPrec :: ReadPrec (Min a)
    $creadListPrec :: forall a. Read a => ReadPrec [Min a]
    readListPrec :: ReadPrec [Min a]
    Read     -- ^ @since 4.9.0.0
               , Typeable (Min a)
    Typeable (Min a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Min a -> c (Min a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Min a))
    -> (Min a -> Constr)
    -> (Min a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Min a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)))
    -> ((forall b. Data b => b -> b) -> Min a -> Min a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Min a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Min a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Min a -> m (Min a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Min a -> m (Min a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Min a -> m (Min a))
    -> Data (Min a)
    Min a -> Constr
    Min a -> DataType
    (forall b. Data b => b -> b) -> Min a -> Min a
    forall a. Data a => Typeable (Min a)
    forall a. Data a => Min a -> Constr
    forall a. Data a => Min a -> DataType
    forall a. Data a => (forall b. Data b => b -> b) -> Min a -> Min a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Min a -> u
    forall a u. Data a => (forall d. Data d => d -> u) -> Min a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Min a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Min a -> c (Min a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Min a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Min a -> u
    forall u. (forall d. Data d => d -> u) -> Min a -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Min a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Min a -> c (Min a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Min a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Min a -> c (Min a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Min a -> c (Min a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Min a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Min a)
    $ctoConstr :: forall a. Data a => Min a -> Constr
    toConstr :: Min a -> Constr
    $cdataTypeOf :: forall a. Data a => Min a -> DataType
    dataTypeOf :: Min a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Min a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Min a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a))
    $cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Min a -> Min a
    gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r
    $cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Min a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Min a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Min a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Min a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Min a -> m (Min a)
    Data     -- ^ @since 4.9.0.0
               , (forall x. Min a -> Rep (Min a) x)
    -> (forall x. Rep (Min a) x -> Min a) -> Generic (Min a)
    forall x. Rep (Min a) x -> Min a
    forall x. Min a -> Rep (Min a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Min a) x -> Min a
    forall a x. Min a -> Rep (Min a) x
    $cfrom :: forall a x. Min a -> Rep (Min a) x
    from :: forall x. Min a -> Rep (Min a) x
    $cto :: forall a x. Rep (Min a) x -> Min a
    to :: forall x. Rep (Min a) x -> Min a
    Generic  -- ^ @since 4.9.0.0
               , (forall a. Min a -> Rep1 Min a)
    -> (forall a. Rep1 Min a -> Min a) -> Generic1 Min
    forall a. Rep1 Min a -> Min a
    forall a. Min a -> Rep1 Min a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. Min a -> Rep1 Min a
    from1 :: forall a. Min a -> Rep1 Min a
    $cto1 :: forall a. Rep1 Min a -> Min a
    to1 :: forall a. Rep1 Min a -> Min a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Enum a => Enum (Min a) where
      succ :: Min a -> Min a
    succ (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> a
    forall a. Enum a => a -> a
    succ a
    a)
      pred :: Min a -> Min a
    pred (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> a
    forall a. Enum a => a -> a
    pred a
    a)
      toEnum :: Int -> Min a
    toEnum = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> (Int -> a) -> Int -> Min a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a
    forall a. Enum a => Int -> a
    toEnum
      fromEnum :: Min a -> Int
    fromEnum = a -> Int
    forall a. Enum a => a -> Int
    fromEnum (a -> Int) -> (Min a -> a) -> Min a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Min a -> a
    forall a. Min a -> a
    getMin
      enumFrom :: Min a -> [Min a]
    enumFrom (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> [a] -> [Min a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> [a]
    forall a. Enum a => a -> [a]
    enumFrom a
    a
      enumFromThen :: Min a -> Min a -> [Min a]
    enumFromThen (Min a
    a) (Min a
    b) = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> [a] -> [Min a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromThen a
    a a
    b
      enumFromTo :: Min a -> Min a -> [Min a]
    enumFromTo (Min a
    a) (Min a
    b) = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> [a] -> [Min a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromTo a
    a a
    b
      enumFromThenTo :: Min a -> Min a -> Min a -> [Min a]
    enumFromThenTo (Min a
    a) (Min a
    b) (Min a
    c) = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> [a] -> [Min a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> a -> [a]
    forall a. Enum a => a -> a -> a -> [a]
    enumFromThenTo a
    a a
    b a
    c

    -- | @since 4.9.0.0
    instance Ord a => Semigroup (Min a) where
      <> :: Min a -> Min a -> Min a
    (<>) = (a -> a -> a) -> Min a -> Min a -> Min a
    forall a b. Coercible a b => a -> b
    coerce (a -> a -> a
    forall a. Ord a => a -> a -> a
    min :: a -> a -> a)
      stimes :: forall b. Integral b => b -> Min a -> Min a
    stimes = b -> Min a -> Min a
    forall b a. Integral b => b -> a -> a
    stimesIdempotent

    -- | @since 4.9.0.0
    instance (Ord a, Bounded a) => Monoid (Min a) where
      mempty :: Min a
    mempty = Min a
    forall a. Bounded a => a
    maxBound
      -- By default, we would get a lazy right fold. This forces the use of a strict
      -- left fold instead.
      mconcat :: [Min a] -> Min a
    mconcat = (Min a -> Min a -> Min a) -> Min a -> [Min a] -> Min a
    forall a b. (b -> a -> b) -> b -> [a] -> b
    List.foldl' Min a -> Min a -> Min a
    forall a. Semigroup a => a -> a -> a
    (<>) Min a
    forall a. Monoid a => a
    mempty
      {-# INLINE mconcat #-}

    -- | @since 4.9.0.0
    instance Functor Min where
      fmap :: forall a b. (a -> b) -> Min a -> Min b
    fmap a -> b
    f (Min a
    x) = b -> Min b
    forall a. a -> Min a
    Min (a -> b
    f a
    x)

    -- | @since 4.9.0.0
    instance Foldable Min where
      foldMap :: forall m a. Monoid m => (a -> m) -> Min a -> m
    foldMap a -> m
    f (Min a
    a) = a -> m
    f a
    a

    -- | @since 4.9.0.0
    instance Traversable Min where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Min a -> f (Min b)
    traverse a -> f b
    f (Min a
    a) = b -> Min b
    forall a. a -> Min a
    Min (b -> Min b) -> f b -> f (Min b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> f b
    f a
    a

    -- | @since 4.9.0.0
    instance Applicative Min where
      pure :: forall a. a -> Min a
    pure = a -> Min a
    forall a. a -> Min a
    Min
      Min a
    a <* :: forall a b. Min a -> Min b -> Min a
    <* Min b
    _ = Min a
    a
      Min a
    _ *> :: forall a b. Min a -> Min b -> Min b
    *> Min b
    a = Min b
    a
      <*> :: forall a b. Min (a -> b) -> Min a -> Min b
    (<*>) = Min (a -> b) -> Min a -> Min b
    forall a b. Coercible a b => a -> b
    coerce
      liftA2 :: forall a b c. (a -> b -> c) -> Min a -> Min b -> Min c
    liftA2 = (a -> b -> c) -> Min a -> Min b -> Min c
    forall a b. Coercible a b => a -> b
    coerce

    -- | @since 4.9.0.0
    instance Monad Min where
      >> :: forall a b. Min a -> Min b -> Min b
    (>>) = Min a -> Min b -> Min b
    forall a b. Min a -> Min b -> Min b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
      Min a
    a >>= :: forall a b. Min a -> (a -> Min b) -> Min b
    >>= a -> Min b
    f = a -> Min b
    f a
    a

    -- | @since 4.9.0.0
    instance MonadFix Min where
      mfix :: forall a. (a -> Min a) -> Min a
    mfix a -> Min a
    f = (Min a -> Min a) -> Min a
    forall a. (a -> a) -> a
    fix (a -> Min a
    f (a -> Min a) -> (Min a -> a) -> Min a -> Min a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Min a -> a
    forall a. Min a -> a
    getMin)

    -- | @since 4.9.0.0
    instance Num a => Num (Min a) where
      (Min a
    a) + :: Min a -> Min a -> Min a
    + (Min a
    b) = a -> Min a
    forall a. a -> Min a
    Min (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    + a
    b)
      (Min a
    a) * :: Min a -> Min a -> Min a
    * (Min a
    b) = a -> Min a
    forall a. a -> Min a
    Min (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    * a
    b)
      (Min a
    a) - :: Min a -> Min a -> Min a
    - (Min a
    b) = a -> Min a
    forall a. a -> Min a
    Min (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    - a
    b)
      negate :: Min a -> Min a
    negate (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> a
    forall a. Num a => a -> a
    negate a
    a)
      abs :: Min a -> Min a
    abs    (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> a
    forall a. Num a => a -> a
    abs a
    a)
      signum :: Min a -> Min a
    signum (Min a
    a) = a -> Min a
    forall a. a -> Min a
    Min (a -> a
    forall a. Num a => a -> a
    signum a
    a)
      fromInteger :: Integer -> Min a
    fromInteger    = a -> Min a
    forall a. a -> Min a
    Min (a -> Min a) -> (Integer -> a) -> Integer -> Min a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> a
    forall a. Num a => Integer -> a
    fromInteger

    -- | The 'Max' 'Monoid' and 'Semigroup' always choose the bigger element as
    -- by the 'Ord' instance and 'max' of the contained type.
    --
    -- ==== __Examples__
    --
    -- >>> Max 42 <> Max 3
    -- Max 42
    --
    -- >>> sconcat $ Max 1 :| [ Max n | n <- [2 .. 100]]
    -- Max {getMax = 100}
    newtype Max a = Max { forall a. Max a -> a
    getMax :: a }
      deriving ( Max a
    Max a -> Max a -> Bounded (Max a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Max a
    $cminBound :: forall a. Bounded a => Max a
    minBound :: Max a
    $cmaxBound :: forall a. Bounded a => Max a
    maxBound :: Max a
    Bounded  -- ^ @since 4.9.0.0
               , Max a -> Max a -> Bool
    (Max a -> Max a -> Bool) -> (Max a -> Max a -> Bool) -> Eq (Max a)
    forall a. Eq a => Max a -> Max a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Max a -> Max a -> Bool
    == :: Max a -> Max a -> Bool
    $c/= :: forall a. Eq a => Max a -> Max a -> Bool
    /= :: Max a -> Max a -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (Max a)
    Eq (Max a) =>
    (Max a -> Max a -> Ordering)
    -> (Max a -> Max a -> Bool)
    -> (Max a -> Max a -> Bool)
    -> (Max a -> Max a -> Bool)
    -> (Max a -> Max a -> Bool)
    -> (Max a -> Max a -> Max a)
    -> (Max a -> Max a -> Max a)
    -> Ord (Max a)
    Max a -> Max a -> Bool
    Max a -> Max a -> Ordering
    Max a -> Max a -> Max a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (Max a)
    forall a. Ord a => Max a -> Max a -> Bool
    forall a. Ord a => Max a -> Max a -> Ordering
    forall a. Ord a => Max a -> Max a -> Max a
    $ccompare :: forall a. Ord a => Max a -> Max a -> Ordering
    compare :: Max a -> Max a -> Ordering
    $c< :: forall a. Ord a => Max a -> Max a -> Bool
    < :: Max a -> Max a -> Bool
    $c<= :: forall a. Ord a => Max a -> Max a -> Bool
    <= :: Max a -> Max a -> Bool
    $c> :: forall a. Ord a => Max a -> Max a -> Bool
    > :: Max a -> Max a -> Bool
    $c>= :: forall a. Ord a => Max a -> Max a -> Bool
    >= :: Max a -> Max a -> Bool
    $cmax :: forall a. Ord a => Max a -> Max a -> Max a
    max :: Max a -> Max a -> Max a
    $cmin :: forall a. Ord a => Max a -> Max a -> Max a
    min :: Max a -> Max a -> Max a
    Ord      -- ^ @since 4.9.0.0
               , Int -> Max a -> ShowS
    [Max a] -> ShowS
    Max a -> String
    (Int -> Max a -> ShowS)
    -> (Max a -> String) -> ([Max a] -> ShowS) -> Show (Max a)
    forall a. Show a => Int -> Max a -> ShowS
    forall a. Show a => [Max a] -> ShowS
    forall a. Show a => Max a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Max a -> ShowS
    showsPrec :: Int -> Max a -> ShowS
    $cshow :: forall a. Show a => Max a -> String
    show :: Max a -> String
    $cshowList :: forall a. Show a => [Max a] -> ShowS
    showList :: [Max a] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , ReadPrec [Max a]
    ReadPrec (Max a)
    Int -> ReadS (Max a)
    ReadS [Max a]
    (Int -> ReadS (Max a))
    -> ReadS [Max a]
    -> ReadPrec (Max a)
    -> ReadPrec [Max a]
    -> Read (Max a)
    forall a. Read a => ReadPrec [Max a]
    forall a. Read a => ReadPrec (Max a)
    forall a. Read a => Int -> ReadS (Max a)
    forall a. Read a => ReadS [Max a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (Max a)
    readsPrec :: Int -> ReadS (Max a)
    $creadList :: forall a. Read a => ReadS [Max a]
    readList :: ReadS [Max a]
    $creadPrec :: forall a. Read a => ReadPrec (Max a)
    readPrec :: ReadPrec (Max a)
    $creadListPrec :: forall a. Read a => ReadPrec [Max a]
    readListPrec :: ReadPrec [Max a]
    Read     -- ^ @since 4.9.0.0
               , Typeable (Max a)
    Typeable (Max a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Max a -> c (Max a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Max a))
    -> (Max a -> Constr)
    -> (Max a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Max a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)))
    -> ((forall b. Data b => b -> b) -> Max a -> Max a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Max a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Max a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Max a -> m (Max a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Max a -> m (Max a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Max a -> m (Max a))
    -> Data (Max a)
    Max a -> Constr
    Max a -> DataType
    (forall b. Data b => b -> b) -> Max a -> Max a
    forall a. Data a => Typeable (Max a)
    forall a. Data a => Max a -> Constr
    forall a. Data a => Max a -> DataType
    forall a. Data a => (forall b. Data b => b -> b) -> Max a -> Max a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Max a -> u
    forall a u. Data a => (forall d. Data d => d -> u) -> Max a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Max a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Max a -> c (Max a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Max a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Max a -> u
    forall u. (forall d. Data d => d -> u) -> Max a -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Max a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Max a -> c (Max a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Max a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Max a -> c (Max a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Max a -> c (Max a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Max a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Max a)
    $ctoConstr :: forall a. Data a => Max a -> Constr
    toConstr :: Max a -> Constr
    $cdataTypeOf :: forall a. Data a => Max a -> DataType
    dataTypeOf :: Max a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Max a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Max a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a))
    $cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Max a -> Max a
    gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r
    $cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Max a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Max a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Max a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Max a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Max a -> m (Max a)
    Data     -- ^ @since 4.9.0.0
               , (forall x. Max a -> Rep (Max a) x)
    -> (forall x. Rep (Max a) x -> Max a) -> Generic (Max a)
    forall x. Rep (Max a) x -> Max a
    forall x. Max a -> Rep (Max a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Max a) x -> Max a
    forall a x. Max a -> Rep (Max a) x
    $cfrom :: forall a x. Max a -> Rep (Max a) x
    from :: forall x. Max a -> Rep (Max a) x
    $cto :: forall a x. Rep (Max a) x -> Max a
    to :: forall x. Rep (Max a) x -> Max a
    Generic  -- ^ @since 4.9.0.0
               , (forall a. Max a -> Rep1 Max a)
    -> (forall a. Rep1 Max a -> Max a) -> Generic1 Max
    forall a. Rep1 Max a -> Max a
    forall a. Max a -> Rep1 Max a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. Max a -> Rep1 Max a
    from1 :: forall a. Max a -> Rep1 Max a
    $cto1 :: forall a. Rep1 Max a -> Max a
    to1 :: forall a. Rep1 Max a -> Max a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Enum a => Enum (Max a) where
      succ :: Max a -> Max a
    succ (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> a
    forall a. Enum a => a -> a
    succ a
    a)
      pred :: Max a -> Max a
    pred (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> a
    forall a. Enum a => a -> a
    pred a
    a)
      toEnum :: Int -> Max a
    toEnum = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> (Int -> a) -> Int -> Max a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a
    forall a. Enum a => Int -> a
    toEnum
      fromEnum :: Max a -> Int
    fromEnum = a -> Int
    forall a. Enum a => a -> Int
    fromEnum (a -> Int) -> (Max a -> a) -> Max a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Max a -> a
    forall a. Max a -> a
    getMax
      enumFrom :: Max a -> [Max a]
    enumFrom (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> [a] -> [Max a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> [a]
    forall a. Enum a => a -> [a]
    enumFrom a
    a
      enumFromThen :: Max a -> Max a -> [Max a]
    enumFromThen (Max a
    a) (Max a
    b) = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> [a] -> [Max a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromThen a
    a a
    b
      enumFromTo :: Max a -> Max a -> [Max a]
    enumFromTo (Max a
    a) (Max a
    b) = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> [a] -> [Max a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromTo a
    a a
    b
      enumFromThenTo :: Max a -> Max a -> Max a -> [Max a]
    enumFromThenTo (Max a
    a) (Max a
    b) (Max a
    c) = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> [a] -> [Max a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> a -> [a]
    forall a. Enum a => a -> a -> a -> [a]
    enumFromThenTo a
    a a
    b a
    c

    -- | @since 4.9.0.0
    instance Ord a => Semigroup (Max a) where
      <> :: Max a -> Max a -> Max a
    (<>) = (a -> a -> a) -> Max a -> Max a -> Max a
    forall a b. Coercible a b => a -> b
    coerce (a -> a -> a
    forall a. Ord a => a -> a -> a
    max :: a -> a -> a)
      stimes :: forall b. Integral b => b -> Max a -> Max a
    stimes = b -> Max a -> Max a
    forall b a. Integral b => b -> a -> a
    stimesIdempotent

    -- | @since 4.9.0.0
    instance (Ord a, Bounded a) => Monoid (Max a) where
      mempty :: Max a
    mempty = Max a
    forall a. Bounded a => a
    minBound
      -- By default, we would get a lazy right fold. This forces the use of a strict
      -- left fold instead.
      mconcat :: [Max a] -> Max a
    mconcat = (Max a -> Max a -> Max a) -> Max a -> [Max a] -> Max a
    forall a b. (b -> a -> b) -> b -> [a] -> b
    List.foldl' Max a -> Max a -> Max a
    forall a. Semigroup a => a -> a -> a
    (<>) Max a
    forall a. Monoid a => a
    mempty
      {-# INLINE mconcat #-}

    -- | @since 4.9.0.0
    instance Functor Max where
      fmap :: forall a b. (a -> b) -> Max a -> Max b
    fmap a -> b
    f (Max a
    x) = b -> Max b
    forall a. a -> Max a
    Max (a -> b
    f a
    x)

    -- | @since 4.9.0.0
    instance Foldable Max where
      foldMap :: forall m a. Monoid m => (a -> m) -> Max a -> m
    foldMap a -> m
    f (Max a
    a) = a -> m
    f a
    a

    -- | @since 4.9.0.0
    instance Traversable Max where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Max a -> f (Max b)
    traverse a -> f b
    f (Max a
    a) = b -> Max b
    forall a. a -> Max a
    Max (b -> Max b) -> f b -> f (Max b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> f b
    f a
    a

    -- | @since 4.9.0.0
    instance Applicative Max where
      pure :: forall a. a -> Max a
    pure = a -> Max a
    forall a. a -> Max a
    Max
      Max a
    a <* :: forall a b. Max a -> Max b -> Max a
    <* Max b
    _ = Max a
    a
      Max a
    _ *> :: forall a b. Max a -> Max b -> Max b
    *> Max b
    a = Max b
    a
      <*> :: forall a b. Max (a -> b) -> Max a -> Max b
    (<*>) = Max (a -> b) -> Max a -> Max b
    forall a b. Coercible a b => a -> b
    coerce
      liftA2 :: forall a b c. (a -> b -> c) -> Max a -> Max b -> Max c
    liftA2 = (a -> b -> c) -> Max a -> Max b -> Max c
    forall a b. Coercible a b => a -> b
    coerce

    -- | @since 4.9.0.0
    instance Monad Max where
      >> :: forall a b. Max a -> Max b -> Max b
    (>>) = Max a -> Max b -> Max b
    forall a b. Max a -> Max b -> Max b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
      Max a
    a >>= :: forall a b. Max a -> (a -> Max b) -> Max b
    >>= a -> Max b
    f = a -> Max b
    f a
    a

    -- | @since 4.9.0.0
    instance MonadFix Max where
      mfix :: forall a. (a -> Max a) -> Max a
    mfix a -> Max a
    f = (Max a -> Max a) -> Max a
    forall a. (a -> a) -> a
    fix (a -> Max a
    f (a -> Max a) -> (Max a -> a) -> Max a -> Max a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Max a -> a
    forall a. Max a -> a
    getMax)

    -- | @since 4.9.0.0
    instance Num a => Num (Max a) where
      (Max a
    a) + :: Max a -> Max a -> Max a
    + (Max a
    b) = a -> Max a
    forall a. a -> Max a
    Max (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    + a
    b)
      (Max a
    a) * :: Max a -> Max a -> Max a
    * (Max a
    b) = a -> Max a
    forall a. a -> Max a
    Max (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    * a
    b)
      (Max a
    a) - :: Max a -> Max a -> Max a
    - (Max a
    b) = a -> Max a
    forall a. a -> Max a
    Max (a
    a a -> a -> a
    forall a. Num a => a -> a -> a
    - a
    b)
      negate :: Max a -> Max a
    negate (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> a
    forall a. Num a => a -> a
    negate a
    a)
      abs :: Max a -> Max a
    abs    (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> a
    forall a. Num a => a -> a
    abs a
    a)
      signum :: Max a -> Max a
    signum (Max a
    a) = a -> Max a
    forall a. a -> Max a
    Max (a -> a
    forall a. Num a => a -> a
    signum a
    a)
      fromInteger :: Integer -> Max a
    fromInteger    = a -> Max a
    forall a. a -> Max a
    Max (a -> Max a) -> (Integer -> a) -> Integer -> Max a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> a
    forall a. Num a => Integer -> a
    fromInteger

    -- | 'Arg' isn't itself a 'Semigroup' in its own right, but it can be
    -- placed inside 'Min' and 'Max' to compute an arg min or arg max.
    --
    -- ==== __Examples__
    --
    -- >>> minimum [ Arg (x * x) x | x <- [-10 .. 10] ]
    -- Arg 0 0
    --
    -- >>> maximum [ Arg (-0.2*x^2 + 1.5*x + 1) x | x <- [-10 .. 10] ]
    -- Arg 3.8 4.0
    --
    -- >>> minimum [ Arg (-0.2*x^2 + 1.5*x + 1) x | x <- [-10 .. 10] ]
    -- Arg (-34.0) (-10.0)
    data Arg a b = Arg
      a
      -- ^ The argument used for comparisons in 'Eq' and 'Ord'.
      b
      -- ^ The "value" exposed via the 'Functor', 'Foldable' etc. instances.
      deriving
      ( Int -> Arg a b -> ShowS
    [Arg a b] -> ShowS
    Arg a b -> String
    (Int -> Arg a b -> ShowS)
    -> (Arg a b -> String) -> ([Arg a b] -> ShowS) -> Show (Arg a b)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall a b. (Show a, Show b) => Int -> Arg a b -> ShowS
    forall a b. (Show a, Show b) => [Arg a b] -> ShowS
    forall a b. (Show a, Show b) => Arg a b -> String
    $cshowsPrec :: forall a b. (Show a, Show b) => Int -> Arg a b -> ShowS
    showsPrec :: Int -> Arg a b -> ShowS
    $cshow :: forall a b. (Show a, Show b) => Arg a b -> String
    show :: Arg a b -> String
    $cshowList :: forall a b. (Show a, Show b) => [Arg a b] -> ShowS
    showList :: [Arg a b] -> ShowS
    Show     -- ^ @since 4.9.0.0
      , ReadPrec [Arg a b]
    ReadPrec (Arg a b)
    Int -> ReadS (Arg a b)
    ReadS [Arg a b]
    (Int -> ReadS (Arg a b))
    -> ReadS [Arg a b]
    -> ReadPrec (Arg a b)
    -> ReadPrec [Arg a b]
    -> Read (Arg a b)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall a b. (Read a, Read b) => ReadPrec [Arg a b]
    forall a b. (Read a, Read b) => ReadPrec (Arg a b)
    forall a b. (Read a, Read b) => Int -> ReadS (Arg a b)
    forall a b. (Read a, Read b) => ReadS [Arg a b]
    $creadsPrec :: forall a b. (Read a, Read b) => Int -> ReadS (Arg a b)
    readsPrec :: Int -> ReadS (Arg a b)
    $creadList :: forall a b. (Read a, Read b) => ReadS [Arg a b]
    readList :: ReadS [Arg a b]
    $creadPrec :: forall a b. (Read a, Read b) => ReadPrec (Arg a b)
    readPrec :: ReadPrec (Arg a b)
    $creadListPrec :: forall a b. (Read a, Read b) => ReadPrec [Arg a b]
    readListPrec :: ReadPrec [Arg a b]
    Read     -- ^ @since 4.9.0.0
      , Typeable (Arg a b)
    Typeable (Arg a b) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Arg a b -> c (Arg a b))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Arg a b))
    -> (Arg a b -> Constr)
    -> (Arg a b -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)))
    -> ((forall b. Data b => b -> b) -> Arg a b -> Arg a b)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Arg a b -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Arg a b -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Arg a b -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Arg a b -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b))
    -> Data (Arg a b)
    Arg a b -> Constr
    Arg a b -> DataType
    (forall b. Data b => b -> b) -> Arg a b -> Arg a b
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Arg a b -> u
    forall u. (forall d. Data d => d -> u) -> Arg a b -> [u]
    forall a b. (Data a, Data b) => Typeable (Arg a b)
    forall a b. (Data a, Data b) => Arg a b -> Constr
    forall a b. (Data a, Data b) => Arg a b -> DataType
    forall a b.
    (Data a, Data b) =>
    (forall b. Data b => b -> b) -> Arg a b -> Arg a b
    forall a b u.
    (Data a, Data b) =>
    Int -> (forall d. Data d => d -> u) -> Arg a b -> u
    forall a b u.
    (Data a, Data b) =>
    (forall d. Data d => d -> u) -> Arg a b -> [u]
    forall a b r r'.
    (Data a, Data b) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    forall a b r r'.
    (Data a, Data b) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    forall a b (m :: * -> *).
    (Data a, Data b, Monad m) =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Arg a b)
    forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg a b -> c (Arg a b)
    forall a b (t :: * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Arg a b))
    forall a b (t :: * -> * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b))
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Arg a b)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg a b -> c (Arg a b)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Arg a b))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b))
    $cgfoldl :: forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg a b -> c (Arg a b)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Arg a b -> c (Arg a b)
    $cgunfold :: forall a b (c :: * -> *).
    (Data a, Data b) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Arg a b)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Arg a b)
    $ctoConstr :: forall a b. (Data a, Data b) => Arg a b -> Constr
    toConstr :: Arg a b -> Constr
    $cdataTypeOf :: forall a b. (Data a, Data b) => Arg a b -> DataType
    dataTypeOf :: Arg a b -> DataType
    $cdataCast1 :: forall a b (t :: * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Arg a b))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Arg a b))
    $cdataCast2 :: forall a b (t :: * -> * -> *) (c :: * -> *).
    (Data a, Data b, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b))
    $cgmapT :: forall a b.
    (Data a, Data b) =>
    (forall b. Data b => b -> b) -> Arg a b -> Arg a b
    gmapT :: (forall b. Data b => b -> b) -> Arg a b -> Arg a b
    $cgmapQl :: forall a b r r'.
    (Data a, Data b) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    $cgmapQr :: forall a b r r'.
    (Data a, Data b) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Arg a b -> r
    $cgmapQ :: forall a b u.
    (Data a, Data b) =>
    (forall d. Data d => d -> u) -> Arg a b -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Arg a b -> [u]
    $cgmapQi :: forall a b u.
    (Data a, Data b) =>
    Int -> (forall d. Data d => d -> u) -> Arg a b -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Arg a b -> u
    $cgmapM :: forall a b (m :: * -> *).
    (Data a, Data b, Monad m) =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    $cgmapMp :: forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    $cgmapMo :: forall a b (m :: * -> *).
    (Data a, Data b, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b)
    Data     -- ^ @since 4.9.0.0
      , (forall x. Arg a b -> Rep (Arg a b) x)
    -> (forall x. Rep (Arg a b) x -> Arg a b) -> Generic (Arg a b)
    forall x. Rep (Arg a b) x -> Arg a b
    forall x. Arg a b -> Rep (Arg a b) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a b x. Rep (Arg a b) x -> Arg a b
    forall a b x. Arg a b -> Rep (Arg a b) x
    $cfrom :: forall a b x. Arg a b -> Rep (Arg a b) x
    from :: forall x. Arg a b -> Rep (Arg a b) x
    $cto :: forall a b x. Rep (Arg a b) x -> Arg a b
    to :: forall x. Rep (Arg a b) x -> Arg a b
    Generic  -- ^ @since 4.9.0.0
      , (forall a. Arg a a -> Rep1 (Arg a) a)
    -> (forall a. Rep1 (Arg a) a -> Arg a a) -> Generic1 (Arg a)
    forall a. Rep1 (Arg a) a -> Arg a a
    forall a. Arg a a -> Rep1 (Arg a) a
    forall a a. Rep1 (Arg a) a -> Arg a a
    forall a a. Arg a a -> Rep1 (Arg a) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a a. Arg a a -> Rep1 (Arg a) a
    from1 :: forall a. Arg a a -> Rep1 (Arg a) a
    $cto1 :: forall a a. Rep1 (Arg a) a -> Arg a a
    to1 :: forall a. Rep1 (Arg a) a -> Arg a a
    Generic1 -- ^ @since 4.9.0.0
      )

    -- |
    -- ==== __Examples__
    --
    -- >>> Min (Arg 0 ()) <> Min (Arg 1 ())
    -- Min {getMin = Arg 0 ()}
    --
    -- >>> minimum [ Arg (length name) name | name <- ["violencia", "lea", "pixie"]]
    -- Arg 3 "lea"
    type ArgMin a b = Min (Arg a b)

    -- |
    -- ==== __Examples__
    --
    -- >>> Max (Arg 0 ()) <> Max (Arg 1 ())
    -- Max {getMax = Arg 1 ()}
    --
    -- >>> maximum [ Arg (length name) name | name <- ["violencia", "lea", "pixie"]]
    -- Arg 9 "violencia"
    type ArgMax a b = Max (Arg a b)

    -- | @since 4.9.0.0
    instance Functor (Arg a) where
      fmap :: forall a b. (a -> b) -> Arg a a -> Arg a b
    fmap a -> b
    f (Arg a
    x a
    a) = a -> b -> Arg a b
    forall a b. a -> b -> Arg a b
    Arg a
    x (a -> b
    f a
    a)

    -- | @since 4.9.0.0
    instance Foldable (Arg a) where
      foldMap :: forall m a. Monoid m => (a -> m) -> Arg a a -> m
    foldMap a -> m
    f (Arg a
    _ a
    a) = a -> m
    f a
    a

    -- | @since 4.9.0.0
    instance Traversable (Arg a) where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Arg a a -> f (Arg a b)
    traverse a -> f b
    f (Arg a
    x a
    a) = a -> b -> Arg a b
    forall a b. a -> b -> Arg a b
    Arg a
    x (b -> Arg a b) -> f b -> f (Arg a b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> f b
    f a
    a

    -- | @since 4.9.0.0
    instance Eq a => Eq (Arg a b) where
      Arg a
    a b
    _ == :: Arg a b -> Arg a b -> Bool
    == Arg a
    b b
    _ = a
    a a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    == a
    b

    -- | @since 4.9.0.0
    instance Ord a => Ord (Arg a b) where
      Arg a
    a b
    _ compare :: Arg a b -> Arg a b -> Ordering
    `compare` Arg a
    b b
    _ = a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare a
    a a
    b
      min :: Arg a b -> Arg a b -> Arg a b
    min x :: Arg a b
    x@(Arg a
    a b
    _) y :: Arg a b
    y@(Arg a
    b b
    _)
        | a
    a a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    <= a
    b    = Arg a b
    x
        | Bool
    otherwise = Arg a b
    y
      max :: Arg a b -> Arg a b -> Arg a b
    max x :: Arg a b
    x@(Arg a
    a b
    _) y :: Arg a b
    y@(Arg a
    b b
    _)
        | a
    a a -> a -> Bool
    forall a. Ord a => a -> a -> Bool
    >= a
    b    = Arg a b
    x
        | Bool
    otherwise = Arg a b
    y

    -- | @since 4.9.0.0
    instance Bifunctor Arg where
      bimap :: forall a b c d. (a -> b) -> (c -> d) -> Arg a c -> Arg b d
    bimap a -> b
    f c -> d
    g (Arg a
    a c
    b) = b -> d -> Arg b d
    forall a b. a -> b -> Arg a b
    Arg (a -> b
    f a
    a) (c -> d
    g c
    b)

    -- | @since 4.10.0.0
    instance Bitraversable Arg where
      bitraverse :: forall (f :: * -> *) a c b d.
    Applicative f =>
    (a -> f c) -> (b -> f d) -> Arg a b -> f (Arg c d)
    bitraverse a -> f c
    f b -> f d
    g (Arg a
    a b
    b) = c -> d -> Arg c d
    forall a b. a -> b -> Arg a b
    Arg (c -> d -> Arg c d) -> f c -> f (d -> Arg c d)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> a -> f c
    f a
    a f (d -> Arg c d) -> f d -> f (Arg c d)
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> b -> f d
    g b
    b

    -- | @since 4.10.0.0
    instance Bifoldable Arg where
      bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> Arg a b -> m
    bifoldMap a -> m
    f b -> m
    g (Arg a
    a b
    b) = a -> m
    f a
    a m -> m -> m
    forall a. Semigroup a => a -> a -> a
    <> b -> m
    g b
    b

    -- |
    -- Beware that @Data.Semigroup.@'First' is different from
    -- @Data.Monoid.@'Data.Monoid.First'. The former simply returns the first value,
    -- so @Data.Semigroup.First Nothing <> x = Data.Semigroup.First Nothing@.
    -- The latter returns the first non-'Nothing',
    -- thus @Data.Monoid.First Nothing <> x = x@.
    --
    -- ==== __Examples__
    --
    -- >>> First 0 <> First 10
    -- First 0
    --
    -- >>> sconcat $ First 1 :| [ First n | n <- [2 ..] ]
    -- First 1
    newtype First a = First { forall a. First a -> a
    getFirst :: a }
      deriving ( First a
    First a -> First a -> Bounded (First a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => First a
    $cminBound :: forall a. Bounded a => First a
    minBound :: First a
    $cmaxBound :: forall a. Bounded a => First a
    maxBound :: First a
    Bounded  -- ^ @since 4.9.0.0
               , First a -> First a -> Bool
    (First a -> First a -> Bool)
    -> (First a -> First a -> Bool) -> Eq (First a)
    forall a. Eq a => First a -> First a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => First a -> First a -> Bool
    == :: First a -> First a -> Bool
    $c/= :: forall a. Eq a => First a -> First a -> Bool
    /= :: First a -> First a -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (First a)
    Eq (First a) =>
    (First a -> First a -> Ordering)
    -> (First a -> First a -> Bool)
    -> (First a -> First a -> Bool)
    -> (First a -> First a -> Bool)
    -> (First a -> First a -> Bool)
    -> (First a -> First a -> First a)
    -> (First a -> First a -> First a)
    -> Ord (First a)
    First a -> First a -> Bool
    First a -> First a -> Ordering
    First a -> First a -> First a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (First a)
    forall a. Ord a => First a -> First a -> Bool
    forall a. Ord a => First a -> First a -> Ordering
    forall a. Ord a => First a -> First a -> First a
    $ccompare :: forall a. Ord a => First a -> First a -> Ordering
    compare :: First a -> First a -> Ordering
    $c< :: forall a. Ord a => First a -> First a -> Bool
    < :: First a -> First a -> Bool
    $c<= :: forall a. Ord a => First a -> First a -> Bool
    <= :: First a -> First a -> Bool
    $c> :: forall a. Ord a => First a -> First a -> Bool
    > :: First a -> First a -> Bool
    $c>= :: forall a. Ord a => First a -> First a -> Bool
    >= :: First a -> First a -> Bool
    $cmax :: forall a. Ord a => First a -> First a -> First a
    max :: First a -> First a -> First a
    $cmin :: forall a. Ord a => First a -> First a -> First a
    min :: First a -> First a -> First a
    Ord      -- ^ @since 4.9.0.0
               , Int -> First a -> ShowS
    [First a] -> ShowS
    First a -> String
    (Int -> First a -> ShowS)
    -> (First a -> String) -> ([First a] -> ShowS) -> Show (First a)
    forall a. Show a => Int -> First a -> ShowS
    forall a. Show a => [First a] -> ShowS
    forall a. Show a => First a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> First a -> ShowS
    showsPrec :: Int -> First a -> ShowS
    $cshow :: forall a. Show a => First a -> String
    show :: First a -> String
    $cshowList :: forall a. Show a => [First a] -> ShowS
    showList :: [First a] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , ReadPrec [First a]
    ReadPrec (First a)
    Int -> ReadS (First a)
    ReadS [First a]
    (Int -> ReadS (First a))
    -> ReadS [First a]
    -> ReadPrec (First a)
    -> ReadPrec [First a]
    -> Read (First a)
    forall a. Read a => ReadPrec [First a]
    forall a. Read a => ReadPrec (First a)
    forall a. Read a => Int -> ReadS (First a)
    forall a. Read a => ReadS [First a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (First a)
    readsPrec :: Int -> ReadS (First a)
    $creadList :: forall a. Read a => ReadS [First a]
    readList :: ReadS [First a]
    $creadPrec :: forall a. Read a => ReadPrec (First a)
    readPrec :: ReadPrec (First a)
    $creadListPrec :: forall a. Read a => ReadPrec [First a]
    readListPrec :: ReadPrec [First a]
    Read     -- ^ @since 4.9.0.0
               , Typeable (First a)
    Typeable (First a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> First a -> c (First a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (First a))
    -> (First a -> Constr)
    -> (First a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (First a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)))
    -> ((forall b. Data b => b -> b) -> First a -> First a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> First a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> First a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> First a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> First a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> First a -> m (First a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> First a -> m (First a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> First a -> m (First a))
    -> Data (First a)
    First a -> Constr
    First a -> DataType
    (forall b. Data b => b -> b) -> First a -> First a
    forall a. Data a => Typeable (First a)
    forall a. Data a => First a -> Constr
    forall a. Data a => First a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> First a -> First a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> First a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> First a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (First a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> First a -> c (First a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (First a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> First a -> u
    forall u. (forall d. Data d => d -> u) -> First a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (First a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> First a -> c (First a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (First a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> First a -> c (First a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> First a -> c (First a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (First a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (First a)
    $ctoConstr :: forall a. Data a => First a -> Constr
    toConstr :: First a -> Constr
    $cdataTypeOf :: forall a. Data a => First a -> DataType
    dataTypeOf :: First a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (First a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (First a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> First a -> First a
    gmapT :: (forall b. Data b => b -> b) -> First a -> First a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> First a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> First a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> First a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> First a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> First a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> First a -> m (First a)
    Data     -- ^ @since 4.9.0.0
               , (forall x. First a -> Rep (First a) x)
    -> (forall x. Rep (First a) x -> First a) -> Generic (First a)
    forall x. Rep (First a) x -> First a
    forall x. First a -> Rep (First a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (First a) x -> First a
    forall a x. First a -> Rep (First a) x
    $cfrom :: forall a x. First a -> Rep (First a) x
    from :: forall x. First a -> Rep (First a) x
    $cto :: forall a x. Rep (First a) x -> First a
    to :: forall x. Rep (First a) x -> First a
    Generic  -- ^ @since 4.9.0.0
               , (forall a. First a -> Rep1 First a)
    -> (forall a. Rep1 First a -> First a) -> Generic1 First
    forall a. Rep1 First a -> First a
    forall a. First a -> Rep1 First a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. First a -> Rep1 First a
    from1 :: forall a. First a -> Rep1 First a
    $cto1 :: forall a. Rep1 First a -> First a
    to1 :: forall a. Rep1 First a -> First a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Enum a => Enum (First a) where
      succ :: First a -> First a
    succ (First a
    a) = a -> First a
    forall a. a -> First a
    First (a -> a
    forall a. Enum a => a -> a
    succ a
    a)
      pred :: First a -> First a
    pred (First a
    a) = a -> First a
    forall a. a -> First a
    First (a -> a
    forall a. Enum a => a -> a
    pred a
    a)
      toEnum :: Int -> First a
    toEnum = a -> First a
    forall a. a -> First a
    First (a -> First a) -> (Int -> a) -> Int -> First a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a
    forall a. Enum a => Int -> a
    toEnum
      fromEnum :: First a -> Int
    fromEnum = a -> Int
    forall a. Enum a => a -> Int
    fromEnum (a -> Int) -> (First a -> a) -> First a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> a
    forall a. First a -> a
    getFirst
      enumFrom :: First a -> [First a]
    enumFrom (First a
    a) = a -> First a
    forall a. a -> First a
    First (a -> First a) -> [a] -> [First a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> [a]
    forall a. Enum a => a -> [a]
    enumFrom a
    a
      enumFromThen :: First a -> First a -> [First a]
    enumFromThen (First a
    a) (First a
    b) = a -> First a
    forall a. a -> First a
    First (a -> First a) -> [a] -> [First a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromThen a
    a a
    b
      enumFromTo :: First a -> First a -> [First a]
    enumFromTo (First a
    a) (First a
    b) = a -> First a
    forall a. a -> First a
    First (a -> First a) -> [a] -> [First a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromTo a
    a a
    b
      enumFromThenTo :: First a -> First a -> First a -> [First a]
    enumFromThenTo (First a
    a) (First a
    b) (First a
    c) = a -> First a
    forall a. a -> First a
    First (a -> First a) -> [a] -> [First a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> a -> [a]
    forall a. Enum a => a -> a -> a -> [a]
    enumFromThenTo a
    a a
    b a
    c

    -- | @since 4.9.0.0
    instance Semigroup (First a) where
      First a
    a <> :: First a -> First a -> First a
    <> First a
    _ = First a
    a
      stimes :: forall b. Integral b => b -> First a -> First a
    stimes = b -> First a -> First a
    forall b a. Integral b => b -> a -> a
    stimesIdempotent
      sconcat :: NonEmpty (First a) -> First a
    sconcat (First a
    x :| [First a]
    _) = First a
    x

    -- | @since 4.9.0.0
    instance Functor First where
      fmap :: forall a b. (a -> b) -> First a -> First b
    fmap a -> b
    f (First a
    x) = b -> First b
    forall a. a -> First a
    First (a -> b
    f a
    x)

    -- | @since 4.9.0.0
    instance Foldable First where
      foldMap :: forall m a. Monoid m => (a -> m) -> First a -> m
    foldMap a -> m
    f (First a
    a) = a -> m
    f a
    a

    -- | @since 4.9.0.0
    instance Traversable First where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> First a -> f (First b)
    traverse a -> f b
    f (First a
    a) = b -> First b
    forall a. a -> First a
    First (b -> First b) -> f b -> f (First b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> f b
    f a
    a

    -- | @since 4.9.0.0
    instance Applicative First where
      pure :: forall a. a -> First a
    pure a
    x = a -> First a
    forall a. a -> First a
    First a
    x
      First a
    a <* :: forall a b. First a -> First b -> First a
    <* First b
    _ = First a
    a
      First a
    _ *> :: forall a b. First a -> First b -> First b
    *> First b
    a = First b
    a
      <*> :: forall a b. First (a -> b) -> First a -> First b
    (<*>) = First (a -> b) -> First a -> First b
    forall a b. Coercible a b => a -> b
    coerce
      liftA2 :: forall a b c. (a -> b -> c) -> First a -> First b -> First c
    liftA2 = (a -> b -> c) -> First a -> First b -> First c
    forall a b. Coercible a b => a -> b
    coerce

    -- | @since 4.9.0.0
    instance Monad First where
      >> :: forall a b. First a -> First b -> First b
    (>>) = First a -> First b -> First b
    forall a b. First a -> First b -> First b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
      First a
    a >>= :: forall a b. First a -> (a -> First b) -> First b
    >>= a -> First b
    f = a -> First b
    f a
    a

    -- | @since 4.9.0.0
    instance MonadFix First where
      mfix :: forall a. (a -> First a) -> First a
    mfix a -> First a
    f = (First a -> First a) -> First a
    forall a. (a -> a) -> a
    fix (a -> First a
    f (a -> First a) -> (First a -> a) -> First a -> First a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . First a -> a
    forall a. First a -> a
    getFirst)

    -- |
    -- Beware that @Data.Semigroup.@'Last' is different from
    -- @Data.Monoid.@'Data.Monoid.Last'. The former simply returns the last value,
    -- so @x <> Data.Semigroup.Last Nothing = Data.Semigroup.Last Nothing@.
    -- The latter returns the last non-'Nothing',
    -- thus @x <> Data.Monoid.Last Nothing = x@.
    --
    -- ==== __Examples__
    --
    -- >>> Last 0 <> Last 10
    -- Last {getLast = 10}
    --
    -- >>> sconcat $ Last 1 :| [ Last n | n <- [2..]]
    -- Last {getLast = * hangs forever *
    newtype Last a = Last { forall a. Last a -> a
    getLast :: a }
      deriving ( Last a
    Last a -> Last a -> Bounded (Last a)
    forall a. a -> a -> Bounded a
    forall a. Bounded a => Last a
    $cminBound :: forall a. Bounded a => Last a
    minBound :: Last a
    $cmaxBound :: forall a. Bounded a => Last a
    maxBound :: Last a
    Bounded  -- ^ @since 4.9.0.0
               , Last a -> Last a -> Bool
    (Last a -> Last a -> Bool)
    -> (Last a -> Last a -> Bool) -> Eq (Last a)
    forall a. Eq a => Last a -> Last a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => Last a -> Last a -> Bool
    == :: Last a -> Last a -> Bool
    $c/= :: forall a. Eq a => Last a -> Last a -> Bool
    /= :: Last a -> Last a -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (Last a)
    Eq (Last a) =>
    (Last a -> Last a -> Ordering)
    -> (Last a -> Last a -> Bool)
    -> (Last a -> Last a -> Bool)
    -> (Last a -> Last a -> Bool)
    -> (Last a -> Last a -> Bool)
    -> (Last a -> Last a -> Last a)
    -> (Last a -> Last a -> Last a)
    -> Ord (Last a)
    Last a -> Last a -> Bool
    Last a -> Last a -> Ordering
    Last a -> Last a -> Last a
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall a. Ord a => Eq (Last a)
    forall a. Ord a => Last a -> Last a -> Bool
    forall a. Ord a => Last a -> Last a -> Ordering
    forall a. Ord a => Last a -> Last a -> Last a
    $ccompare :: forall a. Ord a => Last a -> Last a -> Ordering
    compare :: Last a -> Last a -> Ordering
    $c< :: forall a. Ord a => Last a -> Last a -> Bool
    < :: Last a -> Last a -> Bool
    $c<= :: forall a. Ord a => Last a -> Last a -> Bool
    <= :: Last a -> Last a -> Bool
    $c> :: forall a. Ord a => Last a -> Last a -> Bool
    > :: Last a -> Last a -> Bool
    $c>= :: forall a. Ord a => Last a -> Last a -> Bool
    >= :: Last a -> Last a -> Bool
    $cmax :: forall a. Ord a => Last a -> Last a -> Last a
    max :: Last a -> Last a -> Last a
    $cmin :: forall a. Ord a => Last a -> Last a -> Last a
    min :: Last a -> Last a -> Last a
    Ord      -- ^ @since 4.9.0.0
               , Int -> Last a -> ShowS
    [Last a] -> ShowS
    Last a -> String
    (Int -> Last a -> ShowS)
    -> (Last a -> String) -> ([Last a] -> ShowS) -> Show (Last a)
    forall a. Show a => Int -> Last a -> ShowS
    forall a. Show a => [Last a] -> ShowS
    forall a. Show a => Last a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> Last a -> ShowS
    showsPrec :: Int -> Last a -> ShowS
    $cshow :: forall a. Show a => Last a -> String
    show :: Last a -> String
    $cshowList :: forall a. Show a => [Last a] -> ShowS
    showList :: [Last a] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , ReadPrec [Last a]
    ReadPrec (Last a)
    Int -> ReadS (Last a)
    ReadS [Last a]
    (Int -> ReadS (Last a))
    -> ReadS [Last a]
    -> ReadPrec (Last a)
    -> ReadPrec [Last a]
    -> Read (Last a)
    forall a. Read a => ReadPrec [Last a]
    forall a. Read a => ReadPrec (Last a)
    forall a. Read a => Int -> ReadS (Last a)
    forall a. Read a => ReadS [Last a]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall a. Read a => Int -> ReadS (Last a)
    readsPrec :: Int -> ReadS (Last a)
    $creadList :: forall a. Read a => ReadS [Last a]
    readList :: ReadS [Last a]
    $creadPrec :: forall a. Read a => ReadPrec (Last a)
    readPrec :: ReadPrec (Last a)
    $creadListPrec :: forall a. Read a => ReadPrec [Last a]
    readListPrec :: ReadPrec [Last a]
    Read     -- ^ @since 4.9.0.0
               , Typeable (Last a)
    Typeable (Last a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> Last a -> c (Last a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (Last a))
    -> (Last a -> Constr)
    -> (Last a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (Last a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)))
    -> ((forall b. Data b => b -> b) -> Last a -> Last a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> Last a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> Last a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> Last a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> Last a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> Last a -> m (Last a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Last a -> m (Last a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> Last a -> m (Last a))
    -> Data (Last a)
    Last a -> Constr
    Last a -> DataType
    (forall b. Data b => b -> b) -> Last a -> Last a
    forall a. Data a => Typeable (Last a)
    forall a. Data a => Last a -> Constr
    forall a. Data a => Last a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Last a -> Last a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Last a -> u
    forall a u. Data a => (forall d. Data d => d -> u) -> Last a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Last a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Last a -> c (Last a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Last a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> Last a -> u
    forall u. (forall d. Data d => d -> u) -> Last a -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Last a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Last a -> c (Last a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Last a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Last a -> c (Last a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Last a -> c (Last a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Last a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Last a)
    $ctoConstr :: forall a. Data a => Last a -> Constr
    toConstr :: Last a -> Constr
    $cdataTypeOf :: forall a. Data a => Last a -> DataType
    dataTypeOf :: Last a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (Last a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Last a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> Last a -> Last a
    gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r
    $cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Last a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> Last a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> Last a -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Last a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Last a -> m (Last a)
    Data     -- ^ @since 4.9.0.0
               , (forall x. Last a -> Rep (Last a) x)
    -> (forall x. Rep (Last a) x -> Last a) -> Generic (Last a)
    forall x. Rep (Last a) x -> Last a
    forall x. Last a -> Rep (Last a) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall a x. Rep (Last a) x -> Last a
    forall a x. Last a -> Rep (Last a) x
    $cfrom :: forall a x. Last a -> Rep (Last a) x
    from :: forall x. Last a -> Rep (Last a) x
    $cto :: forall a x. Rep (Last a) x -> Last a
    to :: forall x. Rep (Last a) x -> Last a
    Generic  -- ^ @since 4.9.0.0
               , (forall a. Last a -> Rep1 Last a)
    -> (forall a. Rep1 Last a -> Last a) -> Generic1 Last
    forall a. Rep1 Last a -> Last a
    forall a. Last a -> Rep1 Last a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. Last a -> Rep1 Last a
    from1 :: forall a. Last a -> Rep1 Last a
    $cto1 :: forall a. Rep1 Last a -> Last a
    to1 :: forall a. Rep1 Last a -> Last a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Enum a => Enum (Last a) where
      succ :: Last a -> Last a
    succ (Last a
    a) = a -> Last a
    forall a. a -> Last a
    Last (a -> a
    forall a. Enum a => a -> a
    succ a
    a)
      pred :: Last a -> Last a
    pred (Last a
    a) = a -> Last a
    forall a. a -> Last a
    Last (a -> a
    forall a. Enum a => a -> a
    pred a
    a)
      toEnum :: Int -> Last a
    toEnum = a -> Last a
    forall a. a -> Last a
    Last (a -> Last a) -> (Int -> a) -> Int -> Last a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a
    forall a. Enum a => Int -> a
    toEnum
      fromEnum :: Last a -> Int
    fromEnum = a -> Int
    forall a. Enum a => a -> Int
    fromEnum (a -> Int) -> (Last a -> a) -> Last a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last a -> a
    forall a. Last a -> a
    getLast
      enumFrom :: Last a -> [Last a]
    enumFrom (Last a
    a) = a -> Last a
    forall a. a -> Last a
    Last (a -> Last a) -> [a] -> [Last a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> [a]
    forall a. Enum a => a -> [a]
    enumFrom a
    a
      enumFromThen :: Last a -> Last a -> [Last a]
    enumFromThen (Last a
    a) (Last a
    b) = a -> Last a
    forall a. a -> Last a
    Last (a -> Last a) -> [a] -> [Last a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromThen a
    a a
    b
      enumFromTo :: Last a -> Last a -> [Last a]
    enumFromTo (Last a
    a) (Last a
    b) = a -> Last a
    forall a. a -> Last a
    Last (a -> Last a) -> [a] -> [Last a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromTo a
    a a
    b
      enumFromThenTo :: Last a -> Last a -> Last a -> [Last a]
    enumFromThenTo (Last a
    a) (Last a
    b) (Last a
    c) = a -> Last a
    forall a. a -> Last a
    Last (a -> Last a) -> [a] -> [Last a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> a -> [a]
    forall a. Enum a => a -> a -> a -> [a]
    enumFromThenTo a
    a a
    b a
    c

    -- | @since 4.9.0.0
    instance Semigroup (Last a) where
      Last a
    _ <> :: Last a -> Last a -> Last a
    <> Last a
    b = Last a
    b
      stimes :: forall b. Integral b => b -> Last a -> Last a
    stimes = b -> Last a -> Last a
    forall b a. Integral b => b -> a -> a
    stimesIdempotent

    -- | @since 4.9.0.0
    instance Functor Last where
      fmap :: forall a b. (a -> b) -> Last a -> Last b
    fmap a -> b
    f (Last a
    x) = b -> Last b
    forall a. a -> Last a
    Last (a -> b
    f a
    x)
      a
    a <$ :: forall a b. a -> Last b -> Last a
    <$ Last b
    _ = a -> Last a
    forall a. a -> Last a
    Last a
    a

    -- | @since 4.9.0.0
    instance Foldable Last where
      foldMap :: forall m a. Monoid m => (a -> m) -> Last a -> m
    foldMap a -> m
    f (Last a
    a) = a -> m
    f a
    a

    -- | @since 4.9.0.0
    instance Traversable Last where
      traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Last a -> f (Last b)
    traverse a -> f b
    f (Last a
    a) = b -> Last b
    forall a. a -> Last a
    Last (b -> Last b) -> f b -> f (Last b)
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> f b
    f a
    a

    -- | @since 4.9.0.0
    instance Applicative Last where
      pure :: forall a. a -> Last a
    pure = a -> Last a
    forall a. a -> Last a
    Last
      Last a
    a <* :: forall a b. Last a -> Last b -> Last a
    <* Last b
    _ = Last a
    a
      Last a
    _ *> :: forall a b. Last a -> Last b -> Last b
    *> Last b
    a = Last b
    a
      <*> :: forall a b. Last (a -> b) -> Last a -> Last b
    (<*>) = Last (a -> b) -> Last a -> Last b
    forall a b. Coercible a b => a -> b
    coerce
      liftA2 :: forall a b c. (a -> b -> c) -> Last a -> Last b -> Last c
    liftA2 = (a -> b -> c) -> Last a -> Last b -> Last c
    forall a b. Coercible a b => a -> b
    coerce

    -- | @since 4.9.0.0
    instance Monad Last where
      >> :: forall a b. Last a -> Last b -> Last b
    (>>) = Last a -> Last b -> Last b
    forall a b. Last a -> Last b -> Last b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
      Last a
    a >>= :: forall a b. Last a -> (a -> Last b) -> Last b
    >>= a -> Last b
    f = a -> Last b
    f a
    a

    -- | @since 4.9.0.0
    instance MonadFix Last where
      mfix :: forall a. (a -> Last a) -> Last a
    mfix a -> Last a
    f = (Last a -> Last a) -> Last a
    forall a. (a -> a) -> a
    fix (a -> Last a
    f (a -> Last a) -> (Last a -> a) -> Last a -> Last a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Last a -> a
    forall a. Last a -> a
    getLast)

    -- | Provide a Semigroup for an arbitrary Monoid.
    --
    -- __NOTE__: This is not needed anymore since 'Semigroup' became a superclass of
    -- 'Monoid' in /base-4.11/ and this newtype be deprecated at some point in the future.
    newtype WrappedMonoid m = WrapMonoid { forall m. WrappedMonoid m -> m
    unwrapMonoid :: m }
      deriving ( WrappedMonoid m
    WrappedMonoid m -> WrappedMonoid m -> Bounded (WrappedMonoid m)
    forall a. a -> a -> Bounded a
    forall m. Bounded m => WrappedMonoid m
    $cminBound :: forall m. Bounded m => WrappedMonoid m
    minBound :: WrappedMonoid m
    $cmaxBound :: forall m. Bounded m => WrappedMonoid m
    maxBound :: WrappedMonoid m
    Bounded  -- ^ @since 4.9.0.0
               , WrappedMonoid m -> WrappedMonoid m -> Bool
    (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> Eq (WrappedMonoid m)
    forall m. Eq m => WrappedMonoid m -> WrappedMonoid m -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall m. Eq m => WrappedMonoid m -> WrappedMonoid m -> Bool
    == :: WrappedMonoid m -> WrappedMonoid m -> Bool
    $c/= :: forall m. Eq m => WrappedMonoid m -> WrappedMonoid m -> Bool
    /= :: WrappedMonoid m -> WrappedMonoid m -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (WrappedMonoid m)
    Eq (WrappedMonoid m) =>
    (WrappedMonoid m -> WrappedMonoid m -> Ordering)
    -> (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> (WrappedMonoid m -> WrappedMonoid m -> Bool)
    -> (WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m)
    -> (WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m)
    -> Ord (WrappedMonoid m)
    WrappedMonoid m -> WrappedMonoid m -> Bool
    WrappedMonoid m -> WrappedMonoid m -> Ordering
    WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall m. Ord m => Eq (WrappedMonoid m)
    forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Bool
    forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Ordering
    forall m.
    Ord m =>
    WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    $ccompare :: forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Ordering
    compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering
    $c< :: forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Bool
    < :: WrappedMonoid m -> WrappedMonoid m -> Bool
    $c<= :: forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Bool
    <= :: WrappedMonoid m -> WrappedMonoid m -> Bool
    $c> :: forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Bool
    > :: WrappedMonoid m -> WrappedMonoid m -> Bool
    $c>= :: forall m. Ord m => WrappedMonoid m -> WrappedMonoid m -> Bool
    >= :: WrappedMonoid m -> WrappedMonoid m -> Bool
    $cmax :: forall m.
    Ord m =>
    WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    $cmin :: forall m.
    Ord m =>
    WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    Ord      -- ^ @since 4.9.0.0
               , Int -> WrappedMonoid m -> ShowS
    [WrappedMonoid m] -> ShowS
    WrappedMonoid m -> String
    (Int -> WrappedMonoid m -> ShowS)
    -> (WrappedMonoid m -> String)
    -> ([WrappedMonoid m] -> ShowS)
    -> Show (WrappedMonoid m)
    forall m. Show m => Int -> WrappedMonoid m -> ShowS
    forall m. Show m => [WrappedMonoid m] -> ShowS
    forall m. Show m => WrappedMonoid m -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall m. Show m => Int -> WrappedMonoid m -> ShowS
    showsPrec :: Int -> WrappedMonoid m -> ShowS
    $cshow :: forall m. Show m => WrappedMonoid m -> String
    show :: WrappedMonoid m -> String
    $cshowList :: forall m. Show m => [WrappedMonoid m] -> ShowS
    showList :: [WrappedMonoid m] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , ReadPrec [WrappedMonoid m]
    ReadPrec (WrappedMonoid m)
    Int -> ReadS (WrappedMonoid m)
    ReadS [WrappedMonoid m]
    (Int -> ReadS (WrappedMonoid m))
    -> ReadS [WrappedMonoid m]
    -> ReadPrec (WrappedMonoid m)
    -> ReadPrec [WrappedMonoid m]
    -> Read (WrappedMonoid m)
    forall m. Read m => ReadPrec [WrappedMonoid m]
    forall m. Read m => ReadPrec (WrappedMonoid m)
    forall m. Read m => Int -> ReadS (WrappedMonoid m)
    forall m. Read m => ReadS [WrappedMonoid m]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall m. Read m => Int -> ReadS (WrappedMonoid m)
    readsPrec :: Int -> ReadS (WrappedMonoid m)
    $creadList :: forall m. Read m => ReadS [WrappedMonoid m]
    readList :: ReadS [WrappedMonoid m]
    $creadPrec :: forall m. Read m => ReadPrec (WrappedMonoid m)
    readPrec :: ReadPrec (WrappedMonoid m)
    $creadListPrec :: forall m. Read m => ReadPrec [WrappedMonoid m]
    readListPrec :: ReadPrec [WrappedMonoid m]
    Read     -- ^ @since 4.9.0.0
               , Typeable (WrappedMonoid m)
    Typeable (WrappedMonoid m) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m))
    -> (WrappedMonoid m -> Constr)
    -> (WrappedMonoid m -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (WrappedMonoid m)))
    -> ((forall b. Data b => b -> b)
        -> WrappedMonoid m -> WrappedMonoid m)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> WrappedMonoid m -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> WrappedMonoid m -> m (WrappedMonoid m))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> WrappedMonoid m -> m (WrappedMonoid m))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> WrappedMonoid m -> m (WrappedMonoid m))
    -> Data (WrappedMonoid m)
    WrappedMonoid m -> Constr
    WrappedMonoid m -> DataType
    (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m
    forall m. Data m => Typeable (WrappedMonoid m)
    forall m. Data m => WrappedMonoid m -> Constr
    forall m. Data m => WrappedMonoid m -> DataType
    forall m.
    Data m =>
    (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m
    forall m u.
    Data m =>
    Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u
    forall m u.
    Data m =>
    (forall d. Data d => d -> u) -> WrappedMonoid m -> [u]
    forall m r r'.
    Data m =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    forall m r r'.
    Data m =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    forall m (m :: * -> *).
    (Data m, Monad m) =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    forall m (m :: * -> *).
    (Data m, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    forall m (c :: * -> *).
    Data m =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m)
    forall m (c :: * -> *).
    Data m =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m)
    forall m (t :: * -> *) (c :: * -> *).
    (Data m, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m))
    forall m (t :: * -> * -> *) (c :: * -> *).
    (Data m, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WrappedMonoid m))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u
    forall u. (forall d. Data d => d -> u) -> WrappedMonoid m -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WrappedMonoid m))
    $cgfoldl :: forall m (c :: * -> *).
    Data m =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m)
    $cgunfold :: forall m (c :: * -> *).
    Data m =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m)
    $ctoConstr :: forall m. Data m => WrappedMonoid m -> Constr
    toConstr :: WrappedMonoid m -> Constr
    $cdataTypeOf :: forall m. Data m => WrappedMonoid m -> DataType
    dataTypeOf :: WrappedMonoid m -> DataType
    $cdataCast1 :: forall m (t :: * -> *) (c :: * -> *).
    (Data m, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m))
    $cdataCast2 :: forall m (t :: * -> * -> *) (c :: * -> *).
    (Data m, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WrappedMonoid m))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (WrappedMonoid m))
    $cgmapT :: forall m.
    Data m =>
    (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m
    gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m
    $cgmapQl :: forall m r r'.
    Data m =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    $cgmapQr :: forall m r r'.
    Data m =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r
    $cgmapQ :: forall m u.
    Data m =>
    (forall d. Data d => d -> u) -> WrappedMonoid m -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> WrappedMonoid m -> [u]
    $cgmapQi :: forall m u.
    Data m =>
    Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u
    $cgmapM :: forall m (m :: * -> *).
    (Data m, Monad m) =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    $cgmapMp :: forall m (m :: * -> *).
    (Data m, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    $cgmapMo :: forall m (m :: * -> *).
    (Data m, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WrappedMonoid m -> m (WrappedMonoid m)
    Data     -- ^ @since 4.9.0.0
               , (forall x. WrappedMonoid m -> Rep (WrappedMonoid m) x)
    -> (forall x. Rep (WrappedMonoid m) x -> WrappedMonoid m)
    -> Generic (WrappedMonoid m)
    forall x. Rep (WrappedMonoid m) x -> WrappedMonoid m
    forall x. WrappedMonoid m -> Rep (WrappedMonoid m) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall m x. Rep (WrappedMonoid m) x -> WrappedMonoid m
    forall m x. WrappedMonoid m -> Rep (WrappedMonoid m) x
    $cfrom :: forall m x. WrappedMonoid m -> Rep (WrappedMonoid m) x
    from :: forall x. WrappedMonoid m -> Rep (WrappedMonoid m) x
    $cto :: forall m x. Rep (WrappedMonoid m) x -> WrappedMonoid m
    to :: forall x. Rep (WrappedMonoid m) x -> WrappedMonoid m
    Generic  -- ^ @since 4.9.0.0
               , (forall a. WrappedMonoid a -> Rep1 WrappedMonoid a)
    -> (forall a. Rep1 WrappedMonoid a -> WrappedMonoid a)
    -> Generic1 WrappedMonoid
    forall a. Rep1 WrappedMonoid a -> WrappedMonoid a
    forall a. WrappedMonoid a -> Rep1 WrappedMonoid a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. WrappedMonoid a -> Rep1 WrappedMonoid a
    from1 :: forall a. WrappedMonoid a -> Rep1 WrappedMonoid a
    $cto1 :: forall a. Rep1 WrappedMonoid a -> WrappedMonoid a
    to1 :: forall a. Rep1 WrappedMonoid a -> WrappedMonoid a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Monoid m => Semigroup (WrappedMonoid m) where
      <> :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    (<>) = (m -> m -> m)
    -> WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m
    forall a b. Coercible a b => a -> b
    coerce (m -> m -> m
    forall a. Monoid a => a -> a -> a
    mappend :: m -> m -> m)

    -- | @since 4.9.0.0
    instance Monoid m => Monoid (WrappedMonoid m) where
      mempty :: WrappedMonoid m
    mempty = m -> WrappedMonoid m
    forall m. m -> WrappedMonoid m
    WrapMonoid m
    forall a. Monoid a => a
    mempty
      -- This ensures that we use whatever mconcat is defined for the wrapped
      -- Monoid.
      mconcat :: [WrappedMonoid m] -> WrappedMonoid m
    mconcat = ([m] -> m) -> [WrappedMonoid m] -> WrappedMonoid m
    forall a b. Coercible a b => a -> b
    coerce ([m] -> m
    forall a. Monoid a => [a] -> a
    mconcat :: [m] -> m)

    -- | @since 4.9.0.0
    instance Enum a => Enum (WrappedMonoid a) where
      succ :: WrappedMonoid a -> WrappedMonoid a
    succ (WrapMonoid a
    a) = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> a
    forall a. Enum a => a -> a
    succ a
    a)
      pred :: WrappedMonoid a -> WrappedMonoid a
    pred (WrapMonoid a
    a) = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> a
    forall a. Enum a => a -> a
    pred a
    a)
      toEnum :: Int -> WrappedMonoid a
    toEnum = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> WrappedMonoid a) -> (Int -> a) -> Int -> WrappedMonoid a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> a
    forall a. Enum a => Int -> a
    toEnum
      fromEnum :: WrappedMonoid a -> Int
    fromEnum = a -> Int
    forall a. Enum a => a -> Int
    fromEnum (a -> Int) -> (WrappedMonoid a -> a) -> WrappedMonoid a -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . WrappedMonoid a -> a
    forall m. WrappedMonoid m -> m
    unwrapMonoid
      enumFrom :: WrappedMonoid a -> [WrappedMonoid a]
    enumFrom (WrapMonoid a
    a) = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> WrappedMonoid a) -> [a] -> [WrappedMonoid a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> [a]
    forall a. Enum a => a -> [a]
    enumFrom a
    a
      enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]
    enumFromThen (WrapMonoid a
    a) (WrapMonoid a
    b) = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> WrappedMonoid a) -> [a] -> [WrappedMonoid a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromThen a
    a a
    b
      enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]
    enumFromTo (WrapMonoid a
    a) (WrapMonoid a
    b) = a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> WrappedMonoid a) -> [a] -> [WrappedMonoid a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> [a]
    forall a. Enum a => a -> a -> [a]
    enumFromTo a
    a a
    b
      enumFromThenTo :: WrappedMonoid a
    -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a]
    enumFromThenTo (WrapMonoid a
    a) (WrapMonoid a
    b) (WrapMonoid a
    c) =
          a -> WrappedMonoid a
    forall m. m -> WrappedMonoid m
    WrapMonoid (a -> WrappedMonoid a) -> [a] -> [WrappedMonoid a]
    forall a b. (a -> b) -> [a] -> [b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    `fmap` a -> a -> a -> [a]
    forall a. Enum a => a -> a -> a -> [a]
    enumFromThenTo a
    a a
    b a
    c

    -- | Repeat a value @n@ times.
    --
    -- > mtimesDefault n a = a <> a <> ... <> a  -- using <> (n-1) times
    --
    -- In many cases, @'stimes' 0 a@ for a `Monoid` will produce `mempty`.
    -- However, there are situations when it cannot do so. In particular,
    -- the following situation is fairly common:
    --
    -- @
    -- data T a = ...
    --
    -- class Constraint1 a
    -- class Constraint1 a => Constraint2 a
    -- @
    --
    -- @
    -- instance Constraint1 a => 'Semigroup' (T a)
    -- instance Constraint2 a => 'Monoid' (T a)
    -- @
    --
    -- Since @Constraint1@ is insufficient to implement 'mempty',
    -- 'stimes' for @T a@ cannot do so.
    --
    -- When working with such a type, or when working polymorphically with
    -- 'Semigroup' instances, @mtimesDefault@ should be used when the
    -- multiplier might be zero. It is implemented using 'stimes' when
    -- the multiplier is nonzero and 'mempty' when it is zero.
    --
    -- ==== __Examples__
    --
    -- >>> mtimesDefault 0 "bark"
    -- []
    --
    -- >>> mtimesDefault 3 "meow"
    -- "meowmeowmeow"
    mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
    mtimesDefault :: forall b a. (Integral b, Monoid a) => b -> a -> a
    mtimesDefault b
    n a
    x
      | b
    n b -> b -> Bool
    forall a. Eq a => a -> a -> Bool
    == b
    0    = a
    forall a. Monoid a => a
    mempty
      | Bool
    otherwise = b -> a -> a
    forall b. Integral b => b -> a -> a
    forall a b. (Semigroup a, Integral b) => b -> a -> a
    stimes b
    n a
    x