Remove various -raw suffixes

4 files changed, 148 insertions, 156 deletions

diff --git a/dhall_core/src/parser.rs b/dhall_core/src/parser.rs
index 4614673..f959d2e 100644
--- a/dhall_core/src/parser.rs
+++ b/dhall_core/src/parser.rs
@@ -245,7 +245,7 @@ fn can_be_shortcutted(rule: Rule) -> bool {
         | equal_expression
         | not_equal_expression
         | application_expression
-        | selector_expression_raw
+        | selector_expression
         | annotated_expression => true,
         _ => false,
     }
@@ -256,7 +256,7 @@ make_parser! {
 
     rule!(simple_label<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
     rule!(quoted_label<Label>; captured_str!(s) => Label::from(s.trim().to_owned()));
-    rule!(label_raw<Label>; children!(
+    rule!(label<Label>; children!(
         [simple_label(l)] => l,
         [quoted_label(l)] => l,
     ));
@@ -346,11 +346,11 @@ make_parser! {
         },
     ));
 
-    rule!(NaN_raw<()>; captured_str!(_) => ());
+    rule!(NaN<()>; captured_str!(_) => ());
     rule!(minus_infinity_literal<()>; captured_str!(_) => ());
     rule!(plus_infinity_literal<()>; captured_str!(_) => ());
 
-    rule!(double_literal_raw<core::Double>;
+    rule!(double_literal<core::Double>;
         captured_str!(s) => {
             let s = s.trim();
             match s.parse::<f64>() {
@@ -362,7 +362,7 @@ make_parser! {
         }
     );
 
-    rule!(natural_literal_raw<core::Natural>;
+    rule!(natural_literal<core::Natural>;
         captured_str!(s) => {
             s.trim()
                 .parse()
@@ -370,7 +370,7 @@ make_parser! {
         }
     );
 
-    rule!(integer_literal_raw<core::Integer>;
+    rule!(integer_literal<core::Integer>;
         captured_str!(s) => {
             s.trim()
                 .parse()
@@ -390,18 +390,18 @@ make_parser! {
         }
     ));
 
-    rule_group!(local_raw<(FilePrefix, PathBuf)>);
+    rule_group!(local<(FilePrefix, PathBuf)>);
 
-    rule!(parent_path<(FilePrefix, PathBuf)> as local_raw; children!(
+    rule!(parent_path<(FilePrefix, PathBuf)> as local; children!(
         [path(p)] => (FilePrefix::Parent, p)
     ));
-    rule!(here_path<(FilePrefix, PathBuf)> as local_raw; children!(
+    rule!(here_path<(FilePrefix, PathBuf)> as local; children!(
         [path(p)] => (FilePrefix::Here, p)
     ));
-    rule!(home_path<(FilePrefix, PathBuf)> as local_raw; children!(
+    rule!(home_path<(FilePrefix, PathBuf)> as local; children!(
         [path(p)] => (FilePrefix::Home, p)
     ));
-    rule!(absolute_path<(FilePrefix, PathBuf)> as local_raw; children!(
+    rule!(absolute_path<(FilePrefix, PathBuf)> as local; children!(
         [path(p)] => (FilePrefix::Absolute, p)
     ));
 
@@ -435,49 +435,49 @@ make_parser! {
         [http_raw(url)] => url
     ));
 
-    rule!(env_raw<String>; children!(
+    rule!(env<String>; children!(
         [bash_environment_variable(s)] => s,
         [posix_environment_variable(s)] => s,
     ));
     rule!(bash_environment_variable<String>; captured_str!(s) => s.to_owned());
     rule!(posix_environment_variable<String>; captured_str!(s) => s.to_owned());
 
-    rule!(missing_raw<()>; captured_str!(_) => ());
+    rule!(missing<()>; captured_str!(_) => ());
 
     // TODO: other import types
-    rule!(import_type_raw<ImportLocation>; children!(
-        [missing_raw(_)] => {
+    rule!(import_type<ImportLocation>; children!(
+        [missing(_)] => {
             ImportLocation::Missing
         },
-        [env_raw(e)] => {
+        [env(e)] => {
             ImportLocation::Env(e)
         },
         [http(url)] => {
             ImportLocation::Remote(url)
         },
-        [local_raw((prefix, path))] => {
+        [local((prefix, path))] => {
             ImportLocation::Local(prefix, path)
         },
     ));
 
-    rule!(import_hashed_raw<(ImportLocation, Option<()>)>; children!(
+    rule!(import_hashed<(ImportLocation, Option<()>)>; children!(
         // TODO: handle hash
-        [import_type_raw(import)] => (import, None)
+        [import_type(import)] => (import, None)
     ));
 
     rule_group!(expression<ParsedExpr>);
 
     rule!(Text<()>; captured_str!(_) => ());
 
-    rule!(import_raw<ParsedExpr> as expression; children!(
-        [import_hashed_raw((location, hash))] => {
+    rule!(import<ParsedExpr> as expression; children!(
+        [import_hashed((location, hash))] => {
             bx(Expr::Embed(Import {
                 mode: ImportMode::Code,
                 hash,
                 location,
             }))
         },
-        [import_hashed_raw((location, hash)), Text(_)] => {
+        [import_hashed((location, hash)), Text(_)] => {
             bx(Expr::Embed(Import {
                 mode: ImportMode::RawText,
                 hash,
@@ -487,7 +487,7 @@ make_parser! {
     ));
 
     rule!(lambda_expression<ParsedExpr> as expression; children!(
-        [label_raw(l), expression(typ), expression(body)] => {
+        [label(l), expression(typ), expression(body)] => {
             bx(Expr::Lam(l, typ, body))
         }
     ));
@@ -505,12 +505,12 @@ make_parser! {
     ));
 
     rule!(let_binding<(Label, Option<ParsedExpr>, ParsedExpr)>; children!(
-        [label_raw(name), expression(annot), expression(expr)] => (name, Some(annot), expr),
-        [label_raw(name), expression(expr)] => (name, None, expr),
+        [label(name), expression(annot), expression(expr)] => (name, Some(annot), expr),
+        [label(name), expression(expr)] => (name, None, expr),
     ));
 
     rule!(forall_expression<ParsedExpr> as expression; children!(
-        [label_raw(l), expression(typ), expression(body)] => {
+        [label(l), expression(typ), expression(body)] => {
             bx(Expr::Pi(l, typ, body))
         }
     ));
@@ -646,32 +646,32 @@ make_parser! {
         },
     ));
 
-    rule!(selector_expression_raw<ParsedExpr> as expression; children!(
+    rule!(selector_expression<ParsedExpr> as expression; children!(
         [expression(e)] => e,
-        [expression(first), selector_raw(rest..)] => {
+        [expression(first), selector(rest..)] => {
             rest.fold(first, |acc, e| bx(Expr::Field(acc, e)))
         }
     ));
 
     // TODO: handle record projection
-    rule!(selector_raw<Label>; children!(
-        [label_raw(l)] => l
+    rule!(selector<Label>; children!(
+        [label(l)] => l
     ));
 
-    rule!(literal_expression_raw<ParsedExpr> as expression; children!(
-        [double_literal_raw(n)] => bx(Expr::DoubleLit(n)),
+    rule!(literal_expression<ParsedExpr> as expression; children!(
+        [double_literal(n)] => bx(Expr::DoubleLit(n)),
         [minus_infinity_literal(n)] => bx(Expr::DoubleLit(std::f64::NEG_INFINITY.into())),
         [plus_infinity_literal(n)] => bx(Expr::DoubleLit(std::f64::INFINITY.into())),
-        [NaN_raw(n)] => bx(Expr::DoubleLit(std::f64::NAN.into())),
-        [natural_literal_raw(n)] => bx(Expr::NaturalLit(n)),
-        [integer_literal_raw(n)] => bx(Expr::IntegerLit(n)),
+        [NaN(n)] => bx(Expr::DoubleLit(std::f64::NAN.into())),
+        [natural_literal(n)] => bx(Expr::NaturalLit(n)),
+        [integer_literal(n)] => bx(Expr::IntegerLit(n)),
         [double_quote_literal(s)] => bx(Expr::TextLit(s)),
         [single_quote_literal(s)] => bx(Expr::TextLit(s)),
         [expression(e)] => e,
     ));
 
-    rule!(identifier_raw<ParsedExpr> as expression; children!(
-        [label_raw(l), natural_literal_raw(idx)] => {
+    rule!(identifier<ParsedExpr> as expression; children!(
+        [label(l), natural_literal(idx)] => {
             let name = String::from(l.clone());
             match Builtin::parse(name.as_str()) {
                 Some(b) => bx(Expr::Builtin(b)),
@@ -684,7 +684,7 @@ make_parser! {
                 }
             }
         },
-        [label_raw(l)] => {
+        [label(l)] => {
             let name = String::from(l.clone());
             match Builtin::parse(name.as_str()) {
                 Some(b) => bx(Expr::Builtin(b)),
@@ -708,12 +708,12 @@ make_parser! {
     );
 
     rule!(non_empty_record_type_or_literal<ParsedExpr> as expression; children!(
-        [label_raw(first_label), non_empty_record_type(rest)] => {
+        [label(first_label), non_empty_record_type(rest)] => {
             let (first_expr, mut map) = rest;
             map.insert(first_label, first_expr);
             bx(Expr::RecordType(map))
         },
-        [label_raw(first_label), non_empty_record_literal(rest)] => {
+        [label(first_label), non_empty_record_literal(rest)] => {
             let (first_expr, mut map) = rest;
             map.insert(first_label, first_expr);
             bx(Expr::RecordLit(map))
@@ -727,7 +727,7 @@ make_parser! {
     ));
 
     rule!(record_type_entry<(Label, ParsedExpr)>; children!(
-        [label_raw(name), expression(expr)] => (name, expr)
+        [label(name), expression(expr)] => (name, expr)
     ));
 
     rule!(non_empty_record_literal<(ParsedExpr, BTreeMap<Label, ParsedExpr>)>; children!(
@@ -737,7 +737,7 @@ make_parser! {
     ));
 
     rule!(record_literal_entry<(Label, ParsedExpr)>; children!(
-        [label_raw(name), expression(expr)] => (name, expr)
+        [label(name), expression(expr)] => (name, expr)
     ));
 
     rule!(union_type_or_literal<ParsedExpr> as expression; children!(
@@ -756,15 +756,15 @@ make_parser! {
 
     rule!(non_empty_union_type_or_literal
           <(Option<(Label, ParsedExpr)>, BTreeMap<Label, ParsedExpr>)>; children!(
-        [label_raw(l), expression(e), union_type_entries(entries)] => {
+        [label(l), expression(e), union_type_entries(entries)] => {
             (Some((l, e)), entries)
         },
-        [label_raw(l), expression(e), non_empty_union_type_or_literal(rest)] => {
+        [label(l), expression(e), non_empty_union_type_or_literal(rest)] => {
             let (x, mut entries) = rest;
             entries.insert(l, e);
             (x, entries)
         },
-        [label_raw(l), expression(e)] => {
+        [label(l), expression(e)] => {
             let mut entries = BTreeMap::new();
             entries.insert(l, e);
             (None, entries)
@@ -776,10 +776,10 @@ make_parser! {
     ));
 
     rule!(union_type_entry<(Label, ParsedExpr)>; children!(
-        [label_raw(name), expression(expr)] => (name, expr)
+        [label(name), expression(expr)] => (name, expr)
     ));
 
-    rule!(non_empty_list_literal_raw<ParsedExpr> as expression; children!(
+    rule!(non_empty_list_literal<ParsedExpr> as expression; children!(
         [expression(items..)] => bx(Expr::NEListLit(items.collect()))
     ));
 
diff --git a/dhall_parser/build.rs b/dhall_parser/build.rs
index fc398ff..4e75181 100644
--- a/dhall_parser/build.rs
+++ b/dhall_parser/build.rs
@@ -36,15 +36,15 @@ fn main() -> std::io::Result<()> {
     writeln!(
         &mut file,
         "simple_label = {{
-              keyword_raw ~ simple_label_next_char+
-            | !keyword_raw ~ simple_label_first_char ~ simple_label_next_char*
+              keyword ~ simple_label_next_char+
+            | !keyword ~ simple_label_first_char ~ simple_label_next_char*
     }}"
     )?;
     writeln!(
         &mut file,
-        "keyword_raw = _{{
-            let_raw | in_raw | if_raw | then_raw
-                | else_raw | Infinity_raw | NaN_raw
+        "keyword = _{{
+            let_ | in_ | if_ | then
+                | else_ | Infinity | NaN
     }}"
     )?;
     writeln!(
diff --git a/dhall_parser/src/dhall.abnf b/dhall_parser/src/dhall.abnf
index fa403ba..d27554c 100644
--- a/dhall_parser/src/dhall.abnf
+++ b/dhall_parser/src/dhall.abnf
@@ -172,10 +172,10 @@ quoted-label = 1*quoted-label-char
 ; Their list can be found in semantics.md. This is not enforced by the grammar but

 ; should be checked by implementations. The only place where this restriction applies

 ; is bound variables.

-label-raw = ("`" quoted-label "`" / simple-label)

+label = ("`" quoted-label "`" / simple-label)

 

 ; An any-label is allowed to be one of the reserved identifiers.

-any-label-raw = label-raw

+any-label = label

 

 

 ; Dhall's double-quoted strings are equivalent to JSON strings except with

@@ -274,31 +274,30 @@ single-quote-literal = "''" end-of-line single-quote-continue
 ; Interpolation

 interpolation = "${" complete-expression "}"

 

-text-literal-raw = (double-quote-literal / single-quote-literal)

+text-literal = (double-quote-literal / single-quote-literal)

 

 ; RFC 5234 interprets string literals as case-insensitive and recommends using

 ; hex instead for case-sensitive strings

 ;

 ; If you don't feel like reading hex, these are all the same as the rule name,

-; except without the '-raw' ending.

+; except without the '' ending.

 ; Keywords that should never be parsed as identifiers

-if-raw                = %x69.66

-then-raw              = %x74.68.65.6e

-else-raw              = %x65.6c.73.65

-let-raw               = %x6c.65.74

-in-raw                = %x69.6e

-as-raw                = %x61.73

-using-raw             = %x75.73.69.6e.67

-merge-raw             = %x6d.65.72.67.65

-missing-raw           = %x6d.69.73.73.69.6e.67

-Infinity-raw          = %x49.6e.66.69.6e.69.74.79

+if                = %x69.66

+then              = %x74.68.65.6e

+else              = %x65.6c.73.65

+let               = %x6c.65.74

+in                = %x69.6e

+as                = %x61.73

+using             = %x75.73.69.6e.67

+merge             = %x6d.65.72.67.65

+missing           = %x6d.69.73.73.69.6e.67

+Infinity          = %x49.6e.66.69.6e.69.74.79

 ; Reserved identifiers, only needed for some special cases of parsing

 Optional              = %x4f.70.74.69.6f.6e.61.6c

 Text                  = %x54.65.78.74

 List                  = %x4c.69.73.74

-Infinity-raw          = %x49.6e.66.69.6e.69.74.79

-NaN-raw               = %x4e.61.4e

-Some-raw              = %x53.6f.6d.65

+NaN               = %x4e.61.4e

+Some              = %x53.6f.6d.65

 

 combine       = %x2227 / "/\"

 combine-types = %x2A53 / "//\\"

@@ -309,15 +308,15 @@ arrow         = %x2192 / "->"
 

 exponent = "e" [ "+" / "-" ] 1*DIGIT

 

-double-literal-raw = [ "+" / "-" ] 1*DIGIT ( "." 1*DIGIT [ exponent ] / exponent)

+double-literal = [ "+" / "-" ] 1*DIGIT ( "." 1*DIGIT [ exponent ] / exponent)

 

-natural-literal-raw = 1*DIGIT

+natural-literal = 1*DIGIT

 

-integer-literal-raw = ( "+" / "-" ) natural-literal-raw

+integer-literal = ( "+" / "-" ) natural-literal

 

 ; The implementation should recognize reserved names for builtins and treat them as special

 ; values instead of variables.

-identifier-raw = any-label-raw [ whitespace "@" whitespace natural-literal-raw ]

+identifier = any-label [ whitespace "@" whitespace natural-literal ]

 

 ; Printable characters other than " ()[]{}<>/\,"

 ;

@@ -364,7 +363,7 @@ path-component = "/" ( unquoted-path-component / %x22 quoted-path-component %x22
 

 path = 1*path-component

 

-local-raw =

+local =

     parent-path

     / here-path

     / home-path

@@ -444,11 +443,11 @@ sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
 

 http =

     http-raw

-    [ whitespace using-raw nonempty-whitespace (import-hashed-raw / "(" whitespace import-hashed-raw whitespace ")") ]

+    [ whitespace using nonempty-whitespace (import-hashed / "(" whitespace import-hashed whitespace ")") ]

 

 ; Dhall supports unquoted environment variables that are Bash-compliant or

 ; quoted environment variables that are POSIX-compliant

-env-raw = "env:"

+env = "env:"

     ( bash-environment-variable

     / %x22 posix-environment-variable %x22

     )

@@ -510,21 +509,21 @@ posix-environment-variable-character =
         ; %x5C = "\"

     / %x5D-7E

 

-import-type-raw = missing-raw / local-raw / http / env-raw

+import-type = missing / local / http / env

 

-hash-raw = %x73.68.61.32.35.36.3a 64HEXDIG  ; "sha256:XXX...XXX"

+hash = %x73.68.61.32.35.36.3a 64HEXDIG  ; "sha256:XXX...XXX"

 

-import-hashed-raw = import-type-raw [ whitespace hash-raw ]

+import-hashed = import-type [ whitespace hash ]

 

 ; "http://example.com"

 ; "./foo/bar"

 ; "env:FOO"

-import-raw = import-hashed-raw [ whitespace as-raw nonempty-whitespace Text ]

+import = import-hashed [ whitespace as nonempty-whitespace Text ]

 

 ; NOTE: Every rule past this point should only reference rules that end with

 ; whitespace.  This ensures consistent handling of whitespace in the absence of

 ; a separate lexing step.

-; The exception is the rules ending in -raw, which should _not_ end in whitespace.

+; The exception is the rules ending in , which should _not_ end in whitespace.

 ; This is important to avoid the need for sequential backtracking in application-expression.

 

 expression =

@@ -542,33 +541,33 @@ expression =
     / annotated-expression

 

 ; "\(x : a) -> b"

-lambda-expression = lambda whitespace "(" whitespace label-raw whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression

+lambda-expression = lambda whitespace "(" whitespace label whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression

 

 ; "if a then b else c"

-ifthenelse-expression = if-raw nonempty-whitespace expression then-raw nonempty-whitespace expression else-raw nonempty-whitespace expression

+ifthenelse-expression = if nonempty-whitespace expression then nonempty-whitespace expression else nonempty-whitespace expression

 

 ; "let x : t = e1 in e2"

 ; "let x     = e1 in e2"

 ; "let x = e1 let y = e2 in e3"

-let-expression = 1*let-binding in-raw nonempty-whitespace expression

-let-binding = let-raw nonempty-whitespace label-raw whitespace [ ":" nonempty-whitespace expression ] "=" whitespace expression

+let-expression = 1*let-binding in nonempty-whitespace expression

+let-binding = let nonempty-whitespace label whitespace [ ":" nonempty-whitespace expression ] "=" whitespace expression

 

 ; "forall (x : a) -> b"

-forall-expression = forall whitespace "(" whitespace label-raw whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression

+forall-expression = forall whitespace "(" whitespace label whitespace ":" nonempty-whitespace expression ")" whitespace arrow whitespace expression

 

 ; "a -> b"

 arrow-expression = operator-expression arrow whitespace expression

 

 ; "merge e1 e2 : t"

 ; "merge e1 e2"

-merge-expression = merge-raw nonempty-whitespace import-expression import-expression [ ":" nonempty-whitespace application-expression ]

+merge-expression = merge nonempty-whitespace import-expression whitespace import-expression whitespace [ ":" nonempty-whitespace application-expression ]

 

 ; "[]  : List     t"

 ; "[]  : Optional t"

 ; "[x] : Optional t"

 empty-list-or-optional = "[" whitespace (empty-collection / non-empty-optional)

-empty-collection = "]" whitespace ":" nonempty-whitespace (List whitespace / Optional whitespace) import-expression

-non-empty-optional = expression "]" whitespace ":" nonempty-whitespace Optional whitespace import-expression

+empty-collection = "]" whitespace ":" nonempty-whitespace (List whitespace / Optional whitespace) import-expression whitespace

+non-empty-optional = expression "]" whitespace ":" nonempty-whitespace Optional whitespace import-expression whitespace

 

 ; "x : t"

 annotated-expression = operator-expression [ ":" nonempty-whitespace expression ]

@@ -593,12 +592,11 @@ not-equal-expression     = application-expression   *("!=" whitespace     applic
 ; would be ambiguity: `./ab` could be interpreted as "import the file `./ab`",

 ; or "apply the import `./a` to label `b`"

 application-expression =

-    import-expression-raw *(nonempty-whitespace import-expression-raw) whitespace

+    import-expression *(nonempty-whitespace import-expression) whitespace

 

-import-expression = import-expression-raw whitespace

-import-expression-raw =

-      import-raw

-    / selector-expression-raw

+import-expression =

+      import

+    / selector-expression

 

 ; `record.field` extracts one field of a record

 ; `record.{ field0, field1, field2 }` projects out several fields of a record

@@ -607,48 +605,48 @@ import-expression-raw =
 ; can't tell from parsing just the period whether "foo." will become "foo.bar"

 ; (i.e. accessing field `bar` of the record `foo`) or `foo./bar` (i.e. applying

 ; the function `foo` to the relative path `./bar`)

-selector-expression-raw = primitive-expression-raw *(whitespace "." whitespace selector-raw)

+selector-expression = primitive-expression *(whitespace "." whitespace selector)

 

-selector-raw = any-label-raw / labels-raw

+selector = any-label / labels

 

-labels-raw = "{" whitespace [ any-label-raw whitespace *("," whitespace any-label-raw whitespace) ] "}"

+labels = "{" whitespace [ any-label whitespace *("," whitespace any-label whitespace) ] "}"

 

 

-primitive-expression-raw =

-      literal-expression-raw

+primitive-expression =

+      literal-expression

     / "{" whitespace record-type-or-literal "}"

     / "<" whitespace union-type-or-literal ">"

-    / non-empty-list-literal-raw

-    / parenthesized-expression-raw

+    / non-empty-list-literal

+    / parenthesized-expression

 

 ; NOTE: Backtrack when parsing the first three alternatives (i.e. the numeric

 ; literals).  This is because they share leading characters in common

-literal-expression-raw =

+literal-expression =

     ; "2.0"

-      double-literal-raw

+      double-literal

     

     ; "2"

-    / natural-literal-raw

+    / natural-literal

     

     ; "+2"

-    / integer-literal-raw

+    / integer-literal

     

     ; "-Infinity"

     / minus-infinity-literal

     ; "Infinity"

     / plus-infinity-literal

     ; "NaN"

-    / NaN-raw

+    / NaN

     

     ; '"ABC"'

-    / text-literal-raw

+    / text-literal

     

     ; "x"

     ; "x@2"

-    / identifier-raw

+    / identifier

 

-minus-infinity-literal = "-" Infinity-raw

-plus-infinity-literal = Infinity-raw

+minus-infinity-literal = "-" Infinity

+plus-infinity-literal = Infinity

 

 ; "{ foo = 1      , bar = True }"

 ; "{ foo : Integer, bar : Bool }"

@@ -659,11 +657,11 @@ record-type-or-literal =
 empty-record-literal = "=" whitespace

 empty-record-type = ""

 non-empty-record-type-or-literal =

-    any-label-raw whitespace (non-empty-record-literal / non-empty-record-type)

+    any-label whitespace (non-empty-record-literal / non-empty-record-type)

 non-empty-record-type    = ":" nonempty-whitespace expression *("," whitespace record-type-entry)

-record-type-entry = any-label-raw whitespace ":" nonempty-whitespace expression

+record-type-entry = any-label whitespace ":" nonempty-whitespace expression

 non-empty-record-literal = "=" whitespace expression *("," whitespace record-literal-entry)

-record-literal-entry = any-label-raw whitespace "=" whitespace expression

+record-literal-entry = any-label whitespace "=" whitespace expression

 

 ; "< Foo : Integer | Bar : Bool >"

 ; "< Foo : Integer | Bar = True >"

@@ -672,19 +670,19 @@ union-type-or-literal =
     / empty-union-type

 empty-union-type = ""

 non-empty-union-type-or-literal =

-    any-label-raw whitespace

+    any-label whitespace

     ( "=" whitespace expression union-type-entries

     / ":" nonempty-whitespace expression [ "|" whitespace non-empty-union-type-or-literal ]

     )

 union-type-entries = *("|" whitespace union-type-entry)

-union-type-entry = any-label-raw whitespace ":" nonempty-whitespace expression

+union-type-entry = any-label whitespace ":" nonempty-whitespace expression

 

 ; "[1, 2, 3]"

 ; `empty-list-or-optional` handles empty lists

-non-empty-list-literal-raw = "[" whitespace expression *("," whitespace expression) "]"

+non-empty-list-literal = "[" whitespace expression *("," whitespace expression) "]"

 

 ; "( e )"

-parenthesized-expression-raw = "(" whitespace expression ")"

+parenthesized-expression = "(" whitespace expression ")"

 

 

 ; All expressions end with trailing whitespace.  This just adds a final

diff --git a/dhall_parser/src/dhall.pest.visibility b/dhall_parser/src/dhall.pest.visibility
index ae3fa84..ee5ea2b 100644
--- a/dhall_parser/src/dhall.pest.visibility
+++ b/dhall_parser/src/dhall.pest.visibility
@@ -20,27 +20,23 @@ end_of_line
 simple_label
 # quoted_label_char
 quoted_label
-label_raw
-# any_label_raw
+label
+# any_label
 double_quote_chunk
 double_quote_escaped
 double_quote_literal
 single_quote_continue
 single_quote_literal
-# text_literal_raw
-# if_raw
-# then_raw
-# else_raw
-# let_raw
-# in_raw
-# as_raw
-# using_raw
-# merge_raw
-missing_raw
-# Optional_raw
-Text_raw
-# List_raw
-# Infinity_raw
+# text_literal
+# if
+# then
+# else
+# let
+# in
+# as
+# using
+# merge
+missing
 # if_
 # then
 # else_
@@ -49,6 +45,7 @@ Text_raw
 # as_
 # using
 # merge
+# Infinity
 Optional
 Text
 List
@@ -68,16 +65,16 @@ List
 # colon
 # import_alt
 # open_parens
-# close_parens_raw
+# close_parens
 # close_parens
 # open_brace
-# close_brace_raw
+# close_brace
 # close_brace
 # open_bracket
-# close_bracket_raw
+# close_bracket
 # close_bracket
 # open_angle
-# close_angle_raw
+# close_angle
 # close_angle
 # combine
 # combine_types
@@ -86,16 +83,15 @@ List
 # forall
 # arrow
 # exponent
-double_literal_raw
-natural_literal_raw
-integer_literal_raw
-identifier_raw
+double_literal
+natural_literal
+integer_literal
 identifier
 # path_character
 # quoted_path_character
 path_component
 path
-# local_raw
+# local
 scheme
 http_raw
 authority
@@ -117,14 +113,14 @@ fragment
 # unreserved
 # sub_delims
 http
-env_raw
+env
 bash_environment_variable
 posix_environment_variable
 # posix_environment_variable_character
-import_type_raw
-hash_raw
-import_hashed_raw
-import_raw
+import_type
+hash
+import_hashed
+import
 # expression
 lambda_expression
 ifthenelse_expression
@@ -151,14 +147,12 @@ equal_expression
 not_equal_expression
 application_expression
 # atomic_expression
-# atomic_expression_raw
 # import_expression
-# import_expression_raw
-selector_expression_raw
-selector_raw
-labels_raw
-# primitive_expression_raw
-literal_expression_raw
+selector_expression
+selector
+labels
+# primitive_expression
+literal_expression
 # record_type_or_literal
 empty_record_literal
 empty_record_type
@@ -168,6 +162,6 @@ non_empty_record_literal
 union_type_or_literal
 empty_union_type
 non_empty_union_type_or_literal
-non_empty_list_literal_raw
-# parenthesized_expression_raw
+non_empty_list_literal
+# parenthesized_expression
 # complete_expression