Optimize -is-prefix? and -is-suffix?

* dash.el (-is-prefix?): Stop looping when prefix runs out, even if
list starts with nil elements.
(-is-suffix?): Avoid reversing arguments; just use member.
* dev/examples.el (-is-prefix?, -is-suffix?): Extend tests.

* README.md:
* dash.texi: Regenerate docs.

README.md

@@ -1313,9 +1313,9 @@ Alias: `-same-items-p`
 
 #### -is-prefix? `(prefix list)`
 
-Return non-nil if `prefix` is prefix of `list`.
+Return non-nil if `prefix` is a prefix of `list`.
 
-Alias: `-is-prefix-p`
+Alias: `-is-prefix-p`.
 
 ```el
 (-is-prefix? '(1 2 3) '(1 2 3 4 5)) ;; => t
@@ -1325,9 +1325,9 @@ Alias: `-is-prefix-p`
 
 #### -is-suffix? `(suffix list)`
 
-Return non-nil if `suffix` is suffix of `list`.
+Return non-nil if `suffix` is a suffix of `list`.
 
-Alias: `-is-suffix-p`
+Alias: `-is-suffix-p`.
 
 ```el
 (-is-suffix? '(3 4 5) '(1 2 3 4 5)) ;; => t

dash.el

@@ -2604,20 +2604,22 @@ Alias: `-same-items-p'"
 (defalias '-same-items-p '-same-items?)
 
 (defun -is-prefix? (prefix list)
-  "Return non-nil if PREFIX is prefix of LIST.
+  "Return non-nil if PREFIX is a prefix of LIST.
 
-Alias: `-is-prefix-p'"
+Alias: `-is-prefix-p'."
   (declare (pure t) (side-effect-free t))
-  (--each-while list (equal (car prefix) it)
+  (--each-while list (and (equal (car prefix) it)
-    (!cdr prefix))
+                          (!cdr prefix)))
-  (not prefix))
+  (null prefix))
 
 (defun -is-suffix? (suffix list)
-  "Return non-nil if SUFFIX is suffix of LIST.
+  "Return non-nil if SUFFIX is a suffix of LIST.
 
-Alias: `-is-suffix-p'"
+Alias: `-is-suffix-p'."
   (declare (pure t) (side-effect-free t))
-  (-is-prefix? (reverse suffix) (reverse list)))
+  (cond ((null suffix))
+        ((setq list (member (car suffix) list))
+         (equal (cdr suffix) (cdr list)))))
 
 (defun -is-infix? (infix list)
   "Return non-nil if INFIX is infix of LIST.

dash.texi

@@ -1854,9 +1854,9 @@ Alias: @code{-same-items-p}
 
 @anchor{-is-prefix?}
 @defun -is-prefix? (prefix list)
-Return non-nil if @var{prefix} is prefix of @var{list}.
+Return non-nil if @var{prefix} is a prefix of @var{list}.
 
-Alias: @code{-is-prefix-p}
+Alias: @code{-is-prefix-p}.
 
 @example
 @group
@@ -1876,9 +1876,9 @@ Alias: @code{-is-prefix-p}
 
 @anchor{-is-suffix?}
 @defun -is-suffix? (suffix list)
-Return non-nil if @var{suffix} is suffix of @var{list}.
+Return non-nil if @var{suffix} is a suffix of @var{list}.
 
-Alias: @code{-is-suffix-p}
+Alias: @code{-is-suffix-p}.
 
 @example
 @group

dev/examples.el

@@ -666,16 +666,39 @@ value rather than consuming a list to produce a single value."
     (-is-prefix? '(1 2 3) '(1 2 3 4 5)) => t
     (-is-prefix? '(1 2 3 4 5) '(1 2 3)) => nil
     (-is-prefix? '(1 3) '(1 2 3 4 5)) => nil
-    (-is-prefix? '(1 2 3) '(1 2 4 5)) => nil)
+    (-is-prefix? '(1 2 3) '(1 2 4 5)) => nil
+    (-is-prefix? '(1 2 3) '(1 2)) => nil
+    (-is-prefix? '(1 2) '(1 2)) => t
+    (-is-prefix? '(1) '(1 2)) => t
+    (-is-prefix? '(1) '(1)) => t
+    (-is-prefix? '() '(1)) => t
+    (-is-prefix? '() '()) => t
+    (-is-prefix? '() '(nil)) => t
+    (-is-prefix? '(nil) '(nil)) => t
+    (-is-prefix? '(nil) '()) => nil
+    (-is-prefix? '(2 3) '(1 2 3)) => nil
+    (let* ((p (list 1 2)) (l p) (c (copy-sequence p)))
+      (and (-is-prefix? p l) (equal p c) (equal l c)))
+    => t)
 
   (defexamples -is-suffix?
     (-is-suffix? '(3 4 5) '(1 2 3 4 5)) => t
     (-is-suffix? '(1 2 3 4 5) '(3 4 5)) => nil
     (-is-suffix? '(3 5) '(1 2 3 4 5)) => nil
     (-is-suffix? '(3 4 5) '(1 2 3 5)) => nil
-    (let ((l '(1 2 3)))
+    (-is-suffix? '(1 2 3) '(2 3)) => nil
-      (list (-is-suffix? '(3) l)
+    (-is-suffix? '(1 2) '(1 2)) => t
-            l)) => '(t (1 2 3)))
+    (-is-suffix? '(2) '(1 2)) => t
+    (-is-suffix? '(1) '(1)) => t
+    (-is-suffix? '() '(1)) => t
+    (-is-suffix? '() '()) => t
+    (-is-suffix? '() '(nil)) => t
+    (-is-suffix? '(nil) '(nil)) => t
+    (-is-suffix? '(nil) '()) => nil
+    (-is-suffix? '(1 2) '(1 2 3)) => nil
+    (let* ((s (list 1 2)) (l s) (c (copy-sequence s)))
+      (and (-is-suffix? s l) (equal s c) (equal l c)))
+    => t)
 
   (defexamples -is-infix?
     (-is-infix? '(1 2 3) '(1 2 3 4 5)) => t