generic-diff
Safe HaskellSafe-Inferred
LanguageHaskell2010

Generics.Diff.Instances

Description

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 NonEmpty a - these we give slightly special treatment, since they're so ubiquitous and gdiff would produce very hard-to-read output.

Orphan instances

Diff ByteArray Source # 
Instance details

Methods

diff :: ByteArray -> ByteArray -> DiffResult ByteArray Source #

diffList :: [ByteArray] -> [ByteArray] -> DiffResult [ByteArray] Source #

Diff DataRep Source # 
Instance details

Methods

diff :: DataRep -> DataRep -> DiffResult DataRep Source #

diffList :: [DataRep] -> [DataRep] -> DiffResult [DataRep] Source #

Diff E0 Source # 
Instance details

Methods

diff :: E0 -> E0 -> DiffResult E0 Source #

diffList :: [E0] -> [E0] -> DiffResult [E0] Source #

Diff E1 Source # 
Instance details

Methods

diff :: E1 -> E1 -> DiffResult E1 Source #

diffList :: [E1] -> [E1] -> DiffResult [E1] Source #

Diff E12 Source # 
Instance details

Methods

diff :: E12 -> E12 -> DiffResult E12 Source #

diffList :: [E12] -> [E12] -> DiffResult [E12] Source #

Diff E2 Source # 
Instance details

Methods

diff :: E2 -> E2 -> DiffResult E2 Source #

diffList :: [E2] -> [E2] -> DiffResult [E2] Source #

Diff E3 Source # 
Instance details

Methods

diff :: E3 -> E3 -> DiffResult E3 Source #

diffList :: [E3] -> [E3] -> DiffResult [E3] Source #

Diff E6 Source # 
Instance details

Methods

diff :: E6 -> E6 -> DiffResult E6 Source #

diffList :: [E6] -> [E6] -> DiffResult [E6] Source #

Diff E9 Source # 
Instance details

Methods

diff :: E9 -> E9 -> DiffResult E9 Source #

diffList :: [E9] -> [E9] -> DiffResult [E9] Source #

Diff All Source # 
Instance details

Methods

diff :: All -> All -> DiffResult All Source #

diffList :: [All] -> [All] -> DiffResult [All] Source #

Diff Any Source # 
Instance details

Methods

diff :: Any -> Any -> DiffResult Any Source #

diffList :: [Any] -> [Any] -> DiffResult [Any] Source #

Diff TypeRep Source # 
Instance details

Methods

diff :: TypeRep -> TypeRep -> DiffResult TypeRep Source #

diffList :: [TypeRep] -> [TypeRep] -> DiffResult [TypeRep] Source #

Diff Unique Source # 
Instance details

Methods

diff :: Unique -> Unique -> DiffResult Unique Source #

diffList :: [Unique] -> [Unique] -> DiffResult [Unique] Source #

Diff Version Source # 
Instance details

Methods

diff :: Version -> Version -> DiffResult Version Source #

diffList :: [Version] -> [Version] -> DiffResult [Version] Source #

Diff Errno Source # 
Instance details

Methods

diff :: Errno -> Errno -> DiffResult Errno Source #

diffList :: [Errno] -> [Errno] -> DiffResult [Errno] Source #

Diff CBool Source # 
Instance details

Methods

diff :: CBool -> CBool -> DiffResult CBool Source #

diffList :: [CBool] -> [CBool] -> DiffResult [CBool] Source #

Diff CChar Source # 
Instance details

Methods

diff :: CChar -> CChar -> DiffResult CChar Source #

diffList :: [CChar] -> [CChar] -> DiffResult [CChar] Source #

Diff CClock Source # 
Instance details

Methods

diff :: CClock -> CClock -> DiffResult CClock Source #

diffList :: [CClock] -> [CClock] -> DiffResult [CClock] Source #

Diff CDouble Source # 
Instance details

Methods

diff :: CDouble -> CDouble -> DiffResult CDouble Source #

diffList :: [CDouble] -> [CDouble] -> DiffResult [CDouble] Source #

Diff CFloat Source # 
Instance details

Methods

diff :: CFloat -> CFloat -> DiffResult CFloat Source #

diffList :: [CFloat] -> [CFloat] -> DiffResult [CFloat] Source #

Diff CInt Source # 
Instance details

Methods

diff :: CInt -> CInt -> DiffResult CInt Source #

diffList :: [CInt] -> [CInt] -> DiffResult [CInt] Source #

Diff CIntMax Source # 
Instance details

Methods

diff :: CIntMax -> CIntMax -> DiffResult CIntMax Source #

diffList :: [CIntMax] -> [CIntMax] -> DiffResult [CIntMax] Source #

Diff CIntPtr Source # 
Instance details

Methods

diff :: CIntPtr -> CIntPtr -> DiffResult CIntPtr Source #

diffList :: [CIntPtr] -> [CIntPtr] -> DiffResult [CIntPtr] Source #

Diff CLLong Source # 
Instance details

Methods

diff :: CLLong -> CLLong -> DiffResult CLLong Source #

diffList :: [CLLong] -> [CLLong] -> DiffResult [CLLong] Source #

Diff CLong Source # 
Instance details

Methods

diff :: CLong -> CLong -> DiffResult CLong Source #

diffList :: [CLong] -> [CLong] -> DiffResult [CLong] Source #

Diff CPtrdiff Source # 
Instance details

Methods

diff :: CPtrdiff -> CPtrdiff -> DiffResult CPtrdiff Source #

diffList :: [CPtrdiff] -> [CPtrdiff] -> DiffResult [CPtrdiff] Source #

Diff CSChar Source # 
Instance details

Methods

diff :: CSChar -> CSChar -> DiffResult CSChar Source #

diffList :: [CSChar] -> [CSChar] -> DiffResult [CSChar] Source #

Diff CSUSeconds Source # 
Instance details

Methods

diff :: CSUSeconds -> CSUSeconds -> DiffResult CSUSeconds Source #

diffList :: [CSUSeconds] -> [CSUSeconds] -> DiffResult [CSUSeconds] Source #

Diff CShort Source # 
Instance details

Methods

diff :: CShort -> CShort -> DiffResult CShort Source #

diffList :: [CShort] -> [CShort] -> DiffResult [CShort] Source #

Diff CSigAtomic Source # 
Instance details

Methods

diff :: CSigAtomic -> CSigAtomic -> DiffResult CSigAtomic Source #

diffList :: [CSigAtomic] -> [CSigAtomic] -> DiffResult [CSigAtomic] Source #

Diff CSize Source # 
Instance details

Methods

diff :: CSize -> CSize -> DiffResult CSize Source #

diffList :: [CSize] -> [CSize] -> DiffResult [CSize] Source #

Diff CTime Source # 
Instance details

Methods

diff :: CTime -> CTime -> DiffResult CTime Source #

diffList :: [CTime] -> [CTime] -> DiffResult [CTime] Source #

Diff CUChar Source # 
Instance details

Methods

diff :: CUChar -> CUChar -> DiffResult CUChar Source #

diffList :: [CUChar] -> [CUChar] -> DiffResult [CUChar] Source #

Diff CUInt Source # 
Instance details

Methods

diff :: CUInt -> CUInt -> DiffResult CUInt Source #

diffList :: [CUInt] -> [CUInt] -> DiffResult [CUInt] Source #

Diff CUIntMax Source # 
Instance details

Methods

diff :: CUIntMax -> CUIntMax -> DiffResult CUIntMax Source #

diffList :: [CUIntMax] -> [CUIntMax] -> DiffResult [CUIntMax] Source #

Diff CUIntPtr Source # 
Instance details

Methods

diff :: CUIntPtr -> CUIntPtr -> DiffResult CUIntPtr Source #

diffList :: [CUIntPtr] -> [CUIntPtr] -> DiffResult [CUIntPtr] Source #

Diff CULLong Source # 
Instance details

Methods

diff :: CULLong -> CULLong -> DiffResult CULLong Source #

diffList :: [CULLong] -> [CULLong] -> DiffResult [CULLong] Source #

Diff CULong Source # 
Instance details

Methods

diff :: CULong -> CULong -> DiffResult CULong Source #

diffList :: [CULong] -> [CULong] -> DiffResult [CULong] Source #

Diff CUSeconds Source # 
Instance details

Methods

diff :: CUSeconds -> CUSeconds -> DiffResult CUSeconds Source #

diffList :: [CUSeconds] -> [CUSeconds] -> DiffResult [CUSeconds] Source #

Diff CUShort Source # 
Instance details

Methods

diff :: CUShort -> CUShort -> DiffResult CUShort Source #

diffList :: [CUShort] -> [CUShort] -> DiffResult [CUShort] Source #

Diff CWchar Source # 
Instance details

Methods

diff :: CWchar -> CWchar -> DiffResult CWchar Source #

diffList :: [CWchar] -> [CWchar] -> DiffResult [CWchar] Source #

Diff IntPtr Source # 
Instance details

Methods

diff :: IntPtr -> IntPtr -> DiffResult IntPtr Source #

diffList :: [IntPtr] -> [IntPtr] -> DiffResult [IntPtr] Source #

Diff WordPtr Source # 
Instance details

Methods

diff :: WordPtr -> WordPtr -> DiffResult WordPtr Source #

diffList :: [WordPtr] -> [WordPtr] -> DiffResult [WordPtr] Source #

Diff Void Source # 
Instance details

Methods

diff :: Void -> Void -> DiffResult Void Source #

diffList :: [Void] -> [Void] -> DiffResult [Void] Source #

Diff ByteOrder Source # 
Instance details

Methods

diff :: ByteOrder -> ByteOrder -> DiffResult ByteOrder Source #

diffList :: [ByteOrder] -> [ByteOrder] -> DiffResult [ByteOrder] Source #

Diff BlockReason Source # 
Instance details

Methods

diff :: BlockReason -> BlockReason -> DiffResult BlockReason Source #

diffList :: [BlockReason] -> [BlockReason] -> DiffResult [BlockReason] Source #

Diff ThreadId Source # 
Instance details

Methods

diff :: ThreadId -> ThreadId -> DiffResult ThreadId Source #

diffList :: [ThreadId] -> [ThreadId] -> DiffResult [ThreadId] Source #

Diff ThreadStatus Source # 
Instance details

Methods

diff :: ThreadStatus -> ThreadStatus -> DiffResult ThreadStatus Source #

diffList :: [ThreadStatus] -> [ThreadStatus] -> DiffResult [ThreadStatus] Source #

Diff Event Source # 
Instance details

Methods

diff :: Event -> Event -> DiffResult Event Source #

diffList :: [Event] -> [Event] -> DiffResult [Event] Source #

Diff Lifetime Source # 
Instance details

Methods

diff :: Lifetime -> Lifetime -> DiffResult Lifetime Source #

diffList :: [Lifetime] -> [Lifetime] -> DiffResult [Lifetime] Source #

Diff FdKey Source # 
Instance details

Methods

diff :: FdKey -> FdKey -> DiffResult FdKey Source #

diffList :: [FdKey] -> [FdKey] -> DiffResult [FdKey] Source #

Diff TimeoutKey Source # 
Instance details

Methods

diff :: TimeoutKey -> TimeoutKey -> DiffResult TimeoutKey Source #

diffList :: [TimeoutKey] -> [TimeoutKey] -> DiffResult [TimeoutKey] Source #

Diff ErrorCall Source # 
Instance details

Methods

diff :: ErrorCall -> ErrorCall -> DiffResult ErrorCall Source #

diffList :: [ErrorCall] -> [ErrorCall] -> DiffResult [ErrorCall] Source #

Diff ArithException Source # 
Instance details

Methods

diff :: ArithException -> ArithException -> DiffResult ArithException Source #

diffList :: [ArithException] -> [ArithException] -> DiffResult [ArithException] Source #

Diff Fingerprint Source # 
Instance details

Methods

diff :: Fingerprint -> Fingerprint -> DiffResult Fingerprint Source #

diffList :: [Fingerprint] -> [Fingerprint] -> DiffResult [Fingerprint] Source #

Diff Associativity Source # 
Instance details

Methods

diff :: Associativity -> Associativity -> DiffResult Associativity Source #

diffList :: [Associativity] -> [Associativity] -> DiffResult [Associativity] Source #

Diff DecidedStrictness Source # 
Instance details

Methods

diff :: DecidedStrictness -> DecidedStrictness -> DiffResult DecidedStrictness Source #

diffList :: [DecidedStrictness] -> [DecidedStrictness] -> DiffResult [DecidedStrictness] Source #

Diff Fixity Source # 
Instance details

Methods

diff :: Fixity -> Fixity -> DiffResult Fixity Source #

diffList :: [Fixity] -> [Fixity] -> DiffResult [Fixity] Source #

Diff MaskingState Source # 
Instance details

Methods

diff :: MaskingState -> MaskingState -> DiffResult MaskingState Source #

diffList :: [MaskingState] -> [MaskingState] -> DiffResult [MaskingState] Source #

Diff BufferState Source # 
Instance details

Methods

diff :: BufferState -> BufferState -> DiffResult BufferState Source #

diffList :: [BufferState] -> [BufferState] -> DiffResult [BufferState] Source #

Diff IODeviceType Source # 
Instance details

Methods

diff :: IODeviceType -> IODeviceType -> DiffResult IODeviceType Source #

diffList :: [IODeviceType] -> [IODeviceType] -> DiffResult [IODeviceType] Source #

Diff SeekMode Source # 
Instance details

Methods

diff :: SeekMode -> SeekMode -> DiffResult SeekMode Source #

diffList :: [SeekMode] -> [SeekMode] -> DiffResult [SeekMode] Source #

Diff ArrayException Source # 
Instance details

Methods

diff :: ArrayException -> ArrayException -> DiffResult ArrayException Source #

diffList :: [ArrayException] -> [ArrayException] -> DiffResult [ArrayException] Source #

Diff AsyncException Source # 
Instance details

Methods

diff :: AsyncException -> AsyncException -> DiffResult AsyncException Source #

diffList :: [AsyncException] -> [AsyncException] -> DiffResult [AsyncException] Source #

Diff ExitCode Source # 
Instance details

Methods

diff :: ExitCode -> ExitCode -> DiffResult ExitCode Source #

diffList :: [ExitCode] -> [ExitCode] -> DiffResult [ExitCode] Source #

Diff IOErrorType Source # 
Instance details

Methods

diff :: IOErrorType -> IOErrorType -> DiffResult IOErrorType Source #

diffList :: [IOErrorType] -> [IOErrorType] -> DiffResult [IOErrorType] Source #

Diff IOException Source # 
Instance details

Methods

diff :: IOException -> IOException -> DiffResult IOException Source #

diffList :: [IOException] -> [IOException] -> DiffResult [IOException] Source #

Diff HandlePosn Source # 
Instance details

Methods

diff :: HandlePosn -> HandlePosn -> DiffResult HandlePosn Source #

diffList :: [HandlePosn] -> [HandlePosn] -> DiffResult [HandlePosn] Source #

Diff BufferMode Source # 
Instance details

Methods

diff :: BufferMode -> BufferMode -> DiffResult BufferMode Source #

diffList :: [BufferMode] -> [BufferMode] -> DiffResult [BufferMode] Source #

Diff Handle Source # 
Instance details

Methods

diff :: Handle -> Handle -> DiffResult Handle Source #

diffList :: [Handle] -> [Handle] -> DiffResult [Handle] Source #

Diff Newline Source # 
Instance details

Methods

diff :: Newline -> Newline -> DiffResult Newline Source #

diffList :: [Newline] -> [Newline] -> DiffResult [Newline] Source #

Diff NewlineMode Source # 
Instance details

Methods

diff :: NewlineMode -> NewlineMode -> DiffResult NewlineMode Source #

diffList :: [NewlineMode] -> [NewlineMode] -> DiffResult [NewlineMode] Source #

Diff IOMode Source # 
Instance details

Methods

diff :: IOMode -> IOMode -> DiffResult IOMode Source #

diffList :: [IOMode] -> [IOMode] -> DiffResult [IOMode] Source #

Diff InfoProv Source # 
Instance details

Methods

diff :: InfoProv -> InfoProv -> DiffResult InfoProv Source #

diffList :: [InfoProv] -> [InfoProv] -> DiffResult [InfoProv] Source #

Diff Int16 Source # 
Instance details

Methods

diff :: Int16 -> Int16 -> DiffResult Int16 Source #

diffList :: [Int16] -> [Int16] -> DiffResult [Int16] Source #

Diff Int32 Source # 
Instance details

Methods

diff :: Int32 -> Int32 -> DiffResult Int32 Source #

diffList :: [Int32] -> [Int32] -> DiffResult [Int32] Source #

Diff Int64 Source # 
Instance details

Methods

diff :: Int64 -> Int64 -> DiffResult Int64 Source #

diffList :: [Int64] -> [Int64] -> DiffResult [Int64] Source #

Diff Int8 Source # 
Instance details

Methods

diff :: Int8 -> Int8 -> DiffResult Int8 Source #

diffList :: [Int8] -> [Int8] -> DiffResult [Int8] Source #

Diff StackEntry Source # 
Instance details

Methods

diff :: StackEntry -> StackEntry -> DiffResult StackEntry Source #

diffList :: [StackEntry] -> [StackEntry] -> DiffResult [StackEntry] Source #

Diff SrcLoc Source # 
Instance details

Methods

diff :: SrcLoc -> SrcLoc -> DiffResult SrcLoc Source #

diffList :: [SrcLoc] -> [SrcLoc] -> DiffResult [SrcLoc] Source #

Diff SomeChar Source # 
Instance details

Methods

diff :: SomeChar -> SomeChar -> DiffResult SomeChar Source #

diffList :: [SomeChar] -> [SomeChar] -> DiffResult [SomeChar] Source #

Diff SomeSymbol Source # 
Instance details

Methods

diff :: SomeSymbol -> SomeSymbol -> DiffResult SomeSymbol Source #

diffList :: [SomeSymbol] -> [SomeSymbol] -> DiffResult [SomeSymbol] Source #

Diff SomeNat Source # 
Instance details

Methods

diff :: SomeNat -> SomeNat -> DiffResult SomeNat Source #

diffList :: [SomeNat] -> [SomeNat] -> DiffResult [SomeNat] Source #

Diff GeneralCategory Source # 
Instance details

Methods

diff :: GeneralCategory -> GeneralCategory -> DiffResult GeneralCategory Source #

diffList :: [GeneralCategory] -> [GeneralCategory] -> DiffResult [GeneralCategory] Source #

Diff Word16 Source # 
Instance details

Methods

diff :: Word16 -> Word16 -> DiffResult Word16 Source #

diffList :: [Word16] -> [Word16] -> DiffResult [Word16] Source #

Diff Word32 Source # 
Instance details

Methods

diff :: Word32 -> Word32 -> DiffResult Word32 Source #

diffList :: [Word32] -> [Word32] -> DiffResult [Word32] Source #

Diff Word64 Source # 
Instance details

Methods

diff :: Word64 -> Word64 -> DiffResult Word64 Source #

diffList :: [Word64] -> [Word64] -> DiffResult [Word64] Source #

Diff Word8 Source # 
Instance details

Methods

diff :: Word8 -> Word8 -> DiffResult Word8 Source #

diffList :: [Word8] -> [Word8] -> DiffResult [Word8] Source #

Diff Timeout Source # 
Instance details

Methods

diff :: Timeout -> Timeout -> DiffResult Timeout Source #

diffList :: [Timeout] -> [Timeout] -> DiffResult [Timeout] Source #

Diff Lexeme Source # 
Instance details

Methods

diff :: Lexeme -> Lexeme -> DiffResult Lexeme Source #

diffList :: [Lexeme] -> [Lexeme] -> DiffResult [Lexeme] Source #

Diff Ordering Source # 
Instance details

Methods

diff :: Ordering -> Ordering -> DiffResult Ordering Source #

diffList :: [Ordering] -> [Ordering] -> DiffResult [Ordering] Source #

Diff TrName Source # 
Instance details

Methods

diff :: TrName -> TrName -> DiffResult TrName Source #

diffList :: [TrName] -> [TrName] -> DiffResult [TrName] Source #

Diff TyCon Source # 
Instance details

Methods

diff :: TyCon -> TyCon -> DiffResult TyCon Source #

diffList :: [TyCon] -> [TyCon] -> DiffResult [TyCon] Source #

Diff UnicodeException Source # 
Instance details

Methods

diff :: UnicodeException -> UnicodeException -> DiffResult UnicodeException Source #

diffList :: [UnicodeException] -> [UnicodeException] -> DiffResult [UnicodeException] Source #

Diff Text Source # 
Instance details

Methods

diff :: Text -> Text -> DiffResult Text Source #

diffList :: [Text] -> [Text] -> DiffResult [Text] Source #

Diff Builder Source # 
Instance details

Methods

diff :: Builder -> Builder -> DiffResult Builder Source #

diffList :: [Builder] -> [Builder] -> DiffResult [Builder] Source #

Diff Text Source # 
Instance details

Methods

diff :: Text -> Text -> DiffResult Text Source #

diffList :: [Text] -> [Text] -> DiffResult [Text] Source #

Diff Integer Source # 
Instance details

Methods

diff :: Integer -> Integer -> DiffResult Integer Source #

diffList :: [Integer] -> [Integer] -> DiffResult [Integer] Source #

Diff Natural Source # 
Instance details

Methods

diff :: Natural -> Natural -> DiffResult Natural Source #

diffList :: [Natural] -> [Natural] -> DiffResult [Natural] Source #

Diff () Source # 
Instance details

Methods

diff :: () -> () -> DiffResult () Source #

diffList :: [()] -> [()] -> DiffResult [()] Source #

Diff Bool Source # 
Instance details

Methods

diff :: Bool -> Bool -> DiffResult Bool Source #

diffList :: [Bool] -> [Bool] -> DiffResult [Bool] Source #

Diff Char Source # 
Instance details

Methods

diff :: Char -> Char -> DiffResult Char Source #

diffList :: [Char] -> [Char] -> DiffResult [Char] Source #

Diff Double Source # 
Instance details

Methods

diff :: Double -> Double -> DiffResult Double Source #

diffList :: [Double] -> [Double] -> DiffResult [Double] Source #

Diff Float Source # 
Instance details

Methods

diff :: Float -> Float -> DiffResult Float Source #

diffList :: [Float] -> [Float] -> DiffResult [Float] Source #

Diff Int Source # 
Instance details

Methods

diff :: Int -> Int -> DiffResult Int Source #

diffList :: [Int] -> [Int] -> DiffResult [Int] Source #

Diff Word Source # 
Instance details

Methods

diff :: Word -> Word -> DiffResult Word Source #

diffList :: [Word] -> [Word] -> DiffResult [Word] Source #

Diff (Chan a) Source # 
Instance details

Methods

diff :: Chan a -> Chan a -> DiffResult (Chan a) Source #

diffList :: [Chan a] -> [Chan a] -> DiffResult [Chan a] Source #

Diff (MutableByteArray a) Source # 
Instance details

Methods

diff :: MutableByteArray a -> MutableByteArray a -> DiffResult (MutableByteArray a) Source #

diffList :: [MutableByteArray a] -> [MutableByteArray a] -> DiffResult [MutableByteArray a] Source #

Diff a => Diff (Complex a) Source # 
Instance details

Methods

diff :: Complex a -> Complex a -> DiffResult (Complex a) Source #

diffList :: [Complex a] -> [Complex a] -> DiffResult [Complex a] Source #

Diff a => Diff (Identity a) Source # 
Instance details

Methods

diff :: Identity a -> Identity a -> DiffResult (Identity a) Source #

diffList :: [Identity a] -> [Identity a] -> DiffResult [Identity a] Source #

Diff a => Diff (First a) Source # 
Instance details

Methods

diff :: First a -> First a -> DiffResult (First a) Source #

diffList :: [First a] -> [First a] -> DiffResult [First a] Source #

Diff a => Diff (Last a) Source # 
Instance details

Methods

diff :: Last a -> Last a -> DiffResult (Last a) Source #

diffList :: [Last a] -> [Last a] -> DiffResult [Last a] Source #

Diff a => Diff (Down a) Source # 
Instance details

Methods

diff :: Down a -> Down a -> DiffResult (Down a) Source #

diffList :: [Down a] -> [Down a] -> DiffResult [Down a] Source #

Diff a => Diff (First a) Source # 
Instance details

Methods

diff :: First a -> First a -> DiffResult (First a) Source #

diffList :: [First a] -> [First a] -> DiffResult [First a] Source #

Diff a => Diff (Last a) Source # 
Instance details

Methods

diff :: Last a -> Last a -> DiffResult (Last a) Source #

diffList :: [Last a] -> [Last a] -> DiffResult [Last a] Source #

Diff a => Diff (Max a) Source # 
Instance details

Methods

diff :: Max a -> Max a -> DiffResult (Max a) Source #

diffList :: [Max a] -> [Max a] -> DiffResult [Max a] Source #

Diff a => Diff (Min a) Source # 
Instance details

Methods

diff :: Min a -> Min a -> DiffResult (Min a) Source #

diffList :: [Min a] -> [Min a] -> DiffResult [Min a] Source #

Diff a => Diff (WrappedMonoid a) Source # 
Instance details

Methods

diff :: WrappedMonoid a -> WrappedMonoid a -> DiffResult (WrappedMonoid a) Source #

diffList :: [WrappedMonoid a] -> [WrappedMonoid a] -> DiffResult [WrappedMonoid a] Source #

Diff a => Diff (Dual a) Source # 
Instance details

Methods

diff :: Dual a -> Dual a -> DiffResult (Dual a) Source #

diffList :: [Dual a] -> [Dual a] -> DiffResult [Dual a] Source #

Diff a => Diff (Product a) Source # 
Instance details

Methods

diff :: Product a -> Product a -> DiffResult (Product a) Source #

diffList :: [Product a] -> [Product a] -> DiffResult [Product a] Source #

Diff a => Diff (Sum a) Source # 
Instance details

Methods

diff :: Sum a -> Sum a -> DiffResult (Sum a) Source #

diffList :: [Sum a] -> [Sum a] -> DiffResult [Sum a] Source #

Diff (ConstPtr a) Source # 
Instance details

Methods

diff :: ConstPtr a -> ConstPtr a -> DiffResult (ConstPtr a) Source #

diffList :: [ConstPtr a] -> [ConstPtr a] -> DiffResult [ConstPtr a] Source #

Diff a => Diff (NonEmpty a) Source # 
Instance details

Methods

diff :: NonEmpty a -> NonEmpty a -> DiffResult (NonEmpty a) Source #

diffList :: [NonEmpty a] -> [NonEmpty a] -> DiffResult [NonEmpty a] Source #

Diff (TVar a) Source # 
Instance details

Methods

diff :: TVar a -> TVar a -> DiffResult (TVar a) Source #

diffList :: [TVar a] -> [TVar a] -> DiffResult [TVar a] Source #

Diff (ForeignPtr a) Source # 
Instance details

Methods

diff :: ForeignPtr a -> ForeignPtr a -> DiffResult (ForeignPtr a) Source #

diffList :: [ForeignPtr a] -> [ForeignPtr a] -> DiffResult [ForeignPtr a] Source #

Diff (IORef a) Source # 
Instance details

Methods

diff :: IORef a -> IORef a -> DiffResult (IORef a) Source #

diffList :: [IORef a] -> [IORef a] -> DiffResult [IORef a] Source #

Diff (MVar a) Source # 
Instance details

Methods

diff :: MVar a -> MVar a -> DiffResult (MVar a) Source #

diffList :: [MVar a] -> [MVar a] -> DiffResult [MVar a] Source #

Diff (FunPtr a) Source # 
Instance details

Methods

diff :: FunPtr a -> FunPtr a -> DiffResult (FunPtr a) Source #

diffList :: [FunPtr a] -> [FunPtr a] -> DiffResult [FunPtr a] Source #

Diff (Ptr a) Source # 
Instance details

Methods

diff :: Ptr a -> Ptr a -> DiffResult (Ptr a) Source #

diffList :: [Ptr a] -> [Ptr a] -> DiffResult [Ptr a] Source #

Eq a => Diff (Ratio a) Source # 
Instance details

Methods

diff :: Ratio a -> Ratio a -> DiffResult (Ratio a) Source #

diffList :: [Ratio a] -> [Ratio a] -> DiffResult [Ratio a] Source #

Diff (StablePtr a) Source # 
Instance details

Methods

diff :: StablePtr a -> StablePtr a -> DiffResult (StablePtr a) Source #

diffList :: [StablePtr a] -> [StablePtr a] -> DiffResult [StablePtr a] Source #

Diff (StableName a) Source # 
Instance details

Methods

diff :: StableName a -> StableName a -> DiffResult (StableName a) Source #

diffList :: [StableName a] -> [StableName a] -> DiffResult [StableName a] Source #

Diff a => Diff (I a) Source # 
Instance details

Methods

diff :: I a -> I a -> DiffResult (I a) Source #

diffList :: [I a] -> [I a] -> DiffResult [I a] Source #

Diff a => Diff (Maybe a) Source # 
Instance details

Methods

diff :: Maybe a -> Maybe a -> DiffResult (Maybe a) Source #

diffList :: [Maybe a] -> [Maybe a] -> DiffResult [Maybe a] Source #

Diff a => Diff [a] Source # 
Instance details

Methods

diff :: [a] -> [a] -> DiffResult [a] Source #

diffList :: [[a]] -> [[a]] -> DiffResult [[a]] Source #

(Diff a, Diff b) => Diff (Either a b) Source # 
Instance details

Methods

diff :: Either a b -> Either a b -> DiffResult (Either a b) Source #

diffList :: [Either a b] -> [Either a b] -> DiffResult [Either a b] Source #

(HasDatatypeInfo (Fixed a), All2 Diff (Code (Fixed a))) => Diff (Fixed a) Source # 
Instance details

Methods

diff :: Fixed a -> Fixed a -> DiffResult (Fixed a) Source #

diffList :: [Fixed a] -> [Fixed a] -> DiffResult [Fixed a] Source #

Diff (Proxy a) Source # 
Instance details

Methods

diff :: Proxy a -> Proxy a -> DiffResult (Proxy a) Source #

diffList :: [Proxy a] -> [Proxy a] -> DiffResult [Proxy a] Source #

(Diff a, Diff b) => Diff (Arg a b) Source # 
Instance details

Methods

diff :: Arg a b -> Arg a b -> DiffResult (Arg a b) Source #

diffList :: [Arg a b] -> [Arg a b] -> DiffResult [Arg a b] Source #

Diff (TypeRep a) Source # 
Instance details

Methods

diff :: TypeRep a -> TypeRep a -> DiffResult (TypeRep a) Source #

diffList :: [TypeRep a] -> [TypeRep a] -> DiffResult [TypeRep a] Source #

Diff (IOArray i e) Source # 
Instance details

Methods

diff :: IOArray i e -> IOArray i e -> DiffResult (IOArray i e) Source #

diffList :: [IOArray i e] -> [IOArray i e] -> DiffResult [IOArray i e] Source #

Diff (STRef s a) Source # 
Instance details

Methods

diff :: STRef s a -> STRef s a -> DiffResult (STRef s a) Source #

diffList :: [STRef s a] -> [STRef s a] -> DiffResult [STRef s a] Source #

(Diff a, Diff b) => Diff (a, b) Source # 
Instance details

Methods

diff :: (a, b) -> (a, b) -> DiffResult (a, b) Source #

diffList :: [(a, b)] -> [(a, b)] -> DiffResult [(a, b)] Source #

(HasDatatypeInfo (Const a b), All2 Diff (Code (Const a b))) => Diff (Const a b) Source # 
Instance details

Methods

diff :: Const a b -> Const a b -> DiffResult (Const a b) Source #

diffList :: [Const a b] -> [Const a b] -> DiffResult [Const a b] Source #

(HasDatatypeInfo (Ap f a), All2 Diff (Code (Ap f a))) => Diff (Ap f a) Source # 
Instance details

Methods

diff :: Ap f a -> Ap f a -> DiffResult (Ap f a) Source #

diffList :: [Ap f a] -> [Ap f a] -> DiffResult [Ap f a] Source #

(HasDatatypeInfo (Alt f a), All2 Diff (Code (Alt f a))) => Diff (Alt f a) Source # 
Instance details

Methods

diff :: Alt f a -> Alt f a -> DiffResult (Alt f a) Source #

diffList :: [Alt f a] -> [Alt f a] -> DiffResult [Alt f a] Source #

Diff (Coercion a b) Source # 
Instance details

Methods

diff :: Coercion a b -> Coercion a b -> DiffResult (Coercion a b) Source #

diffList :: [Coercion a b] -> [Coercion a b] -> DiffResult [Coercion a b] Source #

Diff (OrderingI a b) Source # 
Instance details

Methods

diff :: OrderingI a b -> OrderingI a b -> DiffResult (OrderingI a b) Source #

diffList :: [OrderingI a b] -> [OrderingI a b] -> DiffResult [OrderingI a b] Source #

Diff (STArray s i a) Source # 
Instance details

Methods

diff :: STArray s i a -> STArray s i a -> DiffResult (STArray s i a) Source #

diffList :: [STArray s i a] -> [STArray s i a] -> DiffResult [STArray s i a] Source #

(HasDatatypeInfo (K a b), All2 Diff (Code (K a b))) => Diff (K a b) Source # 
Instance details

Methods

diff :: K a b -> K a b -> DiffResult (K a b) Source #

diffList :: [K a b] -> [K a b] -> DiffResult [K a b] Source #

(Diff a, Diff b, Diff c) => Diff (a, b, c) Source # 
Instance details

Methods

diff :: (a, b, c) -> (a, b, c) -> DiffResult (a, b, c) Source #

diffList :: [(a, b, c)] -> [(a, b, c)] -> DiffResult [(a, b, c)] Source #

(HasDatatypeInfo (Product f g a), All2 Diff (Code (Product f g a))) => Diff (Product f g a) Source # 
Instance details

Methods

diff :: Product f g a -> Product f g a -> DiffResult (Product f g a) Source #

diffList :: [Product f g a] -> [Product f g a] -> DiffResult [Product f g a] Source #

(HasDatatypeInfo (Sum f g a), All2 Diff (Code (Sum f g a))) => Diff (Sum f g a) Source # 
Instance details

Methods

diff :: Sum f g a -> Sum f g a -> DiffResult (Sum f g a) Source #

diffList :: [Sum f g a] -> [Sum f g a] -> DiffResult [Sum f g a] Source #

(Diff a, Diff b, Diff c, Diff d) => Diff (a, b, c, d) Source # 
Instance details

Methods

diff :: (a, b, c, d) -> (a, b, c, d) -> DiffResult (a, b, c, d) Source #

diffList :: [(a, b, c, d)] -> [(a, b, c, d)] -> DiffResult [(a, b, c, d)] Source #

(HasDatatypeInfo (Compose f g a), All2 Diff (Code (Compose f g a))) => Diff (Compose f g a) Source # 
Instance details

Methods

diff :: Compose f g a -> Compose f g a -> DiffResult (Compose f g a) Source #

diffList :: [Compose f g a] -> [Compose f g a] -> DiffResult [Compose f g a] Source #

(HasDatatypeInfo ((f :.: g) a), All2 Diff (Code ((f :.: g) a))) => Diff ((f :.: g) a) Source # 
Instance details

Methods

diff :: (f :.: g) a -> (f :.: g) a -> DiffResult ((f :.: g) a) Source #

diffList :: [(f :.: g) a] -> [(f :.: g) a] -> DiffResult [(f :.: g) a] Source #

(Diff a, Diff b, Diff c, Diff d, Diff e) => Diff (a, b, c, d, e) Source # 
Instance details

Methods

diff :: (a, b, c, d, e) -> (a, b, c, d, e) -> DiffResult (a, b, c, d, e) Source #

diffList :: [(a, b, c, d, e)] -> [(a, b, c, d, e)] -> DiffResult [(a, b, c, d, e)] Source #

(Diff a, Diff b, Diff c, Diff d, Diff e, Diff f) => Diff (a, b, c, d, e, f) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> DiffResult (a, b, c, d, e, f) Source #

diffList :: [(a, b, c, d, e, f)] -> [(a, b, c, d, e, f)] -> DiffResult [(a, b, c, d, e, f)] Source #

(Diff a, Diff b, Diff c, Diff d, Diff e, Diff f, Diff g) => Diff (a, b, c, d, e, f, g) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> DiffResult (a, b, c, d, e, f, g) Source #

diffList :: [(a, b, c, d, e, f, g)] -> [(a, b, c, d, e, f, g)] -> DiffResult [(a, b, c, d, e, f, g)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> DiffResult (a, b, c, d, e, f, g, h) Source #

diffList :: [(a, b, c, d, e, f, g, h)] -> [(a, b, c, d, e, f, g, h)] -> DiffResult [(a, b, c, d, e, f, g, h)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> DiffResult (a, b, c, d, e, f, g, h, i) Source #

diffList :: [(a, b, c, d, e, f, g, h, i)] -> [(a, b, c, d, e, f, g, h, i)] -> DiffResult [(a, b, c, d, e, f, g, h, i)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> DiffResult (a, b, c, d, e, f, g, h, i, j) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j)] -> [(a, b, c, d, e, f, g, h, i, j)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> [(a, b, c, d, e, f, g, h, i, j, k)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> [(a, b, c, d, e, f, g, h, i, j, k, l)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)] Source #

(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) Source # 
Instance details

Methods

diff :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)] Source #

(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) Source # 
Instance details

Methods

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) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> DiffResult (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) Source #

diffList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)] -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)] -> DiffResult [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)] Source #

(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) Source # 
Instance details

Methods

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) -> (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) -> DiffResult (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) Source #

diffList :: [(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)] -> [(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)] -> DiffResult [(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)] Source #

(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) Source # 
Instance details

Methods

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) -> (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) -> DiffResult (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) Source #

diffList :: [(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)] -> [(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)] -> DiffResult [(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)] Source #