peg.ebnf: EBNF: -> : name ( string -- obj ) EBNF{{ ... }} ;

language/peg/ebnf/ebnf-docs.factor

@@ -20,8 +20,8 @@ HELP: EBNF<
     }
 } ;
 
-HELP: EBNF[
+HELP: EBNF{{
-{ $syntax "EBNF[ ...ebnf... EBNF]" }
+{ $syntax "EBNF{{ ...ebnf... }}" }
 { $values { "...ebnf..." "EBNF DSL text" } }
 { $description
     "Creates and calls a quotation that parses a string using the syntax "
@@ -33,7 +33,7 @@ HELP: EBNF[
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"ab\" EBNF[ rule=\"a\" \"b\" EBNF] ."
+       "\"ab\" EBNF{{ rule=\"a\" \"b\" }} ."
        "V{ \"a\" \"b\" }"
     }
 } ;
@@ -67,22 +67,22 @@ ARTICLE: "peg.ebnf.strings" "EBNF Rule: Strings"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"helloworld\" EBNF[ rule=\"hello\" \"world\" EBNF] ."
+       "\"helloworld\" EBNF{{ rule=\"hello\" \"world\" }} ."
        "V{ \"hello\" \"world\" }"
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"AΣ𝄞\" EBNF[ rule='\\x41' '\\u{greek-capital-letter-sigma}' '\\u01D11E' EBNF] ."
+       "\"AΣ𝄞\" EBNF{{ rule='\\x41' '\\u{greek-capital-letter-sigma}' '\\u01D11E' }} ."
        "V{ \"A\" \"Σ\" \"𝄞\" }"
     }
     { $example
        "USING: io peg.ebnf ;"
-       "\"A double quote: \\\"\" EBNF[ rule='A double quote: \"' EBNF] print"
+       "\"A double quote: \\\"\" EBNF{{ rule='A double quote: \"' }} print"
        "A double quote: \""
     }
     { $example
        "USING: io peg.ebnf ;"
-       "\"' and \\\"\" EBNF[ rule=\"' and \\\"\" EBNF] print"
+       "\"' and \\\"\" EBNF{{ rule=\"' and \\\"\" }} print"
        "' and \""
     }
 } ;
@@ -93,7 +93,7 @@ ARTICLE: "peg.ebnf.any" "EBNF Rule: Any"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"abc\" EBNF[ rule=\"a\" . \"c\" EBNF] ."
+       "\"abc\" EBNF{{ rule=\"a\" . \"c\" }} ."
        "V{ \"a\" 98 \"c\" }"
     }
 } ;
@@ -106,7 +106,7 @@ ARTICLE: "peg.ebnf.sequence" "EBNF Rule: Sequence"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"abbba\" EBNF[ rule=\"a\" (\"b\")* \"a\" EBNF] ."
+       "\"abbba\" EBNF{{ rule=\"a\" (\"b\")* \"a\" }} ."
        "V{ \"a\" V{ \"b\" \"b\" \"b\" } \"a\" }"
     }
 }
@@ -123,12 +123,12 @@ $nl
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"abcca\" EBNF[ rule=\"a\" (\"b\" | \"c\")* \"a\" EBNF] ."
+       "\"abcca\" EBNF{{ rule=\"a\" (\"b\" | \"c\")* \"a\" }} ."
        "V{ \"a\" V{ \"b\" \"c\" \"c\" } \"a\" }"
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"ab  c\nd \" EBNF[ rule={\"a\" \"b\" \"c\" \"d\"} EBNF] ."
+       "\"ab  c\nd \" EBNF{{ rule={\"a\" \"b\" \"c\" \"d\"} }} ."
        "V{ \"a\" \"b\" \"c\" \"d\" }"
     }
 }
@@ -141,17 +141,17 @@ ARTICLE: "peg.ebnf.choice" "EBNF Rule: Choice"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"a\" EBNF[ rule=\"a\" | \"b\" | \"c\" EBNF] ."
+       "\"a\" EBNF{{ rule=\"a\" | \"b\" | \"c\" }} ."
        "\"a\""
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"b\" EBNF[ rule=\"a\" | \"b\" | \"c\" EBNF] ."
+       "\"b\" EBNF{{ rule=\"a\" | \"b\" | \"c\" }} ."
        "\"b\""
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"d\" EBNF[ rule=\"a\" | \"b\" | \"c\" EBNF] ."
+       "\"d\" EBNF{{ rule=\"a\" | \"b\" | \"c\" }} ."
        "Peg parsing error at character position 0.\nExpected 'a' or 'b' or 'c'\nGot 'd'"
     }
 }
@@ -164,7 +164,7 @@ ARTICLE: "peg.ebnf.ignore" "EBNF Rule: Ignore"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"abc\" EBNF[ rule=\"a\" \"b\"~ \"c\" EBNF] ."
+       "\"abc\" EBNF{{ rule=\"a\" \"b\"~ \"c\" }} ."
        "V{ \"a\" \"c\" }"
     }
 }
@@ -177,12 +177,12 @@ ARTICLE: "peg.ebnf.option" "EBNF Rule: Option"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"abc\" EBNF[ rule=\"a\" \"b\"? \"c\" EBNF] ."
+       "\"abc\" EBNF{{ rule=\"a\" \"b\"? \"c\" }} ."
        "V{ \"a\" \"b\" \"c\" }"
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"ac\" EBNF[ rule=\"a\" \"b\"? \"c\" EBNF] ."
+       "\"ac\" EBNF{{ rule=\"a\" \"b\"? \"c\" }} ."
        "V{ \"a\" f \"c\" }"
     }
 }
@@ -198,7 +198,7 @@ ARTICLE: "peg.ebnf.character-class" "EBNF Rule: Character Class"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"123\" EBNF[ rule=[0-9]+ EBNF] ."
+       "\"123\" EBNF{{ rule=[0-9]+ }} ."
        "V{ 49 50 51 }"
     }
 }
@@ -211,7 +211,7 @@ ARTICLE: "peg.ebnf.one-or-more" "EBNF Rule: One or more"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"aab\" EBNF[ rule=\"a\"+ \"b\" EBNF] ."
+       "\"aab\" EBNF{{ rule=\"a\"+ \"b\" }} ."
        "V{ V{ \"a\" \"a\" } \"b\" }"
     }
 }
@@ -224,12 +224,12 @@ ARTICLE: "peg.ebnf.zero-or-more" "EBNF Rule: Zero or more"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"aab\" EBNF[ rule=\"a\"* \"b\" EBNF] ."
+       "\"aab\" EBNF{{ rule=\"a\"* \"b\" }} ."
        "V{ V{ \"a\" \"a\" } \"b\" }"
     }
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"b\" EBNF[ rule=\"a\"* \"b\" EBNF] ."
+       "\"b\" EBNF{{ rule=\"a\"* \"b\" }} ."
        "V{ V{ } \"b\" }"
     }
 }
@@ -245,7 +245,7 @@ ARTICLE: "peg.ebnf.and" "EBNF Rule: And"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"ab\" EBNF[ rule=&(\"a\") \"a\" \"b\" EBNF] ."
+       "\"ab\" EBNF{{ rule=&(\"a\") \"a\" \"b\" }} ."
        "V{ \"a\" \"b\" }"
     }
 }
@@ -261,7 +261,7 @@ ARTICLE: "peg.ebnf.not" "EBNF Rule: Not"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf ;"
-       "\"<abcd>\" EBNF[ rule=\"<\" (!(\">\") .)* \">\" EBNF] ."
+       "\"<abcd>\" EBNF{{ rule=\"<\" (!(\">\") .)* \">\" }} ."
        "V{ \"<\" V{ 97 98 99 100 } \">\" }"
     }
 }
@@ -282,12 +282,12 @@ ARTICLE: "peg.ebnf.action" "EBNF Action"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf strings ;"
-       "\"<abcd>\" EBNF[ rule=\"<\" ((!(\">\") .)* => [[ >string ]]) \">\" EBNF] ."
+       "\"<abcd>\" EBNF{{ rule=\"<\" ((!(\">\") .)* => [[ >string ]]) \">\" }} ."
        "V{ \"<\" \"abcd\" \">\" }"
     }
     { $example
        "USING: prettyprint peg.ebnf math.parser ;"
-       "\"123\" EBNF[ rule=[0-9]+ => [[ string>number ]] EBNF] ."
+       "\"123\" EBNF{{ rule=[0-9]+ => [[ string>number ]] }} ."
        "123"
     }
 }
@@ -302,12 +302,12 @@ ARTICLE: "peg.ebnf.semantic-action" "EBNF Semantic Action"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf math math.parser ;"
-       "\"1\" EBNF[ rule=[0-9] ?[ digit> odd? ]? EBNF] ."
+       "\"1\" EBNF{{ rule=[0-9] ?[ digit> odd? ]? }} ."
        "49"
     }
     { $example
        "USING: prettyprint peg.ebnf math math.parser ;"
-       "\"2\" EBNF[ rule=[0-9] ?[ digit> odd? ]? EBNF] ."
+       "\"2\" EBNF{{ rule=[0-9] ?[ digit> odd? ]? }} ."
        "Peg parsing error at character position 0.\nExpected \nGot '2'"
     }
 }
@@ -320,7 +320,7 @@ ARTICLE: "peg.ebnf.variable" "EBNF Variable"
 { $examples
     { $example
        "USING: prettyprint peg.ebnf math.parser ;"
-       "\"1+2\" EBNF[ rule=[0-9]:a \"+\" [0-9]:b => [[ a digit> b digit> + ]] EBNF] ."
+       "\"1+2\" EBNF{{ rule=[0-9]:a \"+\" [0-9]:b => [[ a digit> b digit> + ]] }} ."
        "3"
     }
 }
@@ -490,7 +490,7 @@ ARTICLE: "peg.ebnf" "EBNF"
 "accept the same EBNF syntax. The difference is in how they are used. "
 { $subsections
     \ EBNF<
-    \ EBNF[
+    \ EBNF{{
     \ EBNF:
 }
 "The EBNF syntax is composed of a series of rules of the form:"

language/peg/ebnf/ebnf-tests.factor

@@ -145,142 +145,142 @@ in: peg.ebnf.tests
 ] unit-test
 
 { V{ "a" "b" } } [
-  "ab" EBNF[ foo='a' 'b' EBNF]
+  "ab" EBNF{{ foo='a' 'b' }}
 ] unit-test
 
 { V{ 1 "b" } } [
-  "ab" EBNF[ foo=('a')[[ drop 1 ]] 'b' EBNF]
+  "ab" EBNF{{ foo=('a')[[ drop 1 ]] 'b' }}
 ] unit-test
 
 { V{ 1 2 } } [
-  "ab" EBNF[ foo=('a') [[ drop 1 ]] ('b') [[ drop 2 ]] EBNF]
+  "ab" EBNF{{ foo=('a') [[ drop 1 ]] ('b') [[ drop 2 ]] }}
 ] unit-test
 
 { char: A } [
-  "A" EBNF[ foo=[A-Z] EBNF]
+  "A" EBNF{{ foo=[A-Z] }}
 ] unit-test
 
 { char: Z } [
-  "Z" EBNF[ foo=[A-Z] EBNF]
+  "Z" EBNF{{ foo=[A-Z] }}
 ] unit-test
 
 [
-  "0" EBNF[ foo=[A-Z] EBNF]
+  "0" EBNF{{ foo=[A-Z] }}
 ] must-fail
 
 { char: 0 } [
-  "0" EBNF[ foo=[^A-Z] EBNF]
+  "0" EBNF{{ foo=[^A-Z] }}
 ] unit-test
 
 [
-  "A" EBNF[ foo=[^A-Z] EBNF]
+  "A" EBNF{{ foo=[^A-Z] }}
 ] must-fail
 
 [
-  "Z" EBNF[ foo=[^A-Z] EBNF]
+  "Z" EBNF{{ foo=[^A-Z] }}
 ] must-fail
 
 { V{ "1" "+" "foo" } } [
-  "1+1" EBNF[ foo='1' '+' '1' [[ drop "foo" ]] EBNF]
+  "1+1" EBNF{{ foo='1' '+' '1' [[ drop "foo" ]] }}
 ] unit-test
 
 { "foo" } [
-  "1+1" EBNF[ foo='1' '+' '1' => [[ drop "foo" ]] EBNF]
+  "1+1" EBNF{{ foo='1' '+' '1' => [[ drop "foo" ]] }}
 ] unit-test
 
 { "foo" } [
-  "1+1" EBNF[ foo='1' '+' '1' => [[ drop "foo" ]] | '1' '-' '1' => [[ drop "bar" ]] EBNF]
+  "1+1" EBNF{{ foo='1' '+' '1' => [[ drop "foo" ]] | '1' '-' '1' => [[ drop "bar" ]] }}
 ] unit-test
 
 { "bar" } [
-  "1-1" EBNF[ foo='1' '+' '1' => [[ drop "foo" ]] | '1' '-' '1' => [[ drop "bar" ]] EBNF]
+  "1-1" EBNF{{ foo='1' '+' '1' => [[ drop "foo" ]] | '1' '-' '1' => [[ drop "bar" ]] }}
 ] unit-test
 
 { 6 } [
-  "4+2" EBNF[ num=[0-9] => [[ digit> ]] foo=num:x '+' num:y => [[ x y + ]] EBNF]
+  "4+2" EBNF{{ num=[0-9] => [[ digit> ]] foo=num:x '+' num:y => [[ x y + ]] }}
 ] unit-test
 
 { 6 } [
-  "4+2" EBNF[ foo=[0-9]:x '+' [0-9]:y => [[ x digit> y digit> + ]] EBNF]
+  "4+2" EBNF{{ foo=[0-9]:x '+' [0-9]:y => [[ x digit> y digit> + ]] }}
 ] unit-test
 
 { 10 } [
-  { 1 2 3 4 } EBNF[ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num EBNF]
+  { 1 2 3 4 } EBNF{{ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num }}
 ] unit-test
 
 [
-  { "a" 2 3 4 } EBNF[ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num EBNF]
+  { "a" 2 3 4 } EBNF{{ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num }}
 ] must-fail
 
 { 3 } [
-  { 1 2 "a" 4 } EBNF[ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num EBNF]
+  { 1 2 "a" 4 } EBNF{{ num=. ?[ number? ]? list=list:x num:y => [[ x y + ]] | num }}
 ] unit-test
 
 [
-  "ab" EBNF[ -=" " | "\t" | "\n" foo="a" - "b" EBNF]
+  "ab" EBNF{{ -=" " | "\t" | "\n" foo="a" - "b" }}
 ] must-fail
 
 { V{ "a" " " "b" } } [
-  "a b" EBNF[ -=" " | "\t" | "\n" foo="a" - "b" EBNF]
+  "a b" EBNF{{ -=" " | "\t" | "\n" foo="a" - "b" }}
 ] unit-test
 
 { V{ "a" "\t" "b" } } [
-  "a\tb" EBNF[ -=" " | "\t" | "\n" foo="a" - "b" EBNF]
+  "a\tb" EBNF{{ -=" " | "\t" | "\n" foo="a" - "b" }}
 ] unit-test
 
 { V{ "a" "\n" "b" } } [
-  "a\nb" EBNF[ -=" " | "\t" | "\n" foo="a" - "b" EBNF]
+  "a\nb" EBNF{{ -=" " | "\t" | "\n" foo="a" - "b" }}
 ] unit-test
 
 { V{ "a" f "b" } } [
-  "ab" EBNF[ -=" " | "\t" | "\n" foo="a" (-)? "b" EBNF]
+  "ab" EBNF{{ -=" " | "\t" | "\n" foo="a" (-)? "b" }}
 ] unit-test
 
 { V{ "a" " " "b" } } [
-  "a b" EBNF[ -=" " | "\t" | "\n" foo="a" (-)? "b" EBNF]
+  "a b" EBNF{{ -=" " | "\t" | "\n" foo="a" (-)? "b" }}
 ] unit-test
 
 
 { V{ "a" "\t" "b" } } [
-  "a\tb" EBNF[ -=" " | "\t" | "\n" foo="a" (-)? "b" EBNF]
+  "a\tb" EBNF{{ -=" " | "\t" | "\n" foo="a" (-)? "b" }}
 ] unit-test
 
 { V{ "a" "\n" "b" } } [
-  "a\nb" EBNF[ -=" " | "\t" | "\n" foo="a" (-)? "b" EBNF]
+  "a\nb" EBNF{{ -=" " | "\t" | "\n" foo="a" (-)? "b" }}
 ] unit-test
 
 { V{ "a" "b" } } [
-  "ab" EBNF[ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" EBNF]
+  "ab" EBNF{{ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" }}
 ] unit-test
 
 { V{ "a" "b" } } [
-  "a\tb" EBNF[ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" EBNF]
+  "a\tb" EBNF{{ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" }}
 ] unit-test
 
 { V{ "a" "b" } } [
-  "a\nb" EBNF[ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" EBNF]
+  "a\nb" EBNF{{ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" }}
 ] unit-test
 
 [
-  "axb" EBNF[ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" EBNF]
+  "axb" EBNF{{ -=(" " | "\t" | "\n")? => [[ drop ignore ]] foo="a" - "b" }}
 ] must-fail
 
 { V{ V{ 49 } "+" V{ 49 } } } [
   ! Test direct left recursion.
   ! Using packrat, so first part of expr fails, causing 2nd choice to be used
-  "1+1" EBNF[ num=([0-9])+ expr=expr "+" num | num EBNF]
+  "1+1" EBNF{{ num=([0-9])+ expr=expr "+" num | num }}
 ] unit-test
 
 { V{ V{ V{ 49 } "+" V{ 49 } } "+" V{ 49 } } } [
   ! Test direct left recursion.
   ! Using packrat, so first part of expr fails, causing 2nd choice to be used
-  "1+1+1" EBNF[ num=([0-9])+ expr=expr "+" num | num EBNF]
+  "1+1+1" EBNF{{ num=([0-9])+ expr=expr "+" num | num }}
 ] unit-test
 
 { V{ V{ V{ 49 } "+" V{ 49 } } "+" V{ 49 } } } [
   ! Test indirect left recursion.
   ! Using packrat, so first part of expr fails, causing 2nd choice to be used
-  "1+1+1" EBNF[ num=([0-9])+ x=expr expr=x "+" num | num EBNF]
+  "1+1+1" EBNF{{ num=([0-9])+ x=expr expr=x "+" num | num }}
 ] unit-test
 
 { t } [
@@ -333,113 +333,113 @@ EBNF;
 ] unit-test
 
 { V{ V{ "a" "b" } "c" } } [
-  "abc" EBNF[ a="a" "b" foo=(a "c") EBNF]
+  "abc" EBNF{{ a="a" "b" foo=(a "c") }}
 ] unit-test
 
 { V{ "a" "c" } } [
-  "abc" EBNF[ a="a" "b"~ foo=(a "c") EBNF]
+  "abc" EBNF{{ a="a" "b"~ foo=(a "c") }}
 ] unit-test
 
 { V{ V{ "a" V{ "b" "b" } } "c" } } [
-  "abbc" EBNF[ a=("a" "b"*) foo=(a "c") EBNF]
+  "abbc" EBNF{{ a=("a" "b"*) foo=(a "c") }}
 ] unit-test
 
 { V{ "a" "c" } } [
-  "abc" EBNF[ a=("a" ("b")~) foo=(a "c") EBNF]
+  "abc" EBNF{{ a=("a" ("b")~) foo=(a "c") }}
 ] unit-test
 
 { V{ "a" "c" } } [
-  "abc" EBNF[ a=("a" "b"~) foo=(a "c") EBNF]
+  "abc" EBNF{{ a=("a" "b"~) foo=(a "c") }}
 ] unit-test
 
 { "c" } [
-  "abc" EBNF[ a=("a" "b")~ foo=(a "c") EBNF]
+  "abc" EBNF{{ a=("a" "b")~ foo=(a "c") }}
 ] unit-test
 
 { V{ V{ "a" "b" } "c" } } [
-  "abc" EBNF[ a="a" "b" foo={a "c"} EBNF]
+  "abc" EBNF{{ a="a" "b" foo={a "c"} }}
 ] unit-test
 
 { V{ V{ "a" "b" } "c" } } [
-  "abc" EBNF[ a="a" "b" foo=a "c" EBNF]
+  "abc" EBNF{{ a="a" "b" foo=a "c" }}
 ] unit-test
 
 [
-  "a bc" EBNF[ a="a" "b" foo=(a "c") EBNF]
+  "a bc" EBNF{{ a="a" "b" foo=(a "c") }}
 ] must-fail
 
 [
-  "a bc" EBNF[ a="a" "b" foo=a "c" EBNF]
+  "a bc" EBNF{{ a="a" "b" foo=a "c" }}
 ] must-fail
 
 [
-  "a bc" EBNF[ a="a" "b" foo={a "c"} EBNF]
+  "a bc" EBNF{{ a="a" "b" foo={a "c"} }}
 ] must-fail
 
 [
-  "ab c" EBNF[ a="a" "b" foo=a "c" EBNF]
+  "ab c" EBNF{{ a="a" "b" foo=a "c" }}
 ] must-fail
 
 { V{ V{ "a" "b" } "c" } } [
-  "ab c" EBNF[ a="a" "b" foo={a "c"} EBNF]
+  "ab c" EBNF{{ a="a" "b" foo={a "c"} }}
 ] unit-test
 
 [
-  "ab c" EBNF[ a="a" "b" foo=(a "c") EBNF]
+  "ab c" EBNF{{ a="a" "b" foo=(a "c") }}
 ] must-fail
 
 [
-  "a b c" EBNF[ a="a" "b" foo=a "c" EBNF]
+  "a b c" EBNF{{ a="a" "b" foo=a "c" }}
 ] must-fail
 
 [
-  "a b c" EBNF[ a="a" "b" foo=(a "c") EBNF]
+  "a b c" EBNF{{ a="a" "b" foo=(a "c") }}
 ] must-fail
 
 [
-  "a b c" EBNF[ a="a" "b" foo={a "c"} EBNF]
+  "a b c" EBNF{{ a="a" "b" foo={a "c"} }}
 ] must-fail
 
 { V{ V{ V{ "a" "b" } "c" } V{ V{ "a" "b" } "c" } } } [
-  "ab cab c" EBNF[ a="a" "b" foo={a "c"}* EBNF]
+  "ab cab c" EBNF{{ a="a" "b" foo={a "c"}* }}
 ] unit-test
 
 { V{ } } [
-  "ab cab c" EBNF[ a="a" "b" foo=(a "c")* EBNF]
+  "ab cab c" EBNF{{ a="a" "b" foo=(a "c")* }}
 ] unit-test
 
 { V{ V{ V{ "a" "b" } "c" } V{ V{ "a" "b" } "c" } } } [
-  "ab c ab c" EBNF[ a="a" "b" foo={a "c"}* EBNF]
+  "ab c ab c" EBNF{{ a="a" "b" foo={a "c"}* }}
 ] unit-test
 
 { V{ V{ "a" "c" } V{ "a" "c" } } } [
-  "ab c ab c" EBNF[ a="a" "b"~ foo={a "c"}* EBNF]
+  "ab c ab c" EBNF{{ a="a" "b"~ foo={a "c"}* }}
 ] unit-test
 
 { V{ } } [
-  "ab c ab c" EBNF[ a="a" "b" foo=(a "c")* EBNF]
+  "ab c ab c" EBNF{{ a="a" "b" foo=(a "c")* }}
 ] unit-test
 
 { V{ } } [
-  "ab c ab c" EBNF[ a="a" "b" foo=(a "c")* EBNF]
+  "ab c ab c" EBNF{{ a="a" "b" foo=(a "c")* }}
 ] unit-test
 
 { V{ "a" "a" "a" } } [
-  "aaa" EBNF[ a=('a')* b=!('b') a:x => [[ x ]] EBNF]
+  "aaa" EBNF{{ a=('a')* b=!('b') a:x => [[ x ]] }}
 ] unit-test
 
 { t } [
-  "aaa" EBNF[ a=('a')* b=!('b') a:x => [[ x ]] EBNF]
+  "aaa" EBNF{{ a=('a')* b=!('b') a:x => [[ x ]] }}
-  "aaa" EBNF[ a=('a')* b=!('b') (a):x => [[ x ]] EBNF] =
+  "aaa" EBNF{{ a=('a')* b=!('b') (a):x => [[ x ]] }} =
 ] unit-test
 
 { V{ "a" "a" "a" } } [
-  "aaa" EBNF[ a=('a')* b=a:x => [[ x ]] EBNF]
+  "aaa" EBNF{{ a=('a')* b=a:x => [[ x ]] }}
 ] unit-test
 
 { t } [
-  "aaa" EBNF[ a=('a')* b=a:x => [[ x ]] EBNF]
+  "aaa" EBNF{{ a=('a')* b=a:x => [[ x ]] }}
-  "aaa" EBNF[ a=('a')* b=(a):x => [[ x ]] EBNF] =
+  "aaa" EBNF{{ a=('a')* b=(a):x => [[ x ]] }} =
 ] unit-test
 
 { t } [
@@ -503,7 +503,7 @@ EBNF;
 ] unit-test
 
 { } [
- "USING: kernel peg.ebnf ; \"a\\n\" EBNF[ foo='a' '\n'  => [[ drop \"\n\" ]] EBNF] drop" eval( -- )
+ "USING: kernel peg.ebnf ; \"a\\n\" EBNF{{ foo='a' '\n'  => [[ drop \"\n\" ]] }} drop" eval( -- )
 ] unit-test
 
 [
@@ -518,7 +518,7 @@ EBNF;
 
 ! Tokenizer tests
 { V{ "a" char: b } } [
-  "ab" EBNF[ tokenizer=default foo="a" . EBNF]
+  "ab" EBNF{{ tokenizer=default foo="a" . }}
 ] unit-test
 
 TUPLE: ast-number value ;
@@ -542,49 +542,49 @@ Tok                = Spaces (Number | Special )
 EBNF;
 
 { V{ char: 1 T{ ast-number f 23 } ";" char: x } } [
-  "123;x" EBNF[ bar = .
+  "123;x" EBNF{{ bar = .
                 tokenizer = <foreign a-tokenizer Tok>  foo=.
                 tokenizer=default baz=.
                 main = bar foo foo baz
-          EBNF]
+          }}
 ] unit-test
 
 { V{ char: 5 "+" char: 2 } } [
-  "5+2" EBNF[
+  "5+2" EBNF{{
           space=(" " | "\n")
           number=[0-9]
           operator=("*" | "+")
           spaces=space* => [[ ignore ]]
           tokenizer=spaces (number | operator)
           main= . . .
-        EBNF]
+        }}
 ] unit-test
 
 { V{ char: 5 "+" char: 2 } } [
-  "5 + 2" EBNF[
+  "5 + 2" EBNF{{
           space=(" " | "\n")
           number=[0-9]
           operator=("*" | "+")
           spaces=space* => [[ ignore ]]
           tokenizer=spaces (number | operator)
           main= . . .
-        EBNF]
+        }}
 ] unit-test
 
 { "++" } [
-  "++--" EBNF[ tokenizer=("++" | "--") main="++" EBNF]
+  "++--" EBNF{{ tokenizer=("++" | "--") main="++" }}
 ] unit-test
 
 { "\\" } [
-  "\\" EBNF[ foo="\\" EBNF]
+  "\\" EBNF{{ foo="\\" }}
 ] unit-test
 
-[ "use: peg.ebnf EBNF[ EBNF]" eval( -- ) ] must-fail
+[ "use: peg.ebnf EBNF{{ }}" eval( -- ) ] must-fail
 
-[ "use: peg.ebnf EBNF[
+[ "use: peg.ebnf EBNF{{
     lol = a
     lol = b
-  EBNF]" eval( -- )
+  }}" eval( -- )
 ] [
     error>> [ redefined-rule? ] [ name>> "lol" = ] bi and
 ] must-fail-with

language/peg/ebnf/ebnf.factor

@@ -542,8 +542,8 @@ SYNTAX: \ EBNF<
     reset-tokenizer parse-multiline-string parse-ebnf main of
     suffix! reset-tokenizer ;
 
-SYNTAX: \ EBNF[
+SYNTAX: \ EBNF{{
-    "EBNF]"
+    "}}"
     reset-tokenizer parse-multiline-string ebnf>quot nip
     suffix! \ call suffix! reset-tokenizer ;
 

libs/brainfuck/brainfuck.factor

@@ -49,7 +49,7 @@ TUPLE: brainfuck pointer memory ;
 : compose-all ( seq -- quot )
     [ ] [ compose ] reduce ;
 
-EBNF: parse-brainfuck
+: parse-brainfuck ( string -- obj ) EBNF{{
 
 inc-ptr  = (">")+  => [[ length '[ _ (>) ] ]]
 dec-ptr  = ("<")+  => [[ length '[ _ (<) ] ]]
@@ -66,7 +66,7 @@ loop  = "[" {loop|ops}+ "]" => [[ second compose-all '[ [ (?) ] _ while ] ]]
 
 code  = (loop|ops|unknown)*  => [[ compose-all ]]
 
-EBNF;
+}} ;
 
 PRIVATE>
 

libs/svg/svg.factor

@@ -16,7 +16,8 @@ XML-NS: inkscape-name http://www.inkscape.org/namespaces/inkscape ;
 
 : degrees ( deg -- rad ) pi * 180.0 / ;
 
-EBNF: svg-transform>affine-transform
+: svg-transform>affine-transform ( string -- obj )
+    EBNF{{
 
 transforms =
     transform:m comma-wsp+ transforms:n => [[ m n a. ]]
@@ -76,7 +77,7 @@ wsp = [ \t\r\n]
 transform-list = wsp* transforms?:t wsp*
     => [[ t [ identity-transform ] unless* ]]
 
-EBNF;
+}} ;
 
 : tag-transform ( tag -- transform )
     "transform" svg-name attr svg-transform>affine-transform ;

libs/urls/urls-tests.factor

@@ -89,7 +89,7 @@ CONSTANT: urls
             }
             "http://foo.com/?a"
         }
-    }
+    } ;
 
 urls [
     [ 1array ] [ [ >url ] curry ] bi* unit-test

libs/urls/urls.factor

@@ -35,7 +35,7 @@ M: url >url ;
 
 <PRIVATE
 
-EBNF: parse-url
+: parse-url ( string -- obj ) EBNF{{
 
 protocol = [a-z+]+                  => [[ url-decode ]]
 username = [^/:@#?]+                => [[ url-decode ]]
@@ -57,7 +57,7 @@ url      = (((protocol "://") => [[ first ]] auth hostname)
            ("?" query               => [[ second ]])?
            ("#" anchor              => [[ second ]])?
 
-EBNF;
+}} ;
 
 PRIVATE>