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}
10 #include "HsVersions.h"
12 import {-# SOURCE #-} HsExpr( SyntaxExpr, pprExpr )
13 import HsTypes (PostTcType)
20 %************************************************************************
22 \subsection[HsLit]{Literals}
24 %************************************************************************
29 = HsChar Char -- Character
30 | HsCharPrim Char -- Unboxed character
31 | HsString FastString -- String
32 | HsStringPrim FastString -- Packed string
33 | HsInt Integer -- Genuinely an Int; arises from TcGenDeriv,
34 -- and from TRANSLATION
35 | HsIntPrim Integer -- Unboxed Int
36 | HsWordPrim Integer -- Unboxed Word
37 | HsInteger Integer Type -- Genuinely an integer; arises only from TRANSLATION
38 -- (overloaded literals are done with HsOverLit)
39 | HsRat Rational Type -- Genuinely a rational; arises only from TRANSLATION
40 -- (overloaded literals are done with HsOverLit)
41 | HsFloatPrim Rational -- Unboxed Float
42 | HsDoublePrim Rational -- Unboxed Double
44 instance Eq HsLit where
45 (HsChar x1) == (HsChar x2) = x1==x2
46 (HsCharPrim x1) == (HsCharPrim x2) = x1==x2
47 (HsString x1) == (HsString x2) = x1==x2
48 (HsStringPrim x1) == (HsStringPrim x2) = x1==x2
49 (HsInt x1) == (HsInt x2) = x1==x2
50 (HsIntPrim x1) == (HsIntPrim x2) = x1==x2
51 (HsWordPrim x1) == (HsWordPrim x2) = x1==x2
52 (HsInteger x1 _) == (HsInteger x2 _) = x1==x2
53 (HsRat x1 _) == (HsRat x2 _) = x1==x2
54 (HsFloatPrim x1) == (HsFloatPrim x2) = x1==x2
55 (HsDoublePrim x1) == (HsDoublePrim x2) = x1==x2
58 data HsOverLit id -- An overloaded literal
61 ol_rebindable :: Bool, -- True <=> rebindable syntax
62 -- False <=> standard syntax
63 ol_witness :: SyntaxExpr id, -- Note [Overloaded literal witnesses]
64 ol_type :: PostTcType }
67 = HsIntegral !Integer -- Integer-looking literals;
68 | HsFractional !Rational -- Frac-looking literals
69 | HsIsString !FastString -- String-looking literals
71 overLitType :: HsOverLit a -> Type
75 Note [Overloaded literal witnesses]
76 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
77 *Before* type checking, the SyntaxExpr in an HsOverLit is the
78 name of the coercion function, 'fromInteger' or 'fromRational'.
79 *After* type checking, it is a witness for the literal, such as
80 (fromInteger 3) or lit_78
81 This witness should replace the literal.
83 This dual role is unusual, because we're replacing 'fromInteger' with
84 a call to fromInteger. Reason: it allows commoning up of the fromInteger
85 calls, which wouldn't be possible if the desguarar made the application
87 The PostTcType in each branch records the type the overload literal is
91 -- Comparison operations are needed when grouping literals
92 -- for compiling pattern-matching (module MatchLit)
93 instance Eq (HsOverLit id) where
94 (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2
96 instance Eq OverLitVal where
97 (HsIntegral i1) == (HsIntegral i2) = i1 == i2
98 (HsFractional f1) == (HsFractional f2) = f1 == f2
99 (HsIsString s1) == (HsIsString s2) = s1 == s2
102 instance Ord (HsOverLit id) where
103 compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2
105 instance Ord OverLitVal where
106 compare (HsIntegral i1) (HsIntegral i2) = i1 `compare` i2
107 compare (HsIntegral _) (HsFractional _) = LT
108 compare (HsIntegral _) (HsIsString _) = LT
109 compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2
110 compare (HsFractional _) (HsIntegral _) = GT
111 compare (HsFractional _) (HsIsString _) = LT
112 compare (HsIsString s1) (HsIsString s2) = s1 `compare` s2
113 compare (HsIsString _) (HsIntegral _) = GT
114 compare (HsIsString _) (HsFractional _) = GT
118 instance Outputable HsLit where
119 -- Use "show" because it puts in appropriate escapes
120 ppr (HsChar c) = pprHsChar c
121 ppr (HsCharPrim c) = pprHsChar c <> char '#'
122 ppr (HsString s) = pprHsString s
123 ppr (HsStringPrim s) = pprHsString s <> char '#'
124 ppr (HsInt i) = integer i
125 ppr (HsInteger i _) = integer i
126 ppr (HsRat f _) = rational f
127 ppr (HsFloatPrim f) = rational f <> char '#'
128 ppr (HsDoublePrim d) = rational d <> text "##"
129 ppr (HsIntPrim i) = integer i <> char '#'
130 ppr (HsWordPrim w) = integer w <> text "##"
132 -- in debug mode, print the expression that it's resolved to, too
133 instance OutputableBndr id => Outputable (HsOverLit id) where
134 ppr (OverLit {ol_val=val, ol_witness=witness})
135 = ppr val <+> (ifPprDebug (parens (pprExpr witness)))
137 instance Outputable OverLitVal where
138 ppr (HsIntegral i) = integer i
139 ppr (HsFractional f) = rational f
140 ppr (HsIsString s) = pprHsString s