{-# LANGUAGE TypeFamilies         #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
                                      -- in module Language.Haskell.Syntax.Extension

{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

-}

-- See Note [Language.Haskell.Syntax.* Hierarchy] for why not GHC.Hs.*

-- | Source-language literals
module Language.Haskell.Syntax.Lit where

import Language.Haskell.Syntax.Extension
import Language.Haskell.Syntax.Module.Name (ModuleName)

import GHC.Types.SourceText (IntegralLit, FractionalLit, SourceText)

import GHC.Data.FastString (FastString, lexicalCompareFS)

import Data.ByteString (ByteString)
import Data.Data hiding ( Fixity )
import Data.Bool
import Data.Ord
import Data.Eq
import Data.Char
import Prelude (Integer)

{-
************************************************************************
*                                                                      *
\subsection[HsLit]{Literals}
*                                                                      *
************************************************************************
-}

-- Note [Literal source text] in "GHC.Types.SourceText" for SourceText fields in
-- the following
-- Note [Trees That Grow] in "Language.Haskell.Syntax.Extension" for the Xxxxx
-- fields in the following
-- | Haskell Literal
data HsLit x
  = HsChar (XHsChar x) {- SourceText -} Char
      -- ^ Character
  | HsCharPrim (XHsCharPrim x) {- SourceText -} Char
      -- ^ Unboxed character
  | HsString (XHsString x) {- SourceText -} FastString
      -- ^ String
  | HsStringPrim (XHsStringPrim x) {- SourceText -} !ByteString
      -- ^ Packed bytes
  | HsNatural (XHsNatural x)  IntegralLit
      -- ^ Genuinely a @Natural@; used in types only
  | HsDouble (XHsDouble x)  FractionalLit
      -- ^ Genuinely a @Double@; used in type errors only
  | HsInt (XHsInt x)  IntegralLit
      -- ^ Genuinely an Int; arises from
      -- "GHC.Tc.Deriv.Generate", and from TRANSLATION
  | HsIntPrim (XHsIntPrim x) {- SourceText -} Integer
      -- ^ literal @Int#@
  | HsWordPrim (XHsWordPrim x) {- SourceText -} Integer
      -- ^ literal @Word#@
  | HsInt8Prim (XHsInt8Prim x) {- SourceText -} Integer
      -- ^ literal @Int8#@
  | HsInt16Prim (XHsInt16Prim x) {- SourceText -} Integer
      -- ^ literal @Int16#@
  | HsInt32Prim (XHsInt32Prim x) {- SourceText -} Integer
      -- ^ literal @Int32#@
  | HsInt64Prim (XHsInt64Prim x) {- SourceText -} Integer
      -- ^ literal @Int64#@
  | HsWord8Prim (XHsWord8Prim x) {- SourceText -} Integer
      -- ^ literal @Word8#@
  | HsWord16Prim (XHsWord16Prim x) {- SourceText -} Integer
      -- ^ literal @Word16#@
  | HsWord32Prim (XHsWord32Prim x) {- SourceText -} Integer
      -- ^ literal @Word32#@
  | HsWord64Prim (XHsWord64Prim x) {- SourceText -} Integer
      -- ^ literal @Word64#@
  | HsFloatPrim (XHsFloatPrim x)   FractionalLit
      -- ^ Unboxed Float
  | HsDoublePrim (XHsDoublePrim x) FractionalLit
      -- ^ Unboxed Double
  | XLit !(XXLit x)

instance (Eq (XXLit x)) => Eq (HsLit x) where
  HsChar XHsChar x
_ Char
x1       == :: HsLit x -> HsLit x -> Bool
== HsChar XHsChar x
_ Char
x2       = Char
x1 Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
x2
  HsChar{}          == HsLit x
_                 = Bool
False
  HsCharPrim XHsCharPrim x
_ Char
x1   == HsCharPrim XHsCharPrim x
_ Char
x2   = Char
x1 Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
x2
  HsCharPrim{}      == HsLit x
_                 = Bool
False
  HsString XHsString x
_ FastString
x1     == HsString XHsString x
_ FastString
x2     = FastString
x1 FastString -> FastString -> Bool
forall a. Eq a => a -> a -> Bool
== FastString
x2
  HsString{}        == HsLit x
_                 = Bool
False
  HsStringPrim XHsStringPrim x
_ ByteString
x1 == HsStringPrim XHsStringPrim x
_ ByteString
x2 = ByteString
x1 ByteString -> ByteString -> Bool
forall a. Eq a => a -> a -> Bool
== ByteString
x2
  HsStringPrim{}    == HsLit x
_                 = Bool
False
  HsNatural XHsNatural x
_ IntegralLit
x1    == HsNatural XHsNatural x
_ IntegralLit
x2    = IntegralLit
x1 IntegralLit -> IntegralLit -> Bool
forall a. Eq a => a -> a -> Bool
== IntegralLit
x2
  HsNatural{}       == HsLit x
_                 = Bool
False
  HsDouble XHsDouble x
_ FractionalLit
x1     == HsDouble XHsDouble x
_ FractionalLit
x2     = FractionalLit
x1 FractionalLit -> FractionalLit -> Bool
forall a. Eq a => a -> a -> Bool
== FractionalLit
x2
  HsDouble{}        == HsLit x
_                 = Bool
False
  HsInt XHsInt x
_ IntegralLit
x1        == HsInt XHsInt x
_ IntegralLit
x2        = IntegralLit
x1 IntegralLit -> IntegralLit -> Bool
forall a. Eq a => a -> a -> Bool
== IntegralLit
x2
  HsInt{}           == HsLit x
_                 = Bool
False
  HsIntPrim XHsIntPrim x
_ Integer
x1    == HsIntPrim XHsIntPrim x
_ Integer
x2    = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsIntPrim{}       == HsLit x
_                 = Bool
False
  HsWordPrim XHsWordPrim x
_ Integer
x1   == HsWordPrim XHsWordPrim x
_ Integer
x2   = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsWordPrim{}      == HsLit x
_                 = Bool
False
  HsInt8Prim XHsInt8Prim x
_ Integer
x1   == HsInt8Prim XHsInt8Prim x
_ Integer
x2   = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsInt8Prim{}      == HsLit x
_                 = Bool
False
  HsInt16Prim XHsInt16Prim x
_ Integer
x1  == HsInt16Prim XHsInt16Prim x
_ Integer
x2  = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsInt16Prim{}     == HsLit x
_                 = Bool
False
  HsInt32Prim XHsInt32Prim x
_ Integer
x1  == HsInt32Prim XHsInt32Prim x
_ Integer
x2  = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsInt32Prim{}     == HsLit x
_                 = Bool
False
  HsInt64Prim XHsInt64Prim x
_ Integer
x1  == HsInt64Prim XHsInt64Prim x
_ Integer
x2  = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsInt64Prim{}     == HsLit x
_                 = Bool
False
  HsWord8Prim XHsWord8Prim x
_ Integer
x1  == HsWord8Prim XHsWord8Prim x
_ Integer
x2  = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsWord8Prim{}     == HsLit x
_                 = Bool
False
  HsWord16Prim XHsWord16Prim x
_ Integer
x1 == HsWord16Prim XHsWord16Prim x
_ Integer
x2 = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsWord16Prim{}    == HsLit x
_                 = Bool
False
  HsWord32Prim XHsWord32Prim x
_ Integer
x1 == HsWord32Prim XHsWord32Prim x
_ Integer
x2 = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsWord32Prim{}    == HsLit x
_                 = Bool
False
  HsWord64Prim XHsWord64Prim x
_ Integer
x1 == HsWord64Prim XHsWord64Prim x
_ Integer
x2 = Integer
x1 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
x2
  HsWord64Prim{}    == HsLit x
_                 = Bool
False
  HsFloatPrim XHsFloatPrim x
_ FractionalLit
x1  == HsFloatPrim XHsFloatPrim x
_ FractionalLit
x2  = FractionalLit
x1 FractionalLit -> FractionalLit -> Bool
forall a. Eq a => a -> a -> Bool
== FractionalLit
x2
  HsFloatPrim{}     == HsLit x
_                 = Bool
False
  HsDoublePrim XHsDoublePrim x
_ FractionalLit
x1 == HsDoublePrim XHsDoublePrim x
_ FractionalLit
x2 = FractionalLit
x1 FractionalLit -> FractionalLit -> Bool
forall a. Eq a => a -> a -> Bool
== FractionalLit
x2
  HsDoublePrim{}    == HsLit x
_                 = Bool
False
  XLit XXLit x
x1           == XLit XXLit x
x2           = XXLit x
x1 XXLit x -> XXLit x -> Bool
forall a. Eq a => a -> a -> Bool
== XXLit x
x2
  XLit{}            == HsLit x
_                 = Bool
False

-- | Haskell Overloaded Literal
data HsOverLit p
  = OverLit {
      forall p. HsOverLit p -> XOverLit p
ol_ext :: (XOverLit p),
      forall p. HsOverLit p -> OverLitVal
ol_val :: OverLitVal}

  | XOverLit
      !(XXOverLit p)

-- Note [Literal source text] in "GHC.Types.SourceText" for SourceText fields in
-- the following
-- | Overloaded Literal Value
data OverLitVal
  = HsIntegral   !IntegralLit            -- ^ Integer-looking literals;
  | HsFractional !FractionalLit          -- ^ Frac-looking literals
  | HsIsString   !SourceText !FastString -- ^ String-looking literals
  deriving Typeable OverLitVal
Typeable OverLitVal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OverLitVal -> c OverLitVal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OverLitVal)
-> (OverLitVal -> Constr)
-> (OverLitVal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OverLitVal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OverLitVal))
-> ((forall b. Data b => b -> b) -> OverLitVal -> OverLitVal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OverLitVal -> r)
-> (forall u. (forall d. Data d => d -> u) -> OverLitVal -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OverLitVal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal)
-> Data OverLitVal
OverLitVal -> Constr
OverLitVal -> DataType
(forall b. Data b => b -> b) -> OverLitVal -> OverLitVal
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OverLitVal -> u
forall u. (forall d. Data d => d -> u) -> OverLitVal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OverLitVal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OverLitVal -> c OverLitVal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OverLitVal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OverLitVal -> c OverLitVal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OverLitVal -> c OverLitVal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OverLitVal
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OverLitVal
$ctoConstr :: OverLitVal -> Constr
toConstr :: OverLitVal -> Constr
$cdataTypeOf :: OverLitVal -> DataType
dataTypeOf :: OverLitVal -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OverLitVal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OverLitVal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitVal)
$cgmapT :: (forall b. Data b => b -> b) -> OverLitVal -> OverLitVal
gmapT :: (forall b. Data b => b -> b) -> OverLitVal -> OverLitVal
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OverLitVal -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OverLitVal -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OverLitVal -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OverLitVal -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OverLitVal -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OverLitVal -> m OverLitVal
Data

instance Eq OverLitVal where
  HsIntegral   IntegralLit
i1 == :: OverLitVal -> OverLitVal -> Bool
== HsIntegral   IntegralLit
i2 = IntegralLit
i1 IntegralLit -> IntegralLit -> Bool
forall a. Eq a => a -> a -> Bool
== IntegralLit
i2
  HsIntegral{}    == OverLitVal
_               = Bool
False
  HsFractional FractionalLit
f1 == HsFractional FractionalLit
f2 = FractionalLit
f1 FractionalLit -> FractionalLit -> Bool
forall a. Eq a => a -> a -> Bool
== FractionalLit
f2
  HsFractional{}  == OverLitVal
_               = Bool
False
  HsIsString SourceText
_ FastString
s1 == HsIsString SourceText
_ FastString
s2 = FastString
s1 FastString -> FastString -> Bool
forall a. Eq a => a -> a -> Bool
== FastString
s2
  HsIsString{}    == OverLitVal
_               = Bool
False

instance Ord OverLitVal where
  -- HsIntegral
  HsIntegral IntegralLit
i1 compare :: OverLitVal -> OverLitVal -> Ordering
`compare` HsIntegral IntegralLit
i2  = IntegralLit
i1 IntegralLit -> IntegralLit -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` IntegralLit
i2
  HsIntegral{}  `compare` HsFractional{} = Ordering
LT
  HsIntegral{}  `compare` HsIsString{}   = Ordering
LT
  -- HsFractional
  HsFractional{}  `compare` HsIntegral{}    = Ordering
GT
  HsFractional FractionalLit
f1 `compare` HsFractional FractionalLit
f2 = FractionalLit
f1 FractionalLit -> FractionalLit -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` FractionalLit
f2
  HsFractional{}  `compare` HsIsString{}    = Ordering
LT
  -- HsIsString
  HsIsString{}    `compare` HsIntegral{}    = Ordering
GT
  HsIsString{}    `compare` HsFractional{}  = Ordering
GT
  HsIsString SourceText
_ FastString
s1 `compare` HsIsString SourceText
_ FastString
s2 = FastString
s1 FastString -> FastString -> Ordering
`lexicalCompareFS` FastString
s2

-- | Haskell Qualified Literal
data HsQualLit p
  = QualLit
      { forall p. HsQualLit p -> XQualLit p
ql_ext :: !(XQualLit p)
      , forall p. HsQualLit p -> ModuleName
ql_mod :: !ModuleName
      , forall p. HsQualLit p -> QualLitVal
ql_val :: !QualLitVal
      }
  | XQualLit !(XXQualLit p)

instance (Eq (XXQualLit p)) => Eq (HsQualLit p) where
  QualLit XQualLit p
_ ModuleName
m1 QualLitVal
v1 == :: HsQualLit p -> HsQualLit p -> Bool
== QualLit XQualLit p
_ ModuleName
m2 QualLitVal
v2 = (ModuleName
m1, QualLitVal
v1) (ModuleName, QualLitVal) -> (ModuleName, QualLitVal) -> Bool
forall a. Eq a => a -> a -> Bool
== (ModuleName
m2, QualLitVal
v2)
  QualLit{}       == HsQualLit p
_               = Bool
False
  XQualLit XXQualLit p
x1     == XQualLit XXQualLit p
x2     = XXQualLit p
x1 XXQualLit p -> XXQualLit p -> Bool
forall a. Eq a => a -> a -> Bool
== XXQualLit p
x2
  XQualLit{}      == HsQualLit p
_               = Bool
False

instance (Ord (XXQualLit p)) => Ord (HsQualLit p) where
  -- QualLit
  QualLit XQualLit p
_ ModuleName
m1 QualLitVal
v1 compare :: HsQualLit p -> HsQualLit p -> Ordering
`compare` QualLit XQualLit p
_ ModuleName
m2 QualLitVal
v2 = (ModuleName
m1, QualLitVal
v1) (ModuleName, QualLitVal) -> (ModuleName, QualLitVal) -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` (ModuleName
m2, QualLitVal
v2)
  QualLit{}       `compare` XQualLit{}      = Ordering
LT
  -- XQualLit
  XQualLit{}  `compare` QualLit{}   = Ordering
GT
  XQualLit XXQualLit p
x1 `compare` XQualLit XXQualLit p
x2 = XXQualLit p
x1 XXQualLit p -> XXQualLit p -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` XXQualLit p
x2

data QualLitVal
  = HsQualString !SourceText !FastString
    -- ^ See Note [Implementation of QualifiedStrings]
  deriving (Typeable QualLitVal
Typeable QualLitVal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> QualLitVal -> c QualLitVal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c QualLitVal)
-> (QualLitVal -> Constr)
-> (QualLitVal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c QualLitVal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c QualLitVal))
-> ((forall b. Data b => b -> b) -> QualLitVal -> QualLitVal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> QualLitVal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> QualLitVal -> r)
-> (forall u. (forall d. Data d => d -> u) -> QualLitVal -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> QualLitVal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal)
-> Data QualLitVal
QualLitVal -> Constr
QualLitVal -> DataType
(forall b. Data b => b -> b) -> QualLitVal -> QualLitVal
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> QualLitVal -> u
forall u. (forall d. Data d => d -> u) -> QualLitVal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualLitVal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualLitVal -> c QualLitVal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualLitVal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualLitVal)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualLitVal -> c QualLitVal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> QualLitVal -> c QualLitVal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualLitVal
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c QualLitVal
$ctoConstr :: QualLitVal -> Constr
toConstr :: QualLitVal -> Constr
$cdataTypeOf :: QualLitVal -> DataType
dataTypeOf :: QualLitVal -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualLitVal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c QualLitVal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualLitVal)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c QualLitVal)
$cgmapT :: (forall b. Data b => b -> b) -> QualLitVal -> QualLitVal
gmapT :: (forall b. Data b => b -> b) -> QualLitVal -> QualLitVal
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> QualLitVal -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> QualLitVal -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> QualLitVal -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualLitVal -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> QualLitVal -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> QualLitVal -> m QualLitVal
Data)

instance Eq QualLitVal where
  HsQualString SourceText
_ FastString
s1 == :: QualLitVal -> QualLitVal -> Bool
== HsQualString SourceText
_ FastString
s2 = FastString
s1 FastString -> FastString -> Bool
forall a. Eq a => a -> a -> Bool
== FastString
s2

instance Ord QualLitVal where
  HsQualString SourceText
_ FastString
s1 compare :: QualLitVal -> QualLitVal -> Ordering
`compare` HsQualString SourceText
_ FastString
s2 = FastString
s1 FastString -> FastString -> Ordering
`lexicalCompareFS` FastString
s2