Represent user variables as Text.

Author: robrix

semantic-core/src/Analysis/Concrete.hs

@@ -1,4 +1,4 @@
-{-# LANGUAGE FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, LambdaCase, MultiParamTypeClasses, NamedFieldPuns, RecordWildCards, TypeApplications, TypeOperators, UndecidableInstances #-}
+{-# LANGUAGE FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, LambdaCase, MultiParamTypeClasses, NamedFieldPuns, OverloadedStrings, RecordWildCards, TypeApplications, TypeOperators, UndecidableInstances #-}
 module Analysis.Concrete
 ( Concrete(..)
 , concrete
@@ -29,7 +29,7 @@ import           Data.Loc
 import qualified Data.Map as Map
 import           Data.Monoid (Alt(..))
 import           Data.Name
-import           Data.Text (Text, unpack)
+import           Data.Text (Text, pack)
 import           Prelude hiding (fail)
 
 type Precise = Int
@@ -185,25 +185,25 @@ heapValueGraph h = heapGraph (const id) (const fromAddr) h
 heapAddressGraph :: Heap -> G.Graph (EdgeType, Precise)
 heapAddressGraph = heapGraph (\ addr v -> (Value v, addr)) (fmap G.vertex . (,) . either Edge Slot)
 
-addressStyle :: Heap -> G.Style (EdgeType, Precise) String
+addressStyle :: Heap -> G.Style (EdgeType, Precise) Text
 addressStyle heap = (G.defaultStyle vertex) { G.edgeAttributes }
-  where vertex (_, addr) = maybe (show addr <> " = ?") (((show addr <> " = ") <>) . fromConcrete) (IntMap.lookup addr heap)
+  where vertex (_, addr) = maybe (pack (show addr) <> " = ?") (((pack (show addr) <> " = ") <>) . fromConcrete) (IntMap.lookup addr heap)
         edgeAttributes _ (Slot name,         _) = ["label" G.:= fromName name]
         edgeAttributes _ (Edge Core.Import,  _) = ["color" G.:= "blue"]
         edgeAttributes _ (Edge Core.Lexical, _) = ["color" G.:= "green"]
         edgeAttributes _ _                      = []
         fromConcrete = \case
           Unit ->  "()"
-          Bool b -> show b
-          String s -> show s
-          Closure (Loc p (Span s e)) n _ _ -> "\\\\ " <> fromName n <> " [" <> unpack p <> ":" <> showPos s <> "-" <> showPos e <> "]"
+          Bool b -> pack $ show b
+          String s -> pack $ show s
+          Closure (Loc p (Span s e)) n _ _ -> "\\\\ " <> fromName n <> " [" <> p <> ":" <> showPos s <> "-" <> showPos e <> "]"
           Obj _ -> "{}"
-        showPos (Pos l c) = show l <> ":" <> show c
+        showPos (Pos l c) = pack (show l) <> ":" <> pack (show c)
         fromName (User s)  = s
         fromName (Gen sym) = fromGensym sym
-        fromName (Path p)  = show p
-        fromGensym (Root s) = s
-        fromGensym (ss :/ (s, i)) = fromGensym ss <> "." <> s <> show i
+        fromName (Path p)  = pack $ show p
+        fromGensym (Root s) = pack s
+        fromGensym (ss :/ (s, i)) = fromGensym ss <> "." <> pack s <> pack (show i)
 
 data EdgeType
   = Edge Core.Edge

semantic-core/src/Data/Name.hs

@@ -26,12 +26,12 @@ import           Control.Monad.IO.Class
 import qualified Data.Char as Char
 import           Data.HashSet (HashSet)
 import qualified Data.HashSet as HashSet
-import           Data.Text (Text)
+import           Data.Text as Text (Text, any, unpack)
 import           Data.Text.Prettyprint.Doc (Pretty (..))
 import qualified Data.Text.Prettyprint.Doc as Pretty
 
 -- | User-specified and -relevant names.
-type User = String
+type User = Text
 
 -- | The type of namespaced actions, i.e. actions occurring within some outer name.
 --
@@ -57,14 +57,14 @@ instance Pretty Name where
     User n -> pretty n
     Path p -> pretty (show p)
 
-reservedNames :: HashSet User
+reservedNames :: HashSet String
 reservedNames = [ "#true", "#false", "let", "#frame", "if", "then", "else"
                 , "lexical", "import", "#unit", "load"]
 
 -- | Returns true if any character would require quotation or if the
 -- name conflicts with a Core primitive.
 needsQuotation :: User -> Bool
-needsQuotation u = HashSet.member u reservedNames || any (not . isSimpleCharacter) u
+needsQuotation u = HashSet.member (unpack u) reservedNames || Text.any (not . isSimpleCharacter) u
 
 -- | A ‘simple’ character is, loosely defined, a character that is compatible
 -- with identifiers in most ASCII-oriented programming languages. This is defined