{-# LANGUAGE CPP #-}
{-# LANGUAGE EmptyCase #-}
{-# OPTIONS_GHC -Wno-orphans #-}

{- | Here we define orphan instances for as many @base@ types as we can. These fall into a few categories:

- Primitive types e.g. 'Char' and 'Int' - these typically don't have Generic instances, so we use 'eqDiff'
- Opaque types that don't expose constructors, so we couldn't write hand-rolled instances if we want to -
  all we have is an 'Eq' instance, so again we use 'eqDiff'.
- Compound types e.g. 'Maybe' and 'Either' - these have 'Generic' instances so we can just use 'gdiff'.
- List-like types such as @[a]@ and @'NE.NonEmpty' a@ - these we give slightly special treatment, since they're
  so ubiquitous and 'gdiff' would produce very hard-to-read output.
-}
module Generics.Diff.Instances where

import Control.Applicative
import Control.Concurrent
import Control.Exception
#if MIN_VERSION_base(4,17,0)
import Data.Array.Byte
#endif
import Data.Char
import Data.Complex
import Data.Data
import Data.Fixed
import qualified Data.Functor.Compose as F
import Data.Functor.Identity
import Data.Functor.Product
import Data.Functor.Sum
import Data.IORef
import Data.Int
import qualified Data.List.NonEmpty as NE
import qualified Data.Monoid as M
import Data.Ord
import Data.Ratio
import Data.SOP
import Data.STRef
import qualified Data.Semigroup as S
import qualified Data.Text as T
import Data.Text.Encoding.Error (UnicodeException)
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Builder as TLB
import Data.Type.Coercion
#if MIN_VERSION_base(4,16,0)
import Data.Type.Ord
#endif
import Data.Unique
import Data.Version
import Data.Void
import Data.Word
import Numeric.Natural
#if MIN_VERSION_base(4,18,0)
import Foreign.C.ConstPtr
#endif
import Foreign.C.Error
import Foreign.C.Types
import Foreign.ForeignPtr
import Foreign.Ptr
import Foreign.StablePtr
import GHC.Arr
import GHC.Base
import GHC.ByteOrder
import GHC.Conc
import GHC.Event
import GHC.Fingerprint
import qualified GHC.Generics as G
import GHC.IO.Buffer
import GHC.IO.Device
import GHC.IOArray
#if MIN_VERSION_base(4,18,0)
import GHC.InfoProv
#endif
import GHC.StableName
import GHC.Stack
#if MIN_VERSION_base(4,17,0)
import GHC.Stack.CloneStack
#endif
import GHC.TypeLits
import Generics.Diff.Class
import Generics.Diff.Type
import Generics.SOP
import System.Exit
import System.IO
import System.IO.Error
#if MIN_VERSION_base(4,14,0)
import System.Timeout
#endif
import Text.Read (Lexeme)
import qualified Type.Reflection as TR

-- primitive(ish) types

{- FOURMOLU_DISABLE -}

instance Diff Void where diff :: Void -> Void -> DiffResult Void
diff = \case {}
instance Diff () where diff :: () -> () -> DiffResult ()
diff () () = DiffResult ()
forall a. DiffResult a
Equal
instance Diff (Proxy a) where diff :: Proxy a -> Proxy a -> DiffResult (Proxy a)
diff Proxy a
Proxy Proxy a
Proxy = DiffResult (Proxy a)
forall a. DiffResult a
Equal
instance Diff Bool where diff :: Bool -> Bool -> DiffResult Bool
diff = Bool -> Bool -> DiffResult Bool
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Ordering where diff :: Ordering -> Ordering -> DiffResult Ordering
diff = Ordering -> Ordering -> DiffResult Ordering
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Double where diff :: Double -> Double -> DiffResult Double
diff = Double -> Double -> DiffResult Double
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Float where diff :: Float -> Float -> DiffResult Float
diff = Float -> Float -> DiffResult Float
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Int where diff :: Int -> Int -> DiffResult Int
diff = Int -> Int -> DiffResult Int
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Int8 where diff :: Int8 -> Int8 -> DiffResult Int8
diff = Int8 -> Int8 -> DiffResult Int8
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Int16 where diff :: Int16 -> Int16 -> DiffResult Int16
diff = Int16 -> Int16 -> DiffResult Int16
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Int32 where diff :: Int32 -> Int32 -> DiffResult Int32
diff = Int32 -> Int32 -> DiffResult Int32
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Int64 where diff :: Int64 -> Int64 -> DiffResult Int64
diff = Int64 -> Int64 -> DiffResult Int64
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Word where diff :: Word -> Word -> DiffResult Word
diff = Word -> Word -> DiffResult Word
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Word8 where diff :: Word8 -> Word8 -> DiffResult Word8
diff = Word8 -> Word8 -> DiffResult Word8
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Word16 where diff :: Word16 -> Word16 -> DiffResult Word16
diff = Word16 -> Word16 -> DiffResult Word16
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Word32 where diff :: Word32 -> Word32 -> DiffResult Word32
diff = Word32 -> Word32 -> DiffResult Word32
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Word64 where diff :: Word64 -> Word64 -> DiffResult Word64
diff = Word64 -> Word64 -> DiffResult Word64
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Version where diff :: Version -> Version -> DiffResult Version
diff = Version -> Version -> DiffResult Version
forall a. Eq a => a -> a -> DiffResult a
eqDiff

instance Diff Char where
  diff :: Char -> Char -> DiffResult Char
diff = Char -> Char -> DiffResult Char
forall a. Eq a => a -> a -> DiffResult a
eqDiff
  diffList :: [Char] -> [Char] -> DiffResult [Char]
diffList = [Char] -> [Char] -> DiffResult [Char]
forall a. Eq a => a -> a -> DiffResult a
eqDiff

instance (Eq a) => Diff (Ratio a) where diff :: Ratio a -> Ratio a -> DiffResult (Ratio a)
diff = Ratio a -> Ratio a -> DiffResult (Ratio a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Integer where diff :: Integer -> Integer -> DiffResult Integer
diff = Integer -> Integer -> DiffResult Integer
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff ThreadId where diff :: ThreadId -> ThreadId -> DiffResult ThreadId
diff = ThreadId -> ThreadId -> DiffResult ThreadId
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (Chan a) where diff :: Chan a -> Chan a -> DiffResult (Chan a)
diff = Chan a -> Chan a -> DiffResult (Chan a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (MVar a) where diff :: MVar a -> MVar a -> DiffResult (MVar a)
diff = MVar a -> MVar a -> DiffResult (MVar a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (IORef a) where diff :: IORef a -> IORef a -> DiffResult (IORef a)
diff = IORef a -> IORef a -> DiffResult (IORef a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff TypeRep where diff :: TypeRep -> TypeRep -> DiffResult TypeRep
diff = TypeRep -> TypeRep -> DiffResult TypeRep
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (TR.TypeRep a) where diff :: TypeRep a -> TypeRep a -> DiffResult (TypeRep a)
diff = TypeRep a -> TypeRep a -> DiffResult (TypeRep a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff TyCon where diff :: TyCon -> TyCon -> DiffResult TyCon
diff = TyCon -> TyCon -> DiffResult TyCon
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (STRef s a) where diff :: STRef s a -> STRef s a -> DiffResult (STRef s a)
diff = STRef s a -> STRef s a -> DiffResult (STRef s a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Unique where diff :: Unique -> Unique -> DiffResult Unique
diff = Unique -> Unique -> DiffResult Unique
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (ForeignPtr a) where diff :: ForeignPtr a -> ForeignPtr a -> DiffResult (ForeignPtr a)
diff = ForeignPtr a -> ForeignPtr a -> DiffResult (ForeignPtr a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (Ptr a) where diff :: Ptr a -> Ptr a -> DiffResult (Ptr a)
diff = Ptr a -> Ptr a -> DiffResult (Ptr a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (FunPtr a) where diff :: FunPtr a -> FunPtr a -> DiffResult (FunPtr a)
diff = FunPtr a -> FunPtr a -> DiffResult (FunPtr a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff IntPtr where diff :: IntPtr -> IntPtr -> DiffResult IntPtr
diff = IntPtr -> IntPtr -> DiffResult IntPtr
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff WordPtr where diff :: WordPtr -> WordPtr -> DiffResult WordPtr
diff = WordPtr -> WordPtr -> DiffResult WordPtr
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (StablePtr a) where diff :: StablePtr a -> StablePtr a -> DiffResult (StablePtr a)
diff = StablePtr a -> StablePtr a -> DiffResult (StablePtr a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Handle where diff :: Handle -> Handle -> DiffResult Handle
diff = Handle -> Handle -> DiffResult Handle
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff HandlePosn where diff :: HandlePosn -> HandlePosn -> DiffResult HandlePosn
diff = HandlePosn -> HandlePosn -> DiffResult HandlePosn
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (StableName a) where diff :: StableName a -> StableName a -> DiffResult (StableName a)
diff = StableName a -> StableName a -> DiffResult (StableName a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (TVar a) where diff :: TVar a -> TVar a -> DiffResult (TVar a)
diff = TVar a -> TVar a -> DiffResult (TVar a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Natural where diff :: Natural -> Natural -> DiffResult Natural
diff = Natural -> Natural -> DiffResult Natural
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Event where diff :: Event -> Event -> DiffResult Event
diff = Event -> Event -> DiffResult Event
forall a. Eq a => a -> a -> DiffResult a
eqDiff

instance Diff CChar where diff :: CChar -> CChar -> DiffResult CChar
diff = CChar -> CChar -> DiffResult CChar
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CSChar where diff :: CSChar -> CSChar -> DiffResult CSChar
diff = CSChar -> CSChar -> DiffResult CSChar
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUChar where diff :: CUChar -> CUChar -> DiffResult CUChar
diff = CUChar -> CUChar -> DiffResult CUChar
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CShort where diff :: CShort -> CShort -> DiffResult CShort
diff = CShort -> CShort -> DiffResult CShort
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUShort where diff :: CUShort -> CUShort -> DiffResult CUShort
diff = CUShort -> CUShort -> DiffResult CUShort
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CInt where diff :: CInt -> CInt -> DiffResult CInt
diff = CInt -> CInt -> DiffResult CInt
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUInt where diff :: CUInt -> CUInt -> DiffResult CUInt
diff = CUInt -> CUInt -> DiffResult CUInt
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CLong where diff :: CLong -> CLong -> DiffResult CLong
diff = CLong -> CLong -> DiffResult CLong
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CULong where diff :: CULong -> CULong -> DiffResult CULong
diff = CULong -> CULong -> DiffResult CULong
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CPtrdiff where diff :: CPtrdiff -> CPtrdiff -> DiffResult CPtrdiff
diff = CPtrdiff -> CPtrdiff -> DiffResult CPtrdiff
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CSize where diff :: CSize -> CSize -> DiffResult CSize
diff = CSize -> CSize -> DiffResult CSize
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CWchar where diff :: CWchar -> CWchar -> DiffResult CWchar
diff = CWchar -> CWchar -> DiffResult CWchar
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CSigAtomic where diff :: CSigAtomic -> CSigAtomic -> DiffResult CSigAtomic
diff = CSigAtomic -> CSigAtomic -> DiffResult CSigAtomic
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CLLong where diff :: CLLong -> CLLong -> DiffResult CLLong
diff = CLLong -> CLLong -> DiffResult CLLong
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CULLong where diff :: CULLong -> CULLong -> DiffResult CULLong
diff = CULLong -> CULLong -> DiffResult CULLong
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CIntPtr where diff :: CIntPtr -> CIntPtr -> DiffResult CIntPtr
diff = CIntPtr -> CIntPtr -> DiffResult CIntPtr
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUIntPtr where diff :: CUIntPtr -> CUIntPtr -> DiffResult CUIntPtr
diff = CUIntPtr -> CUIntPtr -> DiffResult CUIntPtr
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CIntMax where diff :: CIntMax -> CIntMax -> DiffResult CIntMax
diff = CIntMax -> CIntMax -> DiffResult CIntMax
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUIntMax where diff :: CUIntMax -> CUIntMax -> DiffResult CUIntMax
diff = CUIntMax -> CUIntMax -> DiffResult CUIntMax
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CClock where diff :: CClock -> CClock -> DiffResult CClock
diff = CClock -> CClock -> DiffResult CClock
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CTime where diff :: CTime -> CTime -> DiffResult CTime
diff = CTime -> CTime -> DiffResult CTime
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CUSeconds where diff :: CUSeconds -> CUSeconds -> DiffResult CUSeconds
diff = CUSeconds -> CUSeconds -> DiffResult CUSeconds
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CSUSeconds where diff :: CSUSeconds -> CSUSeconds -> DiffResult CSUSeconds
diff = CSUSeconds -> CSUSeconds -> DiffResult CSUSeconds
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CFloat where diff :: CFloat -> CFloat -> DiffResult CFloat
diff = CFloat -> CFloat -> DiffResult CFloat
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CDouble where diff :: CDouble -> CDouble -> DiffResult CDouble
diff = CDouble -> CDouble -> DiffResult CDouble
forall a. Eq a => a -> a -> DiffResult a
eqDiff

instance Diff E0
instance Diff E1
instance Diff E2
instance Diff E3
instance Diff E6
instance Diff E9
instance Diff E12

instance Diff T.Text where diff :: Text -> Text -> DiffResult Text
diff = Text -> Text -> DiffResult Text
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff TL.Text where diff :: Text -> Text -> DiffResult Text
diff = Text -> Text -> DiffResult Text
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff TLB.Builder where diff :: Builder -> Builder -> DiffResult Builder
diff = Builder -> Builder -> DiffResult Builder
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff UnicodeException where diff :: UnicodeException -> UnicodeException -> DiffResult UnicodeException
diff = UnicodeException -> UnicodeException -> DiffResult UnicodeException
forall a. Eq a => a -> a -> DiffResult a
eqDiff

instance Diff ArithException where diff :: ArithException -> ArithException -> DiffResult ArithException
diff = ArithException -> ArithException -> DiffResult ArithException
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff ArrayException where diff :: ArrayException -> ArrayException -> DiffResult ArrayException
diff = ArrayException -> ArrayException -> DiffResult ArrayException
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Associativity where diff :: Associativity -> Associativity -> DiffResult Associativity
diff = Associativity -> Associativity -> DiffResult Associativity
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff AsyncException where diff :: AsyncException -> AsyncException -> DiffResult AsyncException
diff = AsyncException -> AsyncException -> DiffResult AsyncException
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff BlockReason where diff :: BlockReason -> BlockReason -> DiffResult BlockReason
diff = BlockReason -> BlockReason -> DiffResult BlockReason
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff BufferMode where diff :: BufferMode -> BufferMode -> DiffResult BufferMode
diff = BufferMode -> BufferMode -> DiffResult BufferMode
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff BufferState where diff :: BufferState -> BufferState -> DiffResult BufferState
diff = BufferState -> BufferState -> DiffResult BufferState
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,17,0)
instance Diff ByteArray where diff :: ByteArray -> ByteArray -> DiffResult ByteArray
diff = ByteArray -> ByteArray -> DiffResult ByteArray
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff ByteOrder where diff :: ByteOrder -> ByteOrder -> DiffResult ByteOrder
diff = ByteOrder -> ByteOrder -> DiffResult ByteOrder
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff CBool where diff :: CBool -> CBool -> DiffResult CBool
diff = CBool -> CBool -> DiffResult CBool
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff (Coercion a b) where diff :: Coercion a b -> Coercion a b -> DiffResult (Coercion a b)
diff = Coercion a b -> Coercion a b -> DiffResult (Coercion a b)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,18,0)
instance Diff (ConstPtr a) where diff :: ConstPtr a -> ConstPtr a -> DiffResult (ConstPtr a)
diff = ConstPtr a -> ConstPtr a -> DiffResult (ConstPtr a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff DataRep where diff :: DataRep -> DataRep -> DiffResult DataRep
diff = DataRep -> DataRep -> DiffResult DataRep
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff G.DecidedStrictness where diff :: DecidedStrictness
-> DecidedStrictness -> DiffResult DecidedStrictness
diff = DecidedStrictness
-> DecidedStrictness -> DiffResult DecidedStrictness
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Errno where diff :: Errno -> Errno -> DiffResult Errno
diff = Errno -> Errno -> DiffResult Errno
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff ErrorCall where diff :: ErrorCall -> ErrorCall -> DiffResult ErrorCall
diff = ErrorCall -> ErrorCall -> DiffResult ErrorCall
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff ExitCode where diff :: ExitCode -> ExitCode -> DiffResult ExitCode
diff = ExitCode -> ExitCode -> DiffResult ExitCode
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff FdKey where diff :: FdKey -> FdKey -> DiffResult FdKey
diff = FdKey -> FdKey -> DiffResult FdKey
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Fingerprint where diff :: Fingerprint -> Fingerprint -> DiffResult Fingerprint
diff = Fingerprint -> Fingerprint -> DiffResult Fingerprint
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff G.Fixity where diff :: Fixity -> Fixity -> DiffResult Fixity
diff = Fixity -> Fixity -> DiffResult Fixity
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff GeneralCategory where diff :: GeneralCategory -> GeneralCategory -> DiffResult GeneralCategory
diff = GeneralCategory -> GeneralCategory -> DiffResult GeneralCategory
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,18,0)
instance Diff InfoProv where diff :: InfoProv -> InfoProv -> DiffResult InfoProv
diff = InfoProv -> InfoProv -> DiffResult InfoProv
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff (IOArray i e) where diff :: IOArray i e -> IOArray i e -> DiffResult (IOArray i e)
diff = IOArray i e -> IOArray i e -> DiffResult (IOArray i e)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff IODeviceType where diff :: IODeviceType -> IODeviceType -> DiffResult IODeviceType
diff = IODeviceType -> IODeviceType -> DiffResult IODeviceType
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff IOErrorType where diff :: IOErrorType -> IOErrorType -> DiffResult IOErrorType
diff = IOErrorType -> IOErrorType -> DiffResult IOErrorType
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff IOException where diff :: IOException -> IOException -> DiffResult IOException
diff = IOException -> IOException -> DiffResult IOException
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff IOMode where diff :: IOMode -> IOMode -> DiffResult IOMode
diff = IOMode -> IOMode -> DiffResult IOMode
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Lexeme where diff :: Lexeme -> Lexeme -> DiffResult Lexeme
diff = Lexeme -> Lexeme -> DiffResult Lexeme
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Lifetime where diff :: Lifetime -> Lifetime -> DiffResult Lifetime
diff = Lifetime -> Lifetime -> DiffResult Lifetime
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff MaskingState where diff :: MaskingState -> MaskingState -> DiffResult MaskingState
diff = MaskingState -> MaskingState -> DiffResult MaskingState
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,17,0)
instance Diff (MutableByteArray a) where diff :: MutableByteArray a
-> MutableByteArray a -> DiffResult (MutableByteArray a)
diff = MutableByteArray a
-> MutableByteArray a -> DiffResult (MutableByteArray a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff NewlineMode where diff :: NewlineMode -> NewlineMode -> DiffResult NewlineMode
diff = NewlineMode -> NewlineMode -> DiffResult NewlineMode
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff Newline where diff :: Newline -> Newline -> DiffResult Newline
diff = Newline -> Newline -> DiffResult Newline
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,16,0)
instance Diff (OrderingI a b) where diff :: OrderingI a b -> OrderingI a b -> DiffResult (OrderingI a b)
diff = OrderingI a b -> OrderingI a b -> DiffResult (OrderingI a b)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff SeekMode where diff :: SeekMode -> SeekMode -> DiffResult SeekMode
diff = SeekMode -> SeekMode -> DiffResult SeekMode
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,16,0)
instance Diff SomeChar where diff :: SomeChar -> SomeChar -> DiffResult SomeChar
diff = SomeChar -> SomeChar -> DiffResult SomeChar
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff SomeNat where diff :: SomeNat -> SomeNat -> DiffResult SomeNat
diff = SomeNat -> SomeNat -> DiffResult SomeNat
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff SomeSymbol where diff :: SomeSymbol -> SomeSymbol -> DiffResult SomeSymbol
diff = SomeSymbol -> SomeSymbol -> DiffResult SomeSymbol
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff SrcLoc where diff :: SrcLoc -> SrcLoc -> DiffResult SrcLoc
diff = SrcLoc -> SrcLoc -> DiffResult SrcLoc
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,17,0)
instance Diff StackEntry where diff :: StackEntry -> StackEntry -> DiffResult StackEntry
diff = StackEntry -> StackEntry -> DiffResult StackEntry
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff (STArray s i a) where diff :: STArray s i a -> STArray s i a -> DiffResult (STArray s i a)
diff = STArray s i a -> STArray s i a -> DiffResult (STArray s i a)
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff ThreadStatus where diff :: ThreadStatus -> ThreadStatus -> DiffResult ThreadStatus
diff = ThreadStatus -> ThreadStatus -> DiffResult ThreadStatus
forall a. Eq a => a -> a -> DiffResult a
eqDiff
instance Diff TimeoutKey where diff :: TimeoutKey -> TimeoutKey -> DiffResult TimeoutKey
diff = TimeoutKey -> TimeoutKey -> DiffResult TimeoutKey
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#if MIN_VERSION_base(4,14,0)
instance Diff Timeout where diff :: Timeout -> Timeout -> DiffResult Timeout
diff = Timeout -> Timeout -> DiffResult Timeout
forall a. Eq a => a -> a -> DiffResult a
eqDiff
#endif
instance Diff TrName where diff :: TrName -> TrName -> DiffResult TrName
diff = TrName -> TrName -> DiffResult TrName
forall a. Eq a => a -> a -> DiffResult a
eqDiff

{- FOURMOLU_ENABLE -}

-- list-like types

instance (Diff a) => Diff [a] where
  {-# SPECIALIZE instance Diff [Char] #-}
  diff :: [a] -> [a] -> DiffResult [a]
diff = [a] -> [a] -> DiffResult [a]
forall a. Diff a => [a] -> [a] -> DiffResult [a]
diffList

instance (Diff a) => Diff (NE.NonEmpty a) where
  diff :: NonEmpty a -> NonEmpty a -> DiffResult (NonEmpty a)
diff NonEmpty a
l NonEmpty a
r = (ListDiffError a -> DiffError (NonEmpty a))
-> (a -> a -> DiffResult a)
-> [a]
-> [a]
-> DiffResult (NonEmpty a)
forall a b.
(ListDiffError a -> DiffError b)
-> (a -> a -> DiffResult a) -> [a] -> [a] -> DiffResult b
diffListWith ListDiffError a -> DiffError (NonEmpty a)
forall a1. ListDiffError a1 -> DiffError (NonEmpty a1)
DiffNonEmpty a -> a -> DiffResult a
forall a. Diff a => a -> a -> DiffResult a
diff (NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
l) (NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty a
r)

-- combinators - typically we'll use gdiff

{- FOURMOLU_DISABLE -}

instance (Diff a) => Diff (Identity a)
instance (Diff a) => Diff (I a)
instance (Diff a) => Diff (Maybe a)
instance (Diff a, Diff b) => Diff (Either a b)
instance (Diff a) => Diff (Complex a)
instance (Diff a) => Diff (M.Dual a)
instance Diff M.All
instance Diff M.Any
instance (Diff a) => Diff (M.Sum a)
instance (Diff a) => Diff (M.Product a)
instance (Diff a) => Diff (M.First a)
instance (Diff a) => Diff (M.Last a)

instance
  (HasDatatypeInfo (M.Alt f a), All2 Diff (Code (M.Alt f a))) =>
  Diff (M.Alt f a)

instance
  (HasDatatypeInfo (M.Ap f a), All2 Diff (Code (M.Ap f a))) =>
  Diff (M.Ap f a)

instance (Diff a) => Diff (Down a)
instance (Diff a) => Diff (S.Min a)
instance (Diff a) => Diff (S.Max a)
instance (Diff a) => Diff (S.First a)
instance (Diff a) => Diff (S.Last a)
instance (Diff a) => Diff (S.WrappedMonoid a)
instance (Diff a, Diff b) => Diff (S.Arg a b)

#if !MIN_VERSION_base(4,16,0)
instance (Diff a) => Diff (S.Option a)
#endif

{- FOURMOLU_ENABLE -}

-- with phantom types

instance
  (HasDatatypeInfo (Const a b), All2 Diff (Code (Const a b))) =>
  Diff (Const a b)

instance
  (HasDatatypeInfo (K a b), All2 Diff (Code (K a b))) =>
  Diff (K a b)

instance
  (HasDatatypeInfo (Fixed a), All2 Diff (Code (Fixed a))) =>
  Diff (Fixed a)

instance
  (HasDatatypeInfo ((:.:) f g a), All2 Diff (Code ((:.:) f g a))) =>
  Diff ((:.:) f g a)

instance
  (HasDatatypeInfo (F.Compose f g a), All2 Diff (Code (F.Compose f g a))) =>
  Diff (F.Compose f g a)

instance
  (HasDatatypeInfo (Product f g a), All2 Diff (Code (Product f g a))) =>
  Diff (Product f g a)

instance
  (HasDatatypeInfo (Sum f g a), All2 Diff (Code (Sum f g a))) =>
  Diff (Sum f g a)

-- tuples

{- FOURMOLU_DISABLE -}

instance (Diff a, Diff b) => Diff (a, b)
instance (Diff a, Diff b, Diff c) => Diff (a, b, c)
instance (Diff a, Diff b, Diff c, Diff d) => Diff (a, b, c, d)
instance (Diff a, Diff b, Diff c, Diff d, Diff e) => Diff (a, b, c, d, e)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f) => Diff (a, b, c, d, e, f)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g) => Diff (a, b, c, d, e, f, g)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h) => Diff (a, b, c, d, e, f, g, h)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i) => Diff (a, b, c, d, e, f, g, h, i)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j) => Diff (a, b, c, d, e, f, g, h, i, j)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k) => Diff (a, b, c, d, e, f, g, h, i, j, k)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l) => Diff (a, b, c, d, e, f, g, h, i, j, k, l)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u, Diff v) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u, Diff v, Diff w) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u, Diff v, Diff w, Diff x) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u, Diff v, Diff w, Diff x, Diff y) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)
instance (Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g, Diff h, Diff i, Diff j, Diff k, Diff l, Diff m, Diff n, Diff o, Diff p, Diff q, Diff r, Diff s, Diff t, Diff u, Diff v, Diff w, Diff x, Diff y, Diff z) => Diff (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)
{- FOURMOLU_ENABLE -}