docs(lpeg): merge upstream changes

1 files changed, 37 insertions, 37 deletions

diff --git a/runtime/doc/lua.txt b/runtime/doc/lua.txt
index f56d7f778a..2b269f7d9c 100644
--- a/runtime/doc/lua.txt
+++ b/runtime/doc/lua.txt
@@ -3035,10 +3035,10 @@ Pattern:match({subject}, {init})                             *Pattern:match()*
     pattern that matches anywhere.
 
     Example: >lua
-        local pattern = lpeg.R("az") ^ 1 * -1
-        assert(pattern:match("hello") == 6)
-        assert(lpeg.match(pattern, "hello") == 6)
-        assert(pattern:match("1 hello") == nil)
+        local pattern = lpeg.R('az') ^ 1 * -1
+        assert(pattern:match('hello') == 6)
+        assert(lpeg.match(pattern, 'hello') == 6)
+        assert(pattern:match('1 hello') == nil)
 <
 
     Parameters: ~
@@ -3051,7 +3051,7 @@ Pattern:match({subject}, {init})                             *Pattern:match()*
 vim.lpeg.B({pattern})                                           *vim.lpeg.B()*
     Returns a pattern that matches only if the input string at the current
     position is preceded by `patt`. Pattern `patt` must match only strings
-    with some fixed length, and it cannot contain captures. Like the and
+    with some fixed length, and it cannot contain captures. Like the `and`
     predicate, this pattern never consumes any input, independently of success
     or failure.
 
@@ -3069,8 +3069,8 @@ vim.lpeg.C({patt})                                              *vim.lpeg.C()*
     Example: >lua
         local function split (s, sep)
           sep = lpeg.P(sep)
-          local elem = lpeg.C((1 - sep)^0)
-          local p = elem * (sep * elem)^0
+          local elem = lpeg.C((1 - sep) ^ 0)
+          local p = elem * (sep * elem) ^ 0
           return lpeg.match(p, s)
         end
         local a, b, c = split('a,b,c', ',')
@@ -3137,11 +3137,11 @@ vim.lpeg.Cf({patt}, {func})                                    *vim.lpeg.Cf()*
     final value of the accumulator becomes the captured value.
 
     Example: >lua
-        local number = lpeg.R("09") ^ 1 / tonumber
-        local list = number * ("," * number) ^ 0
+        local number = lpeg.R('09') ^ 1 / tonumber
+        local list = number * (',' * number) ^ 0
         local function add(acc, newvalue) return acc + newvalue end
         local sum = lpeg.Cf(list, add)
-        assert(sum:match("10,30,43") == 83)
+        assert(sum:match('10,30,43') == 83)
 <
 
     Parameters: ~
@@ -3172,12 +3172,12 @@ vim.lpeg.Cmt({patt}, {fn})                                    *vim.lpeg.Cmt()*
     `patt`), plus any capture values produced by `patt`. The first value
     returned by `function` defines how the match happens. If the call returns
     a number, the match succeeds and the returned number becomes the new
-    current position. (Assuming a subject sand current position i, the
-    returned number must be in the range [i, len(s) + 1].) If the call returns
-    true, the match succeeds without consuming any input (so, to return true
-    is equivalent to return i). If the call returns false, nil, or no value,
-    the match fails. Any extra values returned by the function become the
-    values produced by the capture.
+    current position. (Assuming a subject sand current position `i`, the
+    returned number must be in the range `[i, len(s) + 1]`.) If the call
+    returns `true`, the match succeeds without consuming any input (so, to
+    return true is equivalent to return `i`). If the call returns `false`,
+    `nil`, or no value, the match fails. Any extra values returned by the
+    function become the values produced by the capture.
 
     Parameters: ~
       • {patt}  (`vim.lpeg.Pattern`)
@@ -3194,7 +3194,7 @@ vim.lpeg.Cp()                                                  *vim.lpeg.Cp()*
     Example: >lua
         local I = lpeg.Cp()
         local function anywhere(p) return lpeg.P({I * p * I + 1 * lpeg.V(1)}) end
-        local match_start, match_end = anywhere("world"):match("hello world!")
+        local match_start, match_end = anywhere('world'):match('hello world!')
         assert(match_start == 7)
         assert(match_end == 12)
 <
@@ -3213,7 +3213,7 @@ vim.lpeg.Cs({patt})                                            *vim.lpeg.Cs()*
     Example: >lua
         local function gsub (s, patt, repl)
           patt = lpeg.P(patt)
-          patt = lpeg.Cs((patt / repl + 1)^0)
+          patt = lpeg.Cs((patt / repl + 1) ^ 0)
           return lpeg.match(patt, s)
         end
         assert(gsub('Hello, xxx!', 'xxx', 'World') == 'Hello, World!')
@@ -3249,12 +3249,12 @@ vim.lpeg.locale({tab})                                     *vim.lpeg.locale()*
 
     Example: >lua
         lpeg.locale(lpeg)
-        local space = lpeg.space^0
-        local name = lpeg.C(lpeg.alpha^1) * space
-        local sep = lpeg.S(",;") * space
-        local pair = lpeg.Cg(name * "=" * space * name) * sep^-1
-        local list = lpeg.Cf(lpeg.Ct("") * pair^0, rawset)
-        local t = list:match("a=b, c = hi; next = pi")
+        local space = lpeg.space ^ 0
+        local name = lpeg.C(lpeg.alpha ^ 1) * space
+        local sep = lpeg.S(',;') * space
+        local pair = lpeg.Cg(name * '=' * space * name) * sep ^ -1
+        local list = lpeg.Cf(lpeg.Ct('') * pair ^ 0, rawset)
+        local t = list:match('a=b, c = hi; next = pi')
         assert(t.a == 'b')
         assert(t.c == 'hi')
         assert(t.next == 'pi')
@@ -3282,10 +3282,10 @@ vim.lpeg.match({pattern}, {subject}, {init})                *vim.lpeg.match()*
     pattern that matches anywhere.
 
     Example: >lua
-        local pattern = lpeg.R("az") ^ 1 * -1
-        assert(pattern:match("hello") == 6)
-        assert(lpeg.match(pattern, "hello") == 6)
-        assert(pattern:match("1 hello") == nil)
+        local pattern = lpeg.R('az') ^ 1 * -1
+        assert(pattern:match('hello') == 6)
+        assert(lpeg.match(pattern, 'hello') == 6)
+        assert(pattern:match('1 hello') == nil)
 <
 
     Parameters: ~
@@ -3297,7 +3297,7 @@ vim.lpeg.match({pattern}, {subject}, {init})                *vim.lpeg.match()*
         (`integer|vim.lpeg.Capture?`)
 
 vim.lpeg.P({value})                                             *vim.lpeg.P()*
-    Converts the given value into a proper pattern. This following rules are
+    Converts the given value into a proper pattern. The following rules are
     applied:
     • If the argument is a pattern, it is returned unmodified.
     • If the argument is a string, it is translated to a pattern that matches
@@ -3314,7 +3314,7 @@ vim.lpeg.P({value})                                             *vim.lpeg.P()*
     • If the argument is a table, it is interpreted as a grammar (see
       Grammars).
     • If the argument is a function, returns a pattern equivalent to a
-      match-time captureover the empty string.
+      match-time capture over the empty string.
 
     Parameters: ~
       • {value}  (`vim.lpeg.Pattern|string|integer|boolean|table|function`)
@@ -3326,12 +3326,12 @@ vim.lpeg.R({...})                                               *vim.lpeg.R()*
     Returns a pattern that matches any single character belonging to one of
     the given ranges. Each `range` is a string `xy` of length 2, representing
     all characters with code between the codes of `x` and `y` (both
-    inclusive). As an example, the pattern `lpeg.R("09")` matches any digit,
-    and `lpeg.R("az", "AZ")` matches any ASCII letter.
+    inclusive). As an example, the pattern ``lpeg.R('09')`` matches any digit,
+    and ``lpeg.R('az', 'AZ')`` matches any ASCII letter.
 
     Example: >lua
-        local pattern = lpeg.R("az") ^ 1 * -1
-        assert(pattern:match("hello") == 6)
+        local pattern = lpeg.R('az') ^ 1 * -1
+        assert(pattern:match('hello') == 6)
 <
 
     Parameters: ~
@@ -3343,10 +3343,10 @@ vim.lpeg.R({...})                                               *vim.lpeg.R()*
 vim.lpeg.S({string})                                            *vim.lpeg.S()*
     Returns a pattern that matches any single character that appears in the
     given string (the `S` stands for Set). As an example, the pattern
-    `lpeg.S("+-*/")` matches any arithmetic operator. Note that, if `s` is a
+    ``lpeg.S('+-*/')`` matches any arithmetic operator. Note that, if `s` is a
     character (that is, a string of length 1), then `lpeg.P(s)` is equivalent
     to `lpeg.S(s)` which is equivalent to `lpeg.R(s..s)`. Note also that both
-    `lpeg.S("")` and `lpeg.R()` are patterns that always fail.
+    ``lpeg.S('')`` and `lpeg.R()` are patterns that always fail.
 
     Parameters: ~
       • {string}  (`string`)
@@ -3382,7 +3382,7 @@ vim.lpeg.V({v})                                                 *vim.lpeg.V()*
     to the rule indexed by `v` in the enclosing grammar.
 
     Example: >lua
-        local b = lpeg.P({"(" * ((1 - lpeg.S "()") + lpeg.V(1)) ^ 0 * ")"})
+        local b = lpeg.P({'(' * ((1 - lpeg.S '()') + lpeg.V(1)) ^ 0 * ')'})
         assert(b:match('((string))') == 11)
         assert(b:match('(') == nil)
 <