Safe Haskell	Safe
Language	Haskell2010

Precursor.Algebra.Eq

Synopsis

Documentation

class Eq a where #

The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq.

Minimal complete definition: either == or /=.

Minimal complete definition

(==) | (/=)

Methods

(==) :: a -> a -> Bool infix 4 #

(/=) :: a -> a -> Bool infix 4 #

Instances

Eq Bool
Methods (==) :: Bool -> Bool -> Bool # (/=) :: Bool -> Bool -> Bool #
Eq Char
Methods (==) :: Char -> Char -> Bool # (/=) :: Char -> Char -> Bool #
Eq Double
Methods (==) :: Double -> Double -> Bool # (/=) :: Double -> Double -> Bool #
Eq Float
Methods (==) :: Float -> Float -> Bool # (/=) :: Float -> Float -> Bool #
Eq Int
Methods (==) :: Int -> Int -> Bool # (/=) :: Int -> Int -> Bool #
Eq Int8
Methods (==) :: Int8 -> Int8 -> Bool # (/=) :: Int8 -> Int8 -> Bool #
Eq Int16
Methods (==) :: Int16 -> Int16 -> Bool # (/=) :: Int16 -> Int16 -> Bool #
Eq Int32
Methods (==) :: Int32 -> Int32 -> Bool # (/=) :: Int32 -> Int32 -> Bool #
Eq Int64
Methods (==) :: Int64 -> Int64 -> Bool # (/=) :: Int64 -> Int64 -> Bool #
Eq Integer
Methods (==) :: Integer -> Integer -> Bool # (/=) :: Integer -> Integer -> Bool #
Eq Ordering
Methods (==) :: Ordering -> Ordering -> Bool # (/=) :: Ordering -> Ordering -> Bool #
Eq Word
Methods (==) :: Word -> Word -> Bool # (/=) :: Word -> Word -> Bool #
Eq Word8
Methods (==) :: Word8 -> Word8 -> Bool # (/=) :: Word8 -> Word8 -> Bool #
Eq Word16
Methods (==) :: Word16 -> Word16 -> Bool # (/=) :: Word16 -> Word16 -> Bool #
Eq Word32
Methods (==) :: Word32 -> Word32 -> Bool # (/=) :: Word32 -> Word32 -> Bool #
Eq Word64
Methods (==) :: Word64 -> Word64 -> Bool # (/=) :: Word64 -> Word64 -> Bool #
Eq Exp
Methods (==) :: Exp -> Exp -> Bool # (/=) :: Exp -> Exp -> Bool #
Eq Match
Methods (==) :: Match -> Match -> Bool # (/=) :: Match -> Match -> Bool #
Eq Clause
Methods (==) :: Clause -> Clause -> Bool # (/=) :: Clause -> Clause -> Bool #
Eq Pat
Methods (==) :: Pat -> Pat -> Bool # (/=) :: Pat -> Pat -> Bool #
Eq Type
Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Eq Dec
Methods (==) :: Dec -> Dec -> Bool # (/=) :: Dec -> Dec -> Bool #
Eq Name
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Eq FunDep
Methods (==) :: FunDep -> FunDep -> Bool # (/=) :: FunDep -> FunDep -> Bool #
Eq TyVarBndr
Methods (==) :: TyVarBndr -> TyVarBndr -> Bool # (/=) :: TyVarBndr -> TyVarBndr -> Bool #
Eq InjectivityAnn
Methods (==) :: InjectivityAnn -> InjectivityAnn -> Bool # (/=) :: InjectivityAnn -> InjectivityAnn -> Bool #
Eq Overlap
Methods (==) :: Overlap -> Overlap -> Bool # (/=) :: Overlap -> Overlap -> Bool #
Eq ()
Methods (==) :: () -> () -> Bool # (/=) :: () -> () -> Bool #
Eq TyCon
Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #
Eq BigNat
Methods (==) :: BigNat -> BigNat -> Bool # (/=) :: BigNat -> BigNat -> Bool #
Eq SpecConstrAnnotation
Methods (==) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool # (/=) :: SpecConstrAnnotation -> SpecConstrAnnotation -> Bool #
Eq Void
Methods (==) :: Void -> Void -> Bool # (/=) :: Void -> Void -> Bool #
Eq Version
Methods (==) :: Version -> Version -> Bool # (/=) :: Version -> Version -> Bool #
Eq AsyncException
Methods (==) :: AsyncException -> AsyncException -> Bool # (/=) :: AsyncException -> AsyncException -> Bool #
Eq ArrayException
Methods (==) :: ArrayException -> ArrayException -> Bool # (/=) :: ArrayException -> ArrayException -> Bool #
Eq ExitCode
Methods (==) :: ExitCode -> ExitCode -> Bool # (/=) :: ExitCode -> ExitCode -> Bool #
Eq IOErrorType
Methods (==) :: IOErrorType -> IOErrorType -> Bool # (/=) :: IOErrorType -> IOErrorType -> Bool #
Eq All
Methods (==) :: All -> All -> Bool # (/=) :: All -> All -> Bool #
Eq Any
Methods (==) :: Any -> Any -> Bool # (/=) :: Any -> Any -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq Associativity
Methods (==) :: Associativity -> Associativity -> Bool # (/=) :: Associativity -> Associativity -> Bool #
Eq SourceUnpackedness
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq MaskingState
Methods (==) :: MaskingState -> MaskingState -> Bool # (/=) :: MaskingState -> MaskingState -> Bool #
Eq IOException
Methods (==) :: IOException -> IOException -> Bool # (/=) :: IOException -> IOException -> Bool #
Eq SomeNat
Methods (==) :: SomeNat -> SomeNat -> Bool # (/=) :: SomeNat -> SomeNat -> Bool #
Eq SomeSymbol
Methods (==) :: SomeSymbol -> SomeSymbol -> Bool # (/=) :: SomeSymbol -> SomeSymbol -> Bool #
Eq SrcLoc
Methods (==) :: SrcLoc -> SrcLoc -> Bool # (/=) :: SrcLoc -> SrcLoc -> Bool #
Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq ByteString
Methods (==) :: ByteString -> ByteString -> Bool # (/=) :: ByteString -> ByteString -> Bool #
Eq IntSet
Methods (==) :: IntSet -> IntSet -> Bool # (/=) :: IntSet -> IntSet -> Bool #
Eq Extension
Methods (==) :: Extension -> Extension -> Bool # (/=) :: Extension -> Extension -> Bool #
Eq Doc
Methods (==) :: Doc -> Doc -> Bool # (/=) :: Doc -> Doc -> Bool #
Eq TextDetails
Methods (==) :: TextDetails -> TextDetails -> Bool # (/=) :: TextDetails -> TextDetails -> Bool #
Eq Style
Methods (==) :: Style -> Style -> Bool # (/=) :: Style -> Style -> Bool #
Eq Mode
Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Eq ModName
Methods (==) :: ModName -> ModName -> Bool # (/=) :: ModName -> ModName -> Bool #
Eq PkgName
Methods (==) :: PkgName -> PkgName -> Bool # (/=) :: PkgName -> PkgName -> Bool #
Eq Module
Methods (==) :: Module -> Module -> Bool # (/=) :: Module -> Module -> Bool #
Eq OccName
Methods (==) :: OccName -> OccName -> Bool # (/=) :: OccName -> OccName -> Bool #
Eq NameFlavour
Methods (==) :: NameFlavour -> NameFlavour -> Bool # (/=) :: NameFlavour -> NameFlavour -> Bool #
Eq NameSpace
Methods (==) :: NameSpace -> NameSpace -> Bool # (/=) :: NameSpace -> NameSpace -> Bool #
Eq Loc
Methods (==) :: Loc -> Loc -> Bool # (/=) :: Loc -> Loc -> Bool #
Eq Info
Methods (==) :: Info -> Info -> Bool # (/=) :: Info -> Info -> Bool #
Eq ModuleInfo
Methods (==) :: ModuleInfo -> ModuleInfo -> Bool # (/=) :: ModuleInfo -> ModuleInfo -> Bool #
Eq Fixity
Methods (==) :: Fixity -> Fixity -> Bool # (/=) :: Fixity -> Fixity -> Bool #
Eq FixityDirection
Methods (==) :: FixityDirection -> FixityDirection -> Bool # (/=) :: FixityDirection -> FixityDirection -> Bool #
Eq Lit
Methods (==) :: Lit -> Lit -> Bool # (/=) :: Lit -> Lit -> Bool #
Eq Body
Methods (==) :: Body -> Body -> Bool # (/=) :: Body -> Body -> Bool #
Eq Guard
Methods (==) :: Guard -> Guard -> Bool # (/=) :: Guard -> Guard -> Bool #
Eq Stmt
Methods (==) :: Stmt -> Stmt -> Bool # (/=) :: Stmt -> Stmt -> Bool #
Eq Range
Methods (==) :: Range -> Range -> Bool # (/=) :: Range -> Range -> Bool #
Eq TypeFamilyHead
Methods (==) :: TypeFamilyHead -> TypeFamilyHead -> Bool # (/=) :: TypeFamilyHead -> TypeFamilyHead -> Bool #
Eq TySynEqn
Methods (==) :: TySynEqn -> TySynEqn -> Bool # (/=) :: TySynEqn -> TySynEqn -> Bool #
Eq FamFlavour
Methods (==) :: FamFlavour -> FamFlavour -> Bool # (/=) :: FamFlavour -> FamFlavour -> Bool #
Eq Foreign
Methods (==) :: Foreign -> Foreign -> Bool # (/=) :: Foreign -> Foreign -> Bool #
Eq Callconv
Methods (==) :: Callconv -> Callconv -> Bool # (/=) :: Callconv -> Callconv -> Bool #
Eq Safety
Methods (==) :: Safety -> Safety -> Bool # (/=) :: Safety -> Safety -> Bool #
Eq Pragma
Methods (==) :: Pragma -> Pragma -> Bool # (/=) :: Pragma -> Pragma -> Bool #
Eq Inline
Methods (==) :: Inline -> Inline -> Bool # (/=) :: Inline -> Inline -> Bool #
Eq RuleMatch
Methods (==) :: RuleMatch -> RuleMatch -> Bool # (/=) :: RuleMatch -> RuleMatch -> Bool #
Eq Phases
Methods (==) :: Phases -> Phases -> Bool # (/=) :: Phases -> Phases -> Bool #
Eq RuleBndr
Methods (==) :: RuleBndr -> RuleBndr -> Bool # (/=) :: RuleBndr -> RuleBndr -> Bool #
Eq AnnTarget
Methods (==) :: AnnTarget -> AnnTarget -> Bool # (/=) :: AnnTarget -> AnnTarget -> Bool #
Eq SourceUnpackedness
Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool #
Eq SourceStrictness
Methods (==) :: SourceStrictness -> SourceStrictness -> Bool # (/=) :: SourceStrictness -> SourceStrictness -> Bool #
Eq DecidedStrictness
Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool #
Eq Con
Methods (==) :: Con -> Con -> Bool # (/=) :: Con -> Con -> Bool #
Eq Bang
Methods (==) :: Bang -> Bang -> Bool # (/=) :: Bang -> Bang -> Bool #
Eq FamilyResultSig
Methods (==) :: FamilyResultSig -> FamilyResultSig -> Bool # (/=) :: FamilyResultSig -> FamilyResultSig -> Bool #
Eq TyLit
Methods (==) :: TyLit -> TyLit -> Bool # (/=) :: TyLit -> TyLit -> Bool #
Eq Role
Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Eq AnnLookup
Methods (==) :: AnnLookup -> AnnLookup -> Bool # (/=) :: AnnLookup -> AnnLookup -> Bool #
Eq CodePoint
Methods (==) :: CodePoint -> CodePoint -> Bool # (/=) :: CodePoint -> CodePoint -> Bool #
Eq DecoderState
Methods (==) :: DecoderState -> DecoderState -> Bool # (/=) :: DecoderState -> DecoderState -> Bool #
Eq Builder
Methods (==) :: Builder -> Builder -> Bool # (/=) :: Builder -> Builder -> Bool #
Eq UnicodeException
Methods (==) :: UnicodeException -> UnicodeException -> Bool # (/=) :: UnicodeException -> UnicodeException -> Bool #
Eq ConType
Methods (==) :: ConType -> ConType -> Bool # (/=) :: ConType -> ConType -> Bool #
Eq Options
Methods (==) :: Options -> Options -> Bool # (/=) :: Options -> Options -> Bool #
Eq GenTextMethods
Methods (==) :: GenTextMethods -> GenTextMethods -> Bool # (/=) :: GenTextMethods -> GenTextMethods -> Bool #
Eq a => Eq [a]
Methods (==) :: [a] -> [a] -> Bool # (/=) :: [a] -> [a] -> Bool #
Eq a => Eq (Maybe a)
Methods (==) :: Maybe a -> Maybe a -> Bool # (/=) :: Maybe a -> Maybe a -> Bool #
Eq a => Eq (Ratio a)
Methods (==) :: Ratio a -> Ratio a -> Bool # (/=) :: Ratio a -> Ratio a -> Bool #
Eq (Ptr a)
Methods (==) :: Ptr a -> Ptr a -> Bool # (/=) :: Ptr a -> Ptr a -> Bool #
Eq (FunPtr a)
Methods (==) :: FunPtr a -> FunPtr a -> Bool # (/=) :: FunPtr a -> FunPtr a -> Bool #
Eq (V1 p)
Methods (==) :: V1 p -> V1 p -> Bool # (/=) :: V1 p -> V1 p -> Bool #
Eq (U1 p)
Methods (==) :: U1 p -> U1 p -> Bool # (/=) :: U1 p -> U1 p -> Bool #
Eq p => Eq (Par1 p)
Methods (==) :: Par1 p -> Par1 p -> Bool # (/=) :: Par1 p -> Par1 p -> Bool #
Eq a => Eq (Identity a)
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Eq a => Eq (Min a)
Methods (==) :: Min a -> Min a -> Bool # (/=) :: Min a -> Min a -> Bool #
Eq a => Eq (Max a)
Methods (==) :: Max a -> Max a -> Bool # (/=) :: Max a -> Max a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq m => Eq (WrappedMonoid m)
Methods (==) :: WrappedMonoid m -> WrappedMonoid m -> Bool # (/=) :: WrappedMonoid m -> WrappedMonoid m -> Bool #
Eq a => Eq (Option a)
Methods (==) :: Option a -> Option a -> Bool # (/=) :: Option a -> Option a -> Bool #
Eq a => Eq (NonEmpty a)
Methods (==) :: NonEmpty a -> NonEmpty a -> Bool # (/=) :: NonEmpty a -> NonEmpty a -> Bool #
Eq a => Eq (Complex a)
Methods (==) :: Complex a -> Complex a -> Bool # (/=) :: Complex a -> Complex a -> Bool #
Eq a => Eq (ZipList a)
Methods (==) :: ZipList a -> ZipList a -> Bool # (/=) :: ZipList a -> ZipList a -> Bool #
Eq a => Eq (Dual a)
Methods (==) :: Dual a -> Dual a -> Bool # (/=) :: Dual a -> Dual a -> Bool #
Eq a => Eq (Sum a)
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Eq a => Eq (Product a)
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (First a)
Methods (==) :: First a -> First a -> Bool # (/=) :: First a -> First a -> Bool #
Eq a => Eq (Last a)
Methods (==) :: Last a -> Last a -> Bool # (/=) :: Last a -> Last a -> Bool #
Eq a => Eq (Down a)
Methods (==) :: Down a -> Down a -> Bool # (/=) :: Down a -> Down a -> Bool #
Eq a => Eq (IntMap a)
Methods (==) :: IntMap a -> IntMap a -> Bool # (/=) :: IntMap a -> IntMap a -> Bool #
Eq a => Eq (Seq a)
Methods (==) :: Seq a -> Seq a -> Bool # (/=) :: Seq a -> Seq a -> Bool #
Eq a => Eq (ViewL a)
Methods (==) :: ViewL a -> ViewL a -> Bool # (/=) :: ViewL a -> ViewL a -> Bool #
Eq a => Eq (ViewR a)
Methods (==) :: ViewR a -> ViewR a -> Bool # (/=) :: ViewR a -> ViewR a -> Bool #
Eq a => Eq (Set a)
Methods (==) :: Set a -> Set a -> Bool # (/=) :: Set a -> Set a -> Bool #
Eq (Doc a)
Methods (==) :: Doc a -> Doc a -> Bool # (/=) :: Doc a -> Doc a -> Bool #
Eq a => Eq (AnnotDetails a)
Methods (==) :: AnnotDetails a -> AnnotDetails a -> Bool # (/=) :: AnnotDetails a -> AnnotDetails a -> Bool #
Eq a => Eq (Span a)
Methods (==) :: Span a -> Span a -> Bool # (/=) :: Span a -> Span a -> Bool #
Eq a => Eq (FromStringShow a)
Methods (==) :: FromStringShow a -> FromStringShow a -> Bool # (/=) :: FromStringShow a -> FromStringShow a -> Bool #
Eq a => Eq (FromTextShow a)
Methods (==) :: FromTextShow a -> FromTextShow a -> Bool # (/=) :: FromTextShow a -> FromTextShow a -> Bool #
Eq a => Eq (Product a) #
Methods (==) :: Product a -> Product a -> Bool # (/=) :: Product a -> Product a -> Bool #
Eq a => Eq (Sum a) #
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
(Eq b, Eq a) => Eq (Either a b)
Methods (==) :: Either a b -> Either a b -> Bool # (/=) :: Either a b -> Either a b -> Bool #
Eq (f p) => Eq (Rec1 f p)
Methods (==) :: Rec1 f p -> Rec1 f p -> Bool # (/=) :: Rec1 f p -> Rec1 f p -> Bool #
Eq (URec Char p)
Methods (==) :: URec Char p -> URec Char p -> Bool # (/=) :: URec Char p -> URec Char p -> Bool #
Eq (URec Double p)
Methods (==) :: URec Double p -> URec Double p -> Bool # (/=) :: URec Double p -> URec Double p -> Bool #
Eq (URec Float p)
Methods (==) :: URec Float p -> URec Float p -> Bool # (/=) :: URec Float p -> URec Float p -> Bool #
Eq (URec Int p)
Methods (==) :: URec Int p -> URec Int p -> Bool # (/=) :: URec Int p -> URec Int p -> Bool #
Eq (URec Word p)
Methods (==) :: URec Word p -> URec Word p -> Bool # (/=) :: URec Word p -> URec Word p -> Bool #
Eq (URec (Ptr ()) p)
Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool #
(Eq a, Eq b) => Eq (a, b)
Methods (==) :: (a, b) -> (a, b) -> Bool # (/=) :: (a, b) -> (a, b) -> Bool #
Eq a => Eq (Arg a b)
Methods (==) :: Arg a b -> Arg a b -> Bool # (/=) :: Arg a b -> Arg a b -> Bool #
Eq (Proxy k s)
Methods (==) :: Proxy k s -> Proxy k s -> Bool # (/=) :: Proxy k s -> Proxy k s -> Bool #
(Eq k, Eq a) => Eq (Map k a)
Methods (==) :: Map k a -> Map k a -> Bool # (/=) :: Map k a -> Map k a -> Bool #
Eq c => Eq (K1 i c p)
Methods (==) :: K1 i c p -> K1 i c p -> Bool # (/=) :: K1 i c p -> K1 i c p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:+:) f g p)
Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool #
(Eq (g p), Eq (f p)) => Eq ((:*:) f g p)
Methods (==) :: (f :: g) p -> (f :: g) p -> Bool # (/=) :: (f :: g) p -> (f :: g) p -> Bool #
Eq (f (g p)) => Eq ((:.:) f g p)
Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool #
(Eq a, Eq b, Eq c) => Eq (a, b, c)
Methods (==) :: (a, b, c) -> (a, b, c) -> Bool # (/=) :: (a, b, c) -> (a, b, c) -> Bool #
Eq a => Eq (Const k a b)
Methods (==) :: Const k a b -> Const k a b -> Bool # (/=) :: Const k a b -> Const k a b -> Bool #
Eq (f a) => Eq (Alt k f a)
Methods (==) :: Alt k f a -> Alt k f a -> Bool # (/=) :: Alt k f a -> Alt k f a -> Bool #
Eq ((:~:) k a b)
Methods (==) :: (k :~: a) b -> (k :~: a) b -> Bool # (/=) :: (k :~: a) b -> (k :~: a) b -> Bool #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)
Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool #
Eq b => Eq (Tagged k s b)
Methods (==) :: Tagged k s b -> Tagged k s b -> Bool # (/=) :: Tagged k s b -> Tagged k s b -> Bool #
Eq (f a) => Eq (FromStringShow1 k f a)
Methods (==) :: FromStringShow1 k f a -> FromStringShow1 k f a -> Bool # (/=) :: FromStringShow1 k f a -> FromStringShow1 k f a -> Bool #
Eq (f a) => Eq (FromTextShow1 k f a)
Methods (==) :: FromTextShow1 k f a -> FromTextShow1 k f a -> Bool # (/=) :: FromTextShow1 k f a -> FromTextShow1 k f a -> Bool #
Eq (f p) => Eq (M1 i c f p)
Methods (==) :: M1 i c f p -> M1 i c f p -> Bool # (/=) :: M1 i c f p -> M1 i c f p -> Bool #
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
Methods (==) :: (a, b, c, d) -> (a, b, c, d) -> Bool # (/=) :: (a, b, c, d) -> (a, b, c, d) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Sum * f g a)
Methods (==) :: Sum * f g a -> Sum * f g a -> Bool # (/=) :: Sum * f g a -> Sum * f g a -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Product * f g a)
Methods (==) :: Product * f g a -> Product * f g a -> Bool # (/=) :: Product * f g a -> Product * f g a -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
Methods (==) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool # (/=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool #
(Eq1 f, Eq1 g, Eq a) => Eq (Compose * * f g a)
Methods (==) :: Compose * * f g a -> Compose * * f g a -> Bool # (/=) :: Compose * * f g a -> Compose * * f g a -> Bool #
Eq (f a b) => Eq (FromStringShow2 k1 k f a b)
Methods (==) :: FromStringShow2 k1 k f a b -> FromStringShow2 k1 k f a b -> Bool # (/=) :: FromStringShow2 k1 k f a b -> FromStringShow2 k1 k f a b -> Bool #
Eq (f a b) => Eq (FromTextShow2 k1 k f a b)
Methods (==) :: FromTextShow2 k1 k f a b -> FromTextShow2 k1 k f a b -> Bool # (/=) :: FromTextShow2 k1 k f a b -> FromTextShow2 k1 k f a b -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f)
Methods (==) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool # (/=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g)
Methods (==) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool # (/=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h)
Methods (==) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool # (/=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i)
Methods (==) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l)
Methods (==) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool # (/=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
Methods (==) :: (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) -> Bool # (/=) :: (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) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
Methods (==) :: (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) -> Bool # (/=) :: (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) -> Bool #
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
Methods (==) :: (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) -> Bool # (/=) :: (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) -> Bool #

(==) :: Eq a => a -> a -> Bool #

(/=) :: Eq a => a -> a -> Bool #