rhi/quox
rhi/quox
1
0
Fork 0
Code Issues 15 Pull requests 1 Releases Wiki Activity

MakeName ⇒ MkName for consistency

Browse source
This commit is contained in:
rhiannon morris 2024-04-11 22:08:07 +02:00
parent 11b0ab6a25
commit fca75377a0
7 changed files with 28 additions and 28 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
lib/Quox/Name.idr
View file

@ -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

2
lib/Quox/Parser/FromParser.idr
View file

@ -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

6
lib/Quox/Parser/Parser.idr
View file

@ -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
_ => Nothing
Name (MkPName [<] x) => guard $ x == name
_ => Nothing
||| pattern var (unqualified name or _)

8
lib/Quox/Untyped/Scheme.idr
View file

@ -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 (MakeName mods (MN str k)) = I (makeIdBase mods str) 0
makeId (MakeName mods Unused) = I (makeIdBase mods "_") 0
makeId (MkName mods (UN str)) = I (makeIdBase mods str) 0
makeId (MkName mods (MN str k)) = I (makeIdBase mods str) 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

10
tests/Tests/Lexer.idr
View file

@ -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 "a.+" [Name $ MakePName [< "a"] "+"],
lexes "+.a" [Name $ MakePName [< "+"] "a"],
lexes "+.+.+" [Name $ MkPName [< "+", "+"] "+"],
lexes "a.+" [Name $ MkPName [< "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ω"],

8
tests/Tests/Parser.idr
View file

@ -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" _,

4
tests/Tests/PrettyTerm.idr
View file

@ -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",
testPrettyE [<] [<] (^F (MakeName [< "A", "B", "C"] "x") 2)
testPrettyE1 [<] [<] (^F (MkName [< "A", "B", "C"] "x") 0) "A.B.C.x",
testPrettyE [<] [<] (^F (MkName [< "A", "B", "C"] "x") 2)
"A.B.C.x²"
"A.B.C.x^2"
],