[PATCH v2 1/5] Remove trailing whitespace in PEG texinfo.

From: Rutger van Beusekom <[email protected]>

* doc/ref/api-peg.texi (PEG API Reference): Remove trailing whitespace.
---
 doc/ref/api-peg.texi | 46 ++++++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/doc/ref/api-peg.texi b/doc/ref/api-peg.texi
index d34ddc64c..0214f7ff1 100644
--- a/doc/ref/api-peg.texi
+++ b/doc/ref/api-peg.texi
@@ -221,11 +221,11 @@ character (in normal PEGs nonterminals can only be alphabetic).
 
 For example, if we:
 @lisp
-(define-peg-string-patterns 
+(define-peg-string-patterns
   "as <- 'a'+
 bs <- 'b'+
 as-or-bs <- as/bs")
-(define-peg-string-patterns 
+(define-peg-string-patterns
   "as-tag <-- 'a'+
 bs-tag <-- 'b'+
 as-or-bs-tag <-- as-tag/bs-tag")
@@ -271,9 +271,9 @@ For Example, if we:
 @end lisp
 Then:
 @lisp
-(match-pattern as-or-bs "aabbcc") @result{} 
+(match-pattern as-or-bs "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: aa>
-(match-pattern as-or-bs-tag "aabbcc") @result{} 
+(match-pattern as-or-bs-tag "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: (as-or-bs-tag (as-tag aa))>
 @end lisp
 
@@ -325,7 +325,7 @@ find a valid substring starting at index 0 and @code{search-for-pattern} keeps
 looking.  They are both equally capable of ``parsing'' and ``matching''
 given those constraints.
 
-@deffn {Scheme Procedure} match-pattern nonterm string 
+@deffn {Scheme Procedure} match-pattern nonterm string
 Parses @var{string} using the PEG stored in @var{nonterm}.  If no match
 was found, @code{match-pattern} returns false.  If a match was found, a PEG
 match record is returned.
@@ -344,19 +344,19 @@ nothing
 
 @lisp
 (define-peg-pattern as all (+ "a"))
-(match-pattern as "aabbcc") @result{} 
+(match-pattern as "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: (as aa)>
 
 (define-peg-pattern as body (+ "a"))
-(match-pattern as "aabbcc") @result{} 
+(match-pattern as "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: aa>
 
 (define-peg-pattern as none (+ "a"))
-(match-pattern as "aabbcc") @result{} 
+(match-pattern as "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: ()>
 
 (define-peg-pattern bs body (+ "b"))
-(match-pattern bs "aabbcc") @result{} 
+(match-pattern bs "aabbcc") @result{}
 #f
 @end lisp
 @end deffn
@@ -371,31 +371,31 @@ was found, a PEG match record is returned.
 
 @lisp
 (define-peg-pattern as body (+ "a"))
-(search-for-pattern as "aabbcc") @result{} 
+(search-for-pattern as "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: aa>
-(search-for-pattern (+ "a") "aabbcc") @result{} 
+(search-for-pattern (+ "a") "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: aa>
-(search-for-pattern "'a'+" "aabbcc") @result{} 
+(search-for-pattern "'a'+" "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: aa>
 
 (define-peg-pattern as all (+ "a"))
-(search-for-pattern as "aabbcc") @result{} 
+(search-for-pattern as "aabbcc") @result{}
 #<peg start: 0 end: 2 string: aabbcc tree: (as aa)>
 
 (define-peg-pattern bs body (+ "b"))
-(search-for-pattern bs "aabbcc") @result{} 
+(search-for-pattern bs "aabbcc") @result{}
 #<peg start: 2 end: 4 string: aabbcc tree: bb>
-(search-for-pattern (+ "b") "aabbcc") @result{} 
+(search-for-pattern (+ "b") "aabbcc") @result{}
 #<peg start: 2 end: 4 string: aabbcc tree: bb>
-(search-for-pattern "'b'+" "aabbcc") @result{} 
+(search-for-pattern "'b'+" "aabbcc") @result{}
 #<peg start: 2 end: 4 string: aabbcc tree: bb>
 
 (define-peg-pattern zs body (+ "z"))
-(search-for-pattern zs "aabbcc") @result{} 
+(search-for-pattern zs "aabbcc") @result{}
 #f
-(search-for-pattern (+ "z") "aabbcc") @result{} 
+(search-for-pattern (+ "z") "aabbcc") @result{}
 #f
-(search-for-pattern "'z'+" "aabbcc") @result{} 
+(search-for-pattern "'z'+" "aabbcc") @result{}
 #f
 @end lisp
 @end deffn
@@ -468,9 +468,9 @@ itself satisfies @var{tst}, @code{(list lst)} is returned (this is a
 flat list whose only element satisfies @var{tst}).
 
 @lisp
-(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(2 2 (1 1 (2 2)) (2 2 (1 1)))) @result{} 
+(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(2 2 (1 1 (2 2)) (2 2 (1 1)))) @result{}
 (2 2 (1 1 (2 2)) 2 2 (1 1))
-(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(1 1 (1 1 (2 2)) (2 2 (1 1)))) @result{} 
+(context-flatten (lambda (x) (and (number? (car x)) (= (car x) 1))) '(1 1 (1 1 (2 2)) (2 2 (1 1)))) @result{}
 ((1 1 (1 1 (2 2)) (2 2 (1 1))))
 @end lisp
 
@@ -624,7 +624,7 @@ symbol for strings)..
   (entry "nobody:x:65534:65534:nobody:/nonexistent:/bin/sh")
   (entry "messagebus:x:103:107::/var/run/dbus:/bin/false"))
 (peg:tree (match-pattern tag-passwd "one entry"))
-(tag-passwd 
+(tag-passwd
   (entry "one entry"))
 @end lisp
 
@@ -841,7 +841,7 @@ number <-- [0-9]+")
 		(apply next-func (car first))
 		(apply next-func (car rest)))
           ;; form (sum (((product ...) "+") ((product ...) "+")) (product ...))
-	  (car 
+	  (car
 	   (reduce ;; walk through the list and build a left-associative tree
 	    (lambda (l r)
 	      (list (list (cadr r) (car r) (apply next-func (car l)))
-- 
2.46.0