2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section[HsLit]{Abstract syntax: source-language literals}
8 {-# LANGUAGE DeriveDataTypeable #-}
12 #include "HsVersions.h"
14 import {-# SOURCE #-} HsExpr( SyntaxExpr, pprExpr )
15 import BasicTypes ( FractionalLit(..) )
16 import HsTypes ( PostTcType )
25 %************************************************************************
27 \subsection[HsLit]{Literals}
29 %************************************************************************
34 = HsChar Char -- Character
35 | HsCharPrim Char -- Unboxed character
36 | HsString FastString -- String
37 | HsStringPrim FastString -- Packed string
38 | HsInt Integer -- Genuinely an Int; arises from TcGenDeriv,
39 -- and from TRANSLATION
40 | HsIntPrim Integer -- Unboxed Int
41 | HsWordPrim Integer -- Unboxed Word
42 | HsInteger Integer Type -- Genuinely an integer; arises only from TRANSLATION
43 -- (overloaded literals are done with HsOverLit)
44 | HsRat FractionalLit Type -- Genuinely a rational; arises only from TRANSLATION
45 -- (overloaded literals are done with HsOverLit)
46 | HsFloatPrim FractionalLit -- Unboxed Float
47 | HsDoublePrim FractionalLit -- Unboxed Double
48 deriving (Data, Typeable)
50 instance Eq HsLit where
51 (HsChar x1) == (HsChar x2) = x1==x2
52 (HsCharPrim x1) == (HsCharPrim x2) = x1==x2
53 (HsString x1) == (HsString x2) = x1==x2
54 (HsStringPrim x1) == (HsStringPrim x2) = x1==x2
55 (HsInt x1) == (HsInt x2) = x1==x2
56 (HsIntPrim x1) == (HsIntPrim x2) = x1==x2
57 (HsWordPrim x1) == (HsWordPrim x2) = x1==x2
58 (HsInteger x1 _) == (HsInteger x2 _) = x1==x2
59 (HsRat x1 _) == (HsRat x2 _) = x1==x2
60 (HsFloatPrim x1) == (HsFloatPrim x2) = x1==x2
61 (HsDoublePrim x1) == (HsDoublePrim x2) = x1==x2
64 data HsOverLit id -- An overloaded literal
67 ol_rebindable :: Bool, -- Note [ol_rebindable]
68 ol_witness :: SyntaxExpr id, -- Note [Overloaded literal witnesses]
69 ol_type :: PostTcType }
70 deriving (Data, Typeable)
73 = HsIntegral !Integer -- Integer-looking literals;
74 | HsFractional !FractionalLit -- Frac-looking literals
75 | HsIsString !FastString -- String-looking literals
76 deriving (Data, Typeable)
78 overLitType :: HsOverLit a -> Type
84 The ol_rebindable field is True if this literal is actually
85 using rebindable syntax. Specifically:
87 False iff ol_witness is the standard one
88 True iff ol_witness is non-standard
90 Equivalently it's True if
91 a) RebindableSyntax is on
92 b) the witness for fromInteger/fromRational/fromString
93 that happens to be in scope isn't the standard one
95 Note [Overloaded literal witnesses]
96 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
97 *Before* type checking, the SyntaxExpr in an HsOverLit is the
98 name of the coercion function, 'fromInteger' or 'fromRational'.
99 *After* type checking, it is a witness for the literal, such as
100 (fromInteger 3) or lit_78
101 This witness should replace the literal.
103 This dual role is unusual, because we're replacing 'fromInteger' with
104 a call to fromInteger. Reason: it allows commoning up of the fromInteger
105 calls, which wouldn't be possible if the desguarar made the application.
107 The PostTcType in each branch records the type the overload literal is
111 -- Comparison operations are needed when grouping literals
112 -- for compiling pattern-matching (module MatchLit)
113 instance Eq (HsOverLit id) where
114 (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2
116 instance Eq OverLitVal where
117 (HsIntegral i1) == (HsIntegral i2) = i1 == i2
118 (HsFractional f1) == (HsFractional f2) = f1 == f2
119 (HsIsString s1) == (HsIsString s2) = s1 == s2
122 instance Ord (HsOverLit id) where
123 compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2
125 instance Ord OverLitVal where
126 compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2
127 compare (HsIntegral _) (HsFractional _) = LT
128 compare (HsIntegral _) (HsIsString _) = LT
129 compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2
130 compare (HsFractional _) (HsIntegral _) = GT
131 compare (HsFractional _) (HsIsString _) = LT
132 compare (HsIsString s1) (HsIsString s2) = s1 `compare` s2
133 compare (HsIsString _) (HsIntegral _) = GT
134 compare (HsIsString _) (HsFractional _) = GT
138 instance Outputable HsLit where
139 -- Use "show" because it puts in appropriate escapes
140 ppr (HsChar c) = pprHsChar c
141 ppr (HsCharPrim c) = pprHsChar c <> char '#'
142 ppr (HsString s) = pprHsString s
143 ppr (HsStringPrim s) = pprHsString s <> char '#'
144 ppr (HsInt i) = integer i
145 ppr (HsInteger i _) = integer i
146 ppr (HsRat f _) = ppr f
147 ppr (HsFloatPrim f) = ppr f <> char '#'
148 ppr (HsDoublePrim d) = ppr d <> text "##"
149 ppr (HsIntPrim i) = integer i <> char '#'
150 ppr (HsWordPrim w) = integer w <> text "##"
152 -- in debug mode, print the expression that it's resolved to, too
153 instance OutputableBndr id => Outputable (HsOverLit id) where
154 ppr (OverLit {ol_val=val, ol_witness=witness})
155 = ppr val <+> (ifPprDebug (parens (pprExpr witness)))
157 instance Outputable OverLitVal where
158 ppr (HsIntegral i) = integer i
159 ppr (HsFractional f) = ppr f
160 ppr (HsIsString s) = pprHsString s