MakeName ⇒ MkName for consistency

lib/Quox/Name.idr

@@ -43,14 +43,14 @@ Mods = SnocList String
 
 public export
 record Name where
-  constructor MakeName
+  constructor MkName
   mods : Mods
   base : BaseName
 %runElab derive "Name" [Eq, Ord]
 
 public export %inline
 unq : BaseName -> Name
-unq = MakeName [<]
+unq = MkName [<]
 
 ||| add some namespaces to the beginning of a name
 public export %inline
@@ -64,31 +64,31 @@ PBaseName = String
 
 public export
 record PName where
-  constructor MakePName
+  constructor MkPName
   mods : Mods
   base : PBaseName
 %runElab derive "PName" [Eq, Ord, PrettyVal]
 
 export %inline
 fromPName : PName -> Name
-fromPName p = MakeName p.mods $ UN p.base
+fromPName p = MkName p.mods $ UN p.base
 
 export %inline
 toPName : Name -> PName
-toPName p = MakePName p.mods $ baseStr p.base
+toPName p = MkPName p.mods $ baseStr p.base
 
 export %inline
 fromPBaseName : PBaseName -> Name
-fromPBaseName = MakeName [<] . UN
+fromPBaseName = MkName [<] . UN
 
 export
 Show PName where
-  show (MakePName mods base) =
+  show (MkPName mods base) =
     show $ concat $ intersperse "." $ toList $ mods :< base
 
 export Show Name where show = show . toPName
 
-export FromString PName where fromString = MakePName [<]
+export FromString PName where fromString = MkPName [<]
 
 export FromString Name where fromString = fromPBaseName
 
@@ -116,7 +116,7 @@ export
 fromListP : List1 String -> PName
 fromListP (x ::: xs) = go [<] x xs where
   go : SnocList String -> String -> List String -> PName
-  go mods x []        = MakePName mods x
+  go mods x []        = MkPName mods x
   go mods x (y :: ys) = go (mods :< x) y ys
 
 export %inline

lib/Quox/Parser/FromParser.idr

@@ -75,7 +75,7 @@ parameters {auto _ : Functor m} (b : Var n -> m a) (f : PName -> m a)
            (xs : Context' PatVar n)
   private
   fromBaseName : PBaseName -> m a
-  fromBaseName x = maybe (f $ MakePName [<] x) b $
+  fromBaseName x = maybe (f $ MkPName [<] x) b $
                    Context.find (\y => y.name == Just x) xs
 
   private

lib/Quox/Parser/Parser.idr

@@ -124,7 +124,7 @@ qname = terminalMatch "name" `(Name n) `(n)
 ||| unqualified name
 export
 baseName : Grammar True PBaseName
-baseName = terminalMatch "unqualified name" `(Name (MakePName [<] b)) `(b)
+baseName = terminalMatch "unqualified name" `(Name (MkPName [<] b)) `(b)
 
 ||| dimension constant (0 or 1)
 export
@@ -152,8 +152,8 @@ qty fname = withLoc fname [|PQ qtyVal|]
 export
 exactName : String -> Grammar True ()
 exactName name = terminal "expected '\{name}'" $ \case
-  Name (MakePName [<] x) => guard $ x == name
+  Name (MkPName [<] x) => guard $ x == name
-  _                      => Nothing
+  _                    => Nothing
 
 
 ||| pattern var (unqualified name or _)

lib/Quox/Untyped/Scheme.idr

@@ -113,13 +113,13 @@ makeIdBase mods str = joinBy "." $ toList $ mods :< str
 
 export
 makeId : Name -> Id
-makeId (MakeName mods (UN str))   = I (makeIdBase mods str) 0
+makeId (MkName mods (UN str))   = I (makeIdBase mods str) 0
-makeId (MakeName mods (MN str k)) = I (makeIdBase mods str) 0
+makeId (MkName mods (MN str k)) = I (makeIdBase mods str) 0
-makeId (MakeName mods Unused)     = I (makeIdBase mods "_") 0
+makeId (MkName mods Unused)     = I (makeIdBase mods "_") 0
 
 export
 makeIdB : BindName -> Id
-makeIdB (BN name _) = makeId $ MakeName [<] name
+makeIdB (BN name _) = makeId $ MkName [<] name
 
 private
 bump : Id -> Id

tests/Tests/Lexer.idr

@@ -71,7 +71,7 @@ tests = "lexer" :- [
     lexes "δελτα" [Name "δελτα"],
     lexes "★★" [Name "★★"],
     lexes "Types" [Name "Types"],
-    lexes "a.b.c.d.e" [Name $ MakePName [< "a","b","c","d"] "e"],
+    lexes "a.b.c.d.e" [Name $ MkPName [< "a","b","c","d"] "e"],
     lexes "normalïse" [Name "normalïse"],
       -- ↑ replace i + combining ¨ with precomposed ï
     lexes "map#" [Name "map#"],
@@ -90,16 +90,16 @@ tests = "lexer" :- [
     lexes "***" [Name "***"],
     lexes "+**" [Name "+**"],
     lexes "+#" [Name "+#"],
-    lexes "+.+.+" [Name $ MakePName [< "+", "+"] "+"],
+    lexes "+.+.+" [Name $ MkPName [< "+", "+"] "+"],
-    lexes "a.+" [Name $ MakePName [< "a"] "+"],
+    lexes "a.+" [Name $ MkPName [< "a"] "+"],
-    lexes "+.a" [Name $ MakePName [< "+"] "a"],
+    lexes "+.a" [Name $ MkPName [< "+"] "a"],
 
     lexes "+a" [Name "+", Name "a"],
 
     lexes "x." [Name "x", Reserved "."],
     lexes "&." [Name "&", Reserved "."],
     lexes ".x" [Reserved ".", Name "x"],
-    lexes "a.b.c." [Name $ MakePName [< "a", "b"] "c", Reserved "."],
+    lexes "a.b.c." [Name $ MkPName [< "a", "b"] "c", Reserved "."],
 
     lexes "case" [Reserved "case"],
     lexes "caseω" [Reserved "caseω"],

tests/Tests/Parser.idr

@@ -63,9 +63,9 @@ tests = "parser" :- [
 
   "names" :- [
     parsesAs (const qname) "x"
-      (MakePName [<] "x"),
+      (MkPName [<] "x"),
     parsesAs (const qname) "Data.List.length"
-      (MakePName [< "Data", "List"] "length"),
+      (MkPName [< "Data", "List"] "length"),
     parseFails (const qname) "_"
   ],
 
@@ -124,7 +124,7 @@ tests = "parser" :- [
     parseMatch term "f"
       `(V "f" {}),
     parseMatch term "f.x.y"
-      `(V (MakePName [< "f", "x"] "y") {}),
+      `(V (MkPName [< "f", "x"] "y") {}),
     parseMatch term "f x"
       `(App (V "f" {}) (V "x" {}) _),
     parseMatch term "f x y"
@@ -526,7 +526,7 @@ tests = "parser" :- [
               PSucceed False Nothing _]
             PSucceed _),
          PD (PDef $ MkPDef (PQ Any _) "y"
-          (PConcrete Nothing (V (MakePName [< "a"] "x") Nothing _))
+          (PConcrete Nothing (V (MkPName [< "a"] "x") Nothing _))
           PSucceed False Nothing _)]),
     parseMatch input #" load "a.quox"; def b = a.b "#
       `([PLoad "a.quox" _,

tests/Tests/PrettyTerm.idr

@@ -37,8 +37,8 @@ tests = "pretty printing terms" :- [
   "free vars" :- [
     testPrettyE1 [<] [<] (^F "x" 0) "x",
     testPrettyE  [<] [<] (^F "x" 1) "x¹" "x^1",
-    testPrettyE1 [<] [<] (^F (MakeName [< "A", "B", "C"] "x") 0) "A.B.C.x",
+    testPrettyE1 [<] [<] (^F (MkName [< "A", "B", "C"] "x") 0) "A.B.C.x",
-    testPrettyE  [<] [<] (^F (MakeName [< "A", "B", "C"] "x") 2)
+    testPrettyE  [<] [<] (^F (MkName [< "A", "B", "C"] "x") 2)
       "A.B.C.x²"
       "A.B.C.x^2"
   ],