Data/Functor/Identity.hs

    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveGeneric #-}
    {-# LANGUAGE DeriveTraversable #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE Trustworthy #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Data.Functor.Identity
    -- Copyright   :  (c) Andy Gill 2001,
    --                (c) Oregon Graduate Institute of Science and Technology 2001
    -- License     :  BSD-style (see the file LICENSE)
    --
    -- Maintainer  :  ross@soi.city.ac.uk
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- The identity functor and monad.
    --
    -- This trivial type constructor serves two purposes:
    --
    -- * It can be used with functions parameterized by functor or monad classes.
    --
    -- * It can be used as a base monad to which a series of monad
    --   transformers may be applied to construct a composite monad.
    --   Most monad transformer modules include the special case of
    --   applying the transformer to 'Identity'.  For example, @State s@
    --   is an abbreviation for @StateT s 'Identity'@.
    --
    -- @since 4.8.0.0
    -----------------------------------------------------------------------------

    module Data.Functor.Identity (
        Identity(..),
      ) where

    import Control.Monad.Fix
    import Control.Monad.Zip
    import Data.Coerce
    import Data.Data (Data)
    import Data.Foldable
    import Data.Ix (Ix)
    import Data.Semigroup (Semigroup)
    import Foreign.Storable (Storable)
    import GHC.Generics (Generic, Generic1)

    -- | Identity functor and monad. (a non-strict monad)
    --
    -- @since 4.8.0.0
    newtype Identity a = Identity { runIdentity :: a }
        deriving ( Bounded, Enum, Eq, Ix, Ord, Data, Monoid, Semigroup
                 , Storable, Traversable, Generic, Generic1)

    -- | This instance would be equivalent to the derived instances of the
    -- 'Identity' newtype if the 'runIdentity' field were removed
    instance (Read a) => Read (Identity a) where
        readsPrec d = readParen (d > 10) $ \ r ->
            [(Identity x,t) | ("Identity",s) <- lex r, (x,t) <- readsPrec 11 s]

    -- | This instance would be equivalent to the derived instances of the
    -- 'Identity' newtype if the 'runIdentity' field were removed
    instance (Show a) => Show (Identity a) where
        showsPrec d (Identity x) = showParen (d > 10) $
            showString "Identity " . showsPrec 11 x

    -- ---------------------------------------------------------------------------
    -- Identity instances for Functor and Monad

    instance Foldable Identity where
        foldMap                = coerce

        elem                   = (. runIdentity) #. (==)
        foldl                  = coerce
        foldl'                 = coerce
        foldl1 _               = runIdentity
        foldr f z (Identity x) = f x z
        foldr'                 = foldr
        foldr1 _               = runIdentity
        length _               = 1
        maximum                = runIdentity
        minimum                = runIdentity
        null _                 = False
        product                = runIdentity
        sum                    = runIdentity
        toList (Identity x)    = [x]

    instance Functor Identity where
        fmap     = coerce

    instance Applicative Identity where
        pure     = Identity
        (<*>)    = coerce

    instance Monad Identity where
        m >>= k  = k (runIdentity m)

    instance MonadFix Identity where
        mfix f   = Identity (fix (runIdentity . f))

    instance MonadZip Identity where
        mzipWith = coerce
        munzip   = coerce

    -- | Internal (non-exported) 'Coercible' helper for 'elem'
    --
    -- See Note [Function coercion] in "Data.Foldable" for more details.
    (#.) :: Coercible b c => (b -> c) -> (a -> b) -> a -> c
    (#.) _f = coerce