feature: Allow any names as record keys

src/T/Embed.hs

@@ -103,7 +103,7 @@ instance Eject Pcre.Regex where
     value ->
       Left (TypeError (varE name) Type.Regexp (typeOf value) (sexp value))
 
-instance (k ~ Text, v ~ Value) => Eject (HashMap k v) where
+instance (k ~ Name, v ~ Value) => Eject (HashMap k v) where
   eject name = \case
     Record o ->
       pure o

src/T/Exp.hs

@@ -120,7 +120,7 @@ array :: Vector Exp -> Exp
 array =
   litE_ . Array
 
-record :: HashMap Text Exp -> Exp
+record :: HashMap Name Exp -> Exp
 record =
   litE_ . Record
 
@@ -164,7 +164,7 @@ data Literal
   | String Text
   | Regexp Pcre.Regex
   | Array (Vector Exp)
-  | Record (HashMap Text Exp)
+  | Record (HashMap Name Exp)
     deriving (Show, Eq)
 
 instance SExp.To Literal where

src/T/Name.hs

@@ -3,6 +3,7 @@
 module T.Name
   ( Name(..)
   , toString
+  , toText
   ) where
 
 
@@ -32,3 +33,7 @@ instance Pretty Name where
 toString :: Name -> String
 toString name =
   Text.unpack name.unName
+
+toText :: Name -> Text
+toText name =
+  name.unName

src/T/Parse.hs

@@ -302,7 +302,7 @@ litP = do
       (braces (spaces *> Unspaced (sepBy kv (symbol ","))))
    where
     kv = do
-      k <- map fromString (some letter)
+      _ :+ k <- nameP
       _ <- symbol ":"
       v <- expP
       pure (k, v)

src/T/Render.hs

@@ -219,7 +219,7 @@ evalExp = \case
         throwError (OutOfBounds expIdx (sexp xs) (sexp idx))
       Just x ->
         pure x
-  _ :< Key exp (_ :+ Name key) -> do
+  _ :< Key exp (_ :+ key) -> do
     r <- enforceRecord exp
     case HashMap.lookup key r of
       Nothing ->
@@ -245,7 +245,7 @@ enforceArray exp = do
     _ ->
       throwError (TypeError exp Type.Array (Value.typeOf v) (sexp v))
 
-enforceRecord :: (Ctx m, MonadError Error m) => Exp -> m (HashMap Text Value)
+enforceRecord :: (Ctx m, MonadError Error m) => Exp -> m (HashMap Name Value)
 enforceRecord exp = do
   v <- evalExp exp
   case v of
@@ -429,12 +429,12 @@ build :: MonadState Rendering m => Builder -> m ()
 build chunk =
   modify (\env -> env {Rendering.result = env.result <> chunk})
 
-loopRecord :: Maybe Text -> Int -> Int -> Value
+loopRecord :: Maybe Name -> Int -> Int -> Value
 loopRecord key len idx =
   Value.Record $ HashMap.fromList
     [ ("length", Value.Int len)
     , ("index", Value.Int idx)
     , ("first", Value.Bool (idx == 0))
     , ("last", Value.Bool (idx == len - 1))
-    , ("key", maybe Value.Null Value.String key)
+    , ("key", maybe Value.Null (Value.String . Name.toText) key)
     ]

src/T/Value.hs

@@ -10,13 +10,16 @@ module T.Value
 import Data.Aeson qualified as Aeson
 import Data.Aeson.KeyMap qualified as Aeson (fromHashMapText, toHashMapText)
 import Data.ByteString.Lazy qualified as Lazy (ByteString)
+import Data.HashMap.Strict qualified as HashMap
 import Data.Scientific qualified as Scientific
 import Data.Text.Lazy qualified as Text.Lazy
 import Data.Text.Lazy.Encoding qualified as Text.Lazy
 import Text.Regex.PCRE.Light qualified as Pcre
 
 import T.Error (Error)
 import T.Exp ((:+)(..), Ann)
+import T.Name (Name(..))
+import T.Name qualified as Name
 import T.Prelude
 import T.SExp (sexp)
 import T.SExp qualified as SExp
@@ -32,7 +35,7 @@ data Value
   | String Text
   | Regexp Pcre.Regex
   | Array (Vector Value)
-  | Record (HashMap Text Value)
+  | Record (HashMap Name Value)
   | Lam (Ann :+ Value -> Either Error Value)
 
 instance SExp.To Value where
@@ -86,7 +89,7 @@ displayWith f =
     Array xs ->
       Aeson.Array (map ejectAeson xs)
     Record r ->
-      Aeson.Object (Aeson.fromHashMapText (map ejectAeson r))
+      Aeson.Object (Aeson.fromHashMapText (HashMap.mapKeys Name.toText (map ejectAeson r)))
     Lam _f ->
       Aeson.String "<lambda>"
 
@@ -115,4 +118,4 @@ embedAeson = \case
   Aeson.Array xs ->
     Array (map embedAeson xs)
   Aeson.Object xs ->
-    Record (Aeson.toHashMapText (map embedAeson xs))
+    Record (HashMap.mapKeys Name (Aeson.toHashMapText (map embedAeson xs)))

test/T/Parse/AnnSpec.hs

@@ -70,7 +70,7 @@ spec =
         errorOf "{{ {foo:4} + 1 }}" `shouldBe`
           "(interactive):1:4: error: mismatched types in +: \n\
           \  expected: Number\n\
-          \   but got: {\"foo\" 4} : Record\n\
+          \   but got: {foo 4} : Record\n\
           \1 | {{ {foo:4} + 1 }}<EOF> \n\
           \  |    ~~~~~~~             "
 

test/T/ParseSpec.hs

@@ -67,6 +67,7 @@ spec =
           (int 7))
       "{{ {} }}" `shouldParseTo` Tmpl.Exp (record [])
       "{{ {x: 4} }}" `shouldParseTo` Tmpl.Exp (record [("x", int 4)])
+      "{{ {x->y: 4} }}" `shouldParseTo` Tmpl.Exp (record [("x->y", int 4)])
       "{{ {x: 4, y: \"foo\"} }}" `shouldParseTo`
         Tmpl.Exp
           (record
@@ -258,7 +259,7 @@ array :: [Exp] -> Exp
 array =
   litE_ . Array . Vector.fromList
 
-record :: [(Text, Exp)] -> Exp
+record :: [(Name, Exp)] -> Exp
 record =
   litE_ . Record . HashMap.fromList
 

test/T/RenderSpec.hs

@@ -76,7 +76,7 @@ spec =
         r_ "{{ {foo: [1,{bar: 7},3]}.foo[1].bar }}" `shouldRender` "7"
         r_ "{{ 4.foo }}" `shouldRaise`
           TypeError (litE_ (Int 4)) Type.Record Type.Int "4"
-        r_ "{{ {}.foo }}" `shouldRaise` MissingProperty (record mempty) (sexp (record mempty)) "\"foo\""
+        r_ "{{ {}.foo }}" `shouldRaise` MissingProperty (record mempty) (sexp (record mempty)) "foo"
 
     context "line blocks" $
       it "examples" $ do

test/T/SExpSpec.hs

@@ -9,6 +9,7 @@ import T.Parse (parseText)
 import T.Prelude
 import T.Exp (Exp)
 import T.SExp (render, sexp)
+import T.Name (Name)
 import T.Stdlib qualified as Stdlib
 import T.Tmpl (Tmpl)
 import T.Tmpl qualified as Tmpl
@@ -73,7 +74,7 @@ spec = do
         rexp "{{ [false, 42] }}" `shouldBe` "[false 42]"
 
       it "record" $
-        rexp "{{ {foo: 42, bar: 4.2} }}" `shouldBe` "{\"bar\" 4.2 \"foo\" 42}"
+        rexp "{{ {foo: 42, bar: 4.2} }}" `shouldBe` "{bar 4.2 foo 42}"
 
     it "var" $
       rexp "{{ foo }}" `shouldBe` "foo"
@@ -127,9 +128,9 @@ spec = do
 
     it "record" $ do
       render (sexp (Value.Record [("foo", Value.Int 4), ("bar",  Value.Int 7)])) `shouldBe`
-        "{\"bar\" 7 \"foo\" 4}"
-      render (sexp ([("foo", 4), ("bar",  7)] :: HashMap Text Int)) `shouldBe`
-        "{\"bar\" 7 \"foo\" 4}"
+        "{bar 7 foo 4}"
+      render (sexp ([("foo", 4), ("bar",  7)] :: HashMap Name Int)) `shouldBe`
+        "{bar 7 foo 4}"
 
     it "lam" $
       render (sexp (Value.Lam (\_ -> pure Value.Null))) `shouldBe` "(lambda [_] ...)"