wilderjds
/
dash.el
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix take/drop splits (again)

Browse Source 
This reverts some of the copying added in PR #354 so as to maintain
some support for circular and dotted list tails, which can't be
copied.  For more discussion, see also issue #225.

* dash.el (--take-while, -take-while, -take, -take-last)
(-drop-last): Improve docstring.
(--drop-while, -drop): Revert to not returning a copy.
(-drop-while): Update docstring accordingly.
(-split-at): Simplify.  Improve docstring.
(-rotate): Prefer nthcdr over -drop for clarity.

* dev/examples.el (-drop, -drop-while): Update tests for reverted
behavior.
(-take-while, -split-at, -rotate, -cycle, -fix): Improve tests.

* README.md:
* dash.texi: Regenerate docs.
master
Basil L. Contovounesios 5 years ago
parent 565055e95c
commit 558cd95367
No known key found for this signature in database
GPG Key ID: 205AB54A5D5D8CFF
4 changed files with 137 additions and 80 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 46
      README.md
  2. 61
      dash.el
  3. 53
      dash.texi
  4. 57
      dev/examples.el

46
README.md
Unescape View File

@ -610,7 +610,7 @@ Return a copy of the first `n` items in `list`.
Return a copy of `list` if it contains `n` items or fewer. Return a copy of `list` if it contains `n` items or fewer.
Return nil if `n` is zero or less. Return nil if `n` is zero or less.
See also: [`-take-last`](#-take-last-n-list) See also: [`-take-last`](#-take-last-n-list).
```el ```el
(-take 3 '(1 2 3 4 5)) ;; => '(1 2 3) (-take 3 '(1 2 3 4 5)) ;; => '(1 2 3)
@ -624,7 +624,7 @@ Return a copy of the last `n` items of `list` in order.
Return a copy of `list` if it contains `n` items or fewer. Return a copy of `list` if it contains `n` items or fewer.
Return nil if `n` is zero or less. Return nil if `n` is zero or less.
See also: [`-take`](#-take-n-list) See also: [`-take`](#-take-n-list).
```el ```el
(-take-last 3 '(1 2 3 4 5)) ;; => '(3 4 5) (-take-last 3 '(1 2 3 4 5)) ;; => '(3 4 5)
@ -634,11 +634,12 @@ See also: [`-take`](#-take-n-list)
#### -drop `(n list)` #### -drop `(n list)`
Return a copy of the tail of `list` without the first `n` items. Return the tail (not a copy) of `list` without the first `n` items.
Return a copy of `list` if `n` is zero or less.
Return nil if `list` contains `n` items or fewer. Return nil if `list` contains `n` items or fewer.
Return `list` if `n` is zero or less.
For another variant, see also [`-drop-last`](#-drop-last-n-list).
See also: [`-drop-last`](#-drop-last-n-list) (fn `n` `list`)
```el ```el
(-drop 3 '(1 2 3 4 5)) ;; => '(4 5) (-drop 3 '(1 2 3 4 5)) ;; => '(4 5)
@ -652,7 +653,7 @@ Return a copy of `list` without its last `n` items.
Return a copy of `list` if `n` is zero or less. Return a copy of `list` if `n` is zero or less.
Return nil if `list` contains `n` items or fewer. Return nil if `list` contains `n` items or fewer.
See also: [`-drop`](#-drop-n-list) See also: [`-drop`](#-drop-n-list).
```el ```el
(-drop-last 3 '(1 2 3 4 5)) ;; => '(1 2) (-drop-last 3 '(1 2 3 4 5)) ;; => '(1 2)
@ -666,26 +667,27 @@ Take successive items from `list` for which `pred` returns non-nil.
`pred` is a function of one argument. Return a new list of the `pred` is a function of one argument. Return a new list of the
successive elements from the start of `list` for which `pred` returns successive elements from the start of `list` for which `pred` returns
non-nil. non-nil.
This function's anaphoric counterpart is `--take-while`.
See also: [`-drop-while`](#-drop-while-pred-list) For another variant, see also [`-drop-while`](#-drop-while-pred-list).
```el ```el
(-take-while 'even? '(1 2 3 4)) ;; => nil (-take-while #'even? '(1 2 3 4)) ;; => nil
(-take-while 'even? '(2 4 5 6)) ;; => '(2 4) (-take-while #'even? '(2 4 5 6)) ;; => '(2 4)
(--take-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(1 2 3) (--take-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(1 2 3)
``` ```
#### -drop-while `(pred list)` #### -drop-while `(pred list)`
Drop successive items from `list` for which `pred` returns non-nil. Drop successive items from `list` for which `pred` returns non-nil.
`pred` is a function of one argument. Return a copy of the tail of `pred` is a function of one argument. Return the tail (not a copy)
`list` starting from its first element for which `pred` returns nil. of `list` starting from its first element for which `pred` returns
nil.
See also: [`-take-while`](#-take-while-pred-list) This function's anaphoric counterpart is `--drop-while`.
For another variant, see also [`-take-while`](#-take-while-pred-list).
```el ```el
(-drop-while 'even? '(1 2 3 4)) ;; => '(1 2 3 4) (-drop-while #'even? '(1 2 3 4)) ;; => '(1 2 3 4)
(-drop-while 'even? '(2 4 5 6)) ;; => '(5 6) (-drop-while #'even? '(2 4 5 6)) ;; => '(5 6)
(--drop-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(4 3 2 1) (--drop-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(4 3 2 1)
``` ```
@ -1366,11 +1368,17 @@ Functions partitioning the input list into a list of lists.
#### -split-at `(n list)` #### -split-at `(n list)`
Return a list of ((-take `n` `list`) (-drop `n` `list`)), in no more than one pass through the list. Split `list` into two sublists after the Nth element.
The result is a list of two elements (`take` `drop`) where `take` is a
new list of the first `n` elements of `list`, and `drop` is the
remaining elements of `list` (not a copy). `take` and `drop` are like
the results of [`-take`](#-take-n-list) and [`-drop`](#-drop-n-list), respectively, but the split
is done in a single list traversal.
```el ```el
(-split-at 3 '(1 2 3 4 5)) ;; => '((1 2 3) (4 5)) (-split-at 3 '(1 2 3 4 5)) ;; => '((1 2 3) (4 5))
(-split-at 17 '(1 2 3 4 5)) ;; => '((1 2 3 4 5) nil) (-split-at 17 '(1 2 3 4 5)) ;; => '((1 2 3 4 5) nil)
(-split-at 0 '(1 2 3 4 5)) ;; => '(nil (1 2 3 4 5))
``` ```
#### -split-with `(pred list)` #### -split-with `(pred list)`
@ -2090,8 +2098,8 @@ Compute the (least) fixpoint of `fn` with initial input `list`.
`fn` is called at least once, results are compared with `equal`. `fn` is called at least once, results are compared with `equal`.
```el ```el
(-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3 4 5 6))) ;; => '((1) (2) (3) (4) (5) (6)) (-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3))) ;; => '((1) (2) (3))
(let ((data '(("starwars" "scifi") ("jedi" "starwars" "warrior")))) (--fix (-uniq (--mapcat (cons it (cdr (assoc it data))) it)) '("jedi" "book"))) ;; => '("jedi" "starwars" "warrior" "scifi" "book") (let ((l '((starwars scifi) (jedi starwars warrior)))) (--fix (-uniq (--mapcat (cons it (cdr (assq it l))) it)) '(jedi book))) ;; => '(jedi starwars warrior scifi book)
``` ```

61
dash.el
Unescape View File

@ -966,7 +966,12 @@ section is returned. Defaults to 1."
(nreverse new-list))) (nreverse new-list)))
(defmacro --take-while (form list) (defmacro --take-while (form list)
"Anaphoric form of `-take-while'." "Take successive items from LIST for which FORM evals to non-nil.
Each element of LIST in turn is bound to `it' and its index
within LIST to `it-index' before evaluating FORM. Return a new
list of the successive elements from the start of LIST for which
FORM evaluates to non-nil.
This is the anaphoric counterpart to `-take-while'."
(declare (debug (form form))) (declare (debug (form form)))
(let ((r (make-symbol "result"))) (let ((r (make-symbol "result")))
`(let (,r) `(let (,r)
@ -978,24 +983,30 @@ section is returned. Defaults to 1."
PRED is a function of one argument. Return a new list of the PRED is a function of one argument. Return a new list of the
successive elements from the start of LIST for which PRED returns successive elements from the start of LIST for which PRED returns
non-nil. non-nil.
This function's anaphoric counterpart is `--take-while'.
See also: `-drop-while'" For another variant, see also `-drop-while'."
(--take-while (funcall pred it) list)) (--take-while (funcall pred it) list))
(defmacro --drop-while (form list) (defmacro --drop-while (form list)
"Anaphoric form of `-drop-while'." "Drop successive items from LIST for which FORM evals to non-nil.
Each element of LIST in turn is bound to `it' and its index
within LIST to `it-index' before evaluating FORM. Return the
tail (not a copy) of LIST starting from its first element for
which FORM evaluates to nil.
This is the anaphoric counterpart to `-drop-while'."
(declare (debug (form form))) (declare (debug (form form)))
(let ((l (make-symbol "list"))) (let ((l (make-symbol "list")))
`(let ((,l ,list)) `(let ((,l ,list))
(--each-while ,l ,form (pop ,l)) (--each-while ,l ,form (pop ,l))
(copy-sequence ,l)))) ,l)))
(defun -drop-while (pred list) (defun -drop-while (pred list)
"Drop successive items from LIST for which PRED returns non-nil. "Drop successive items from LIST for which PRED returns non-nil.
PRED is a function of one argument. Return a copy of the tail of PRED is a function of one argument. Return the tail (not a copy)
LIST starting from its first element for which PRED returns nil. of LIST starting from its first element for which PRED returns
nil.
See also: `-take-while'" This function's anaphoric counterpart is `--drop-while'.
For another variant, see also `-take-while'."
(--drop-while (funcall pred it) list)) (--drop-while (funcall pred it) list))
(defun -take (n list) (defun -take (n list)
@ -1003,7 +1014,7 @@ See also: `-take-while'"
Return a copy of LIST if it contains N items or fewer. Return a copy of LIST if it contains N items or fewer.
Return nil if N is zero or less. Return nil if N is zero or less.
See also: `-take-last'" See also: `-take-last'."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(--take-while (< it-index n) list)) (--take-while (< it-index n) list))
@ -1012,35 +1023,37 @@ See also: `-take-last'"
Return a copy of LIST if it contains N items or fewer. Return a copy of LIST if it contains N items or fewer.
Return nil if N is zero or less. Return nil if N is zero or less.
See also: `-take'" See also: `-take'."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(copy-sequence (last list n))) (copy-sequence (last list n)))
(defun -drop (n list) (defalias '-drop #'nthcdr
"Return a copy of the tail of LIST without the first N items. "Return the tail (not a copy) of LIST without the first N items.
Return a copy of LIST if N is zero or less.
Return nil if LIST contains N items or fewer. Return nil if LIST contains N items or fewer.
Return LIST if N is zero or less.
See also: `-drop-last'" For another variant, see also `-drop-last'.
(copy-sequence (nthcdr n list))) \n(fn N LIST)")
(defun -drop-last (n list) (defun -drop-last (n list)
"Return a copy of LIST without its last N items. "Return a copy of LIST without its last N items.
Return a copy of LIST if N is zero or less. Return a copy of LIST if N is zero or less.
Return nil if LIST contains N items or fewer. Return nil if LIST contains N items or fewer.
See also: `-drop'" See also: `-drop'."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(nbutlast (copy-sequence list) n)) (nbutlast (copy-sequence list) n))
(defun -split-at (n list) (defun -split-at (n list)
"Return a list of ((-take N LIST) (-drop N LIST)), in no more than one pass through the list." "Split LIST into two sublists after the Nth element.
The result is a list of two elements (TAKE DROP) where TAKE is a
new list of the first N elements of LIST, and DROP is the
remaining elements of LIST (not a copy). TAKE and DROP are like
the results of `-take' and `-drop', respectively, but the split
is done in a single list traversal."
(declare (pure t) (side-effect-free t)) (declare (pure t) (side-effect-free t))
(let (result) (let (result)
(--dotimes n (--each-while list (< it-index n)
(when list (push (pop list) result))
(!cons (car list) result)
(!cdr list)))
(list (nreverse result) list))) (list (nreverse result) list)))
(defun -rotate (n list) (defun -rotate (n list)
@ -1051,7 +1064,7 @@ The time complexity is O(n)."
(let* ((len (length list)) (let* ((len (length list))
(n-mod-len (mod n len)) (n-mod-len (mod n len))
(new-tail-len (- len n-mod-len))) (new-tail-len (- len n-mod-len)))
(append (-drop new-tail-len list) (-take new-tail-len list))))) (append (nthcdr new-tail-len list) (-take new-tail-len list)))))
(defun -insert-at (n x list) (defun -insert-at (n x list)
"Return a list with X inserted into LIST at position N. "Return a list with X inserted into LIST at position N.

53
dash.texi
Unescape View File

@ -642,7 +642,7 @@ Return a copy of the first @var{n} items in @var{list}.
Return a copy of @var{list} if it contains @var{n} items or fewer. Return a copy of @var{list} if it contains @var{n} items or fewer.
Return nil if @var{n} is zero or less. Return nil if @var{n} is zero or less.
See also: @code{-take-last} (@pxref{-take-last}) See also: @code{-take-last} (@pxref{-take-last}).
@example @example
@group @group
@ -666,7 +666,7 @@ Return a copy of the last @var{n} items of @var{list} in order.
Return a copy of @var{list} if it contains @var{n} items or fewer. Return a copy of @var{list} if it contains @var{n} items or fewer.
Return nil if @var{n} is zero or less. Return nil if @var{n} is zero or less.
See also: @code{-take} (@pxref{-take}) See also: @code{-take} (@pxref{-take}).
@example @example
@group @group
@ -686,11 +686,12 @@ See also: @code{-take} (@pxref{-take})
@anchor{-drop} @anchor{-drop}
@defun -drop (n list) @defun -drop (n list)
Return a copy of the tail of @var{list} without the first @var{n} items. Return the tail (not a copy) of @var{list} without the first @var{n} items.
Return a copy of @var{list} if @var{n} is zero or less.
Return nil if @var{list} contains @var{n} items or fewer. Return nil if @var{list} contains @var{n} items or fewer.
Return @var{list} if @var{n} is zero or less.
For another variant, see also @code{-drop-last} (@pxref{-drop-last}).
See also: @code{-drop-last} (@pxref{-drop-last}) (fn @var{n} @var{list})
@example @example
@group @group
@ -714,7 +715,7 @@ Return a copy of @var{list} without its last @var{n} items.
Return a copy of @var{list} if @var{n} is zero or less. Return a copy of @var{list} if @var{n} is zero or less.
Return nil if @var{list} contains @var{n} items or fewer. Return nil if @var{list} contains @var{n} items or fewer.
See also: @code{-drop} (@pxref{-drop}) See also: @code{-drop} (@pxref{-drop}).
@example @example
@group @group
@ -738,16 +739,16 @@ Take successive items from @var{list} for which @var{pred} returns non-nil.
@var{pred} is a function of one argument. Return a new list of the @var{pred} is a function of one argument. Return a new list of the
successive elements from the start of @var{list} for which @var{pred} returns successive elements from the start of @var{list} for which @var{pred} returns
non-nil. non-nil.
This function's anaphoric counterpart is @code{--take-while}.
See also: @code{-drop-while} (@pxref{-drop-while}) For another variant, see also @code{-drop-while} (@pxref{-drop-while}).
@example @example
@group @group
(-take-while 'even? '(1 2 3 4)) (-take-while #'even? '(1 2 3 4))
@result{} nil @result{} nil
@end group @end group
@group @group
(-take-while 'even? '(2 4 5 6)) (-take-while #'even? '(2 4 5 6))
@result{} '(2 4) @result{} '(2 4)
@end group @end group
@group @group
@ -760,18 +761,19 @@ See also: @code{-drop-while} (@pxref{-drop-while})
@anchor{-drop-while} @anchor{-drop-while}
@defun -drop-while (pred list) @defun -drop-while (pred list)
Drop successive items from @var{list} for which @var{pred} returns non-nil. Drop successive items from @var{list} for which @var{pred} returns non-nil.
@var{pred} is a function of one argument. Return a copy of the tail of @var{pred} is a function of one argument. Return the tail (not a copy)
@var{list} starting from its first element for which @var{pred} returns nil. of @var{list} starting from its first element for which @var{pred} returns
nil.
See also: @code{-take-while} (@pxref{-take-while}) This function's anaphoric counterpart is @code{--drop-while}.
For another variant, see also @code{-take-while} (@pxref{-take-while}).
@example @example
@group @group
(-drop-while 'even? '(1 2 3 4)) (-drop-while #'even? '(1 2 3 4))
@result{} '(1 2 3 4) @result{} '(1 2 3 4)
@end group @end group
@group @group
(-drop-while 'even? '(2 4 5 6)) (-drop-while #'even? '(2 4 5 6))
@result{} '(5 6) @result{} '(5 6)
@end group @end group
@group @group
@ -1935,7 +1937,12 @@ Functions partitioning the input list into a list of lists.
@anchor{-split-at} @anchor{-split-at}
@defun -split-at (n list) @defun -split-at (n list)
Return a list of ((-take @var{n} @var{list}) (-drop @var{n} @var{list})), in no more than one pass through the list. Split @var{list} into two sublists after the Nth element.
The result is a list of two elements (@var{take} @var{drop}) where @var{take} is a
new list of the first @var{n} elements of @var{list}, and @var{drop} is the
remaining elements of @var{list} (not a copy). @var{take} and @var{drop} are like
the results of @code{-take} (@pxref{-take}) and @code{-drop} (@pxref{-drop}), respectively, but the split
is done in a single list traversal.
@example @example
@group @group
@ -1946,6 +1953,10 @@ Return a list of ((-take @var{n} @var{list}) (-drop @var{n} @var{list})), in no
(-split-at 17 '(1 2 3 4 5)) (-split-at 17 '(1 2 3 4 5))
@result{} '((1 2 3 4 5) nil) @result{} '((1 2 3 4 5) nil)
@end group @end group
@group
(-split-at 0 '(1 2 3 4 5))
@result{} '(nil (1 2 3 4 5))
@end group
@end example @end example
@end defun @end defun
@ -3196,12 +3207,12 @@ Compute the (least) fixpoint of @var{fn} with initial input @var{list}.
@example @example
@group @group
(-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3 4 5 6))) (-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3)))
@result{} '((1) (2) (3) (4) (5) (6)) @result{} '((1) (2) (3))
@end group @end group
@group @group
(let ((data '(("starwars" "scifi") ("jedi" "starwars" "warrior")))) (--fix (-uniq (--mapcat (cons it (cdr (assoc it data))) it)) '("jedi" "book"))) (let ((l '((starwars scifi) (jedi starwars warrior)))) (--fix (-uniq (--mapcat (cons it (cdr (assq it l))) it)) '(jedi book)))
@result{} '("jedi" "starwars" "warrior" "scifi" "book") @result{} '(jedi starwars warrior scifi book)
@end group @end group
@end example @end example
@end defun @end defun

57
dev/examples.el
Unescape View File

@ -211,8 +211,8 @@ new list."
(-drop -1 ()) => () (-drop -1 ()) => ()
(-drop -1 '(1)) => '(1) (-drop -1 '(1)) => '(1)
(-drop 1 ()) => () (-drop 1 ()) => ()
(let ((l (list 1 2))) (setcar (-drop 1 l) 0) l) => '(1 2) (let ((l (list 1 2))) (setcar (-drop 1 l) 0) l) => '(1 0)
(let ((l (list 1 2))) (eq (-drop 0 l) l)) => nil) (let ((l (list 1 2))) (eq (-drop 0 l) l)) => t)
(defexamples -drop-last (defexamples -drop-last
(-drop-last 3 '(1 2 3 4 5)) => '(1 2) (-drop-last 3 '(1 2 3 4 5)) => '(1 2)
@ -226,8 +226,8 @@ new list."
(let ((l (list 1 2))) (eq (-drop-last 0 l) l)) => nil) (let ((l (list 1 2))) (eq (-drop-last 0 l) l)) => nil)
(defexamples -take-while (defexamples -take-while
(-take-while 'even? '(1 2 3 4)) => () (-take-while #'even? '(1 2 3 4)) => ()
(-take-while 'even? '(2 4 5 6)) => '(2 4) (-take-while #'even? '(2 4 5 6)) => '(2 4)
(--take-while (< it 4) '(1 2 3 4 3 2 1)) => '(1 2 3) (--take-while (< it 4) '(1 2 3 4 3 2 1)) => '(1 2 3)
(--take-while t ()) => () (--take-while t ()) => ()
(--take-while nil ()) => () (--take-while nil ()) => ()
@ -237,8 +237,8 @@ new list."
(let ((l (list 1 2))) (eq (--take-while t l) l)) => nil) (let ((l (list 1 2))) (eq (--take-while t l) l)) => nil)
(defexamples -drop-while (defexamples -drop-while
(-drop-while 'even? '(1 2 3 4)) => '(1 2 3 4) (-drop-while #'even? '(1 2 3 4)) => '(1 2 3 4)
(-drop-while 'even? '(2 4 5 6)) => '(5 6) (-drop-while #'even? '(2 4 5 6)) => '(5 6)
(--drop-while (< it 4) '(1 2 3 4 3 2 1)) => '(4 3 2 1) (--drop-while (< it 4) '(1 2 3 4 3 2 1)) => '(4 3 2 1)
(--drop-while t ()) => () (--drop-while t ()) => ()
(--drop-while nil ()) => () (--drop-while nil ()) => ()
@ -246,8 +246,8 @@ new list."
(--drop-while nil '(1 2)) => '(1 2) (--drop-while nil '(1 2)) => '(1 2)
(--drop-while t '(1)) => () (--drop-while t '(1)) => ()
(--drop-while t '(1 2)) => () (--drop-while t '(1 2)) => ()
(let ((l (list 1 2))) (setcar (-drop-while 'odd? l) 0) l) => '(1 2) (let ((l (list 1 2))) (setcar (-drop-while #'odd? l) 0) l) => '(1 0)
(let ((l (list 1 2))) (eq (--drop-while nil l) l)) => nil) (let ((l (list 1 2))) (eq (--drop-while nil l) l)) => t)
(defexamples -select-by-indices (defexamples -select-by-indices
(-select-by-indices '(4 10 2 3 6) '("v" "e" "l" "o" "c" "i" "r" "a" "p" "t" "o" "r")) => '("c" "o" "l" "o" "r") (-select-by-indices '(4 10 2 3 6) '("v" "e" "l" "o" "c" "i" "r" "a" "p" "t" "o" "r")) => '("c" "o" "l" "o" "r")
@ -634,7 +634,21 @@ value rather than consuming a list to produce a single value."
(defexamples -split-at (defexamples -split-at
(-split-at 3 '(1 2 3 4 5)) => '((1 2 3) (4 5)) (-split-at 3 '(1 2 3 4 5)) => '((1 2 3) (4 5))
(-split-at 17 '(1 2 3 4 5)) => '((1 2 3 4 5) nil)) (-split-at 17 '(1 2 3 4 5)) => '((1 2 3 4 5) ())
(-split-at 0 '(1 2 3 4 5)) => '(() (1 2 3 4 5))
(-split-at -1 ()) => '(() ())
(-split-at 0 ()) => '(() ())
(-split-at 1 ()) => '(() ())
(-split-at -1 '(1)) => '(() (1))
(-split-at 0 '(1)) => '(() (1))
(-split-at 1 '(1)) => '((1) ())
(-split-at 2 '(1)) => '((1) ())
(-split-at -1 '(1 2)) => '(() (1 2))
(-split-at 1 '(1 2)) => '((1) (2))
(-split-at 2 '(1 2)) => '((1 2) ())
(-split-at 3 '(1 2)) => '((1 2) ())
(let* ((l (list 1 2)) (s (-split-at 1 l))) (eq (car s) l)) => nil
(let* ((l (list 1 2)) (s (-split-at 1 l))) (eq (cadr s) (cdr l))) => t)
(defexamples -split-with (defexamples -split-with
(-split-with 'even? '(1 2 3 4)) => '(() (1 2 3 4)) (-split-with 'even? '(1 2 3 4)) => '(() (1 2 3 4))
@ -819,7 +833,17 @@ value rather than consuming a list to produce a single value."
(-rotate 3 '(1 2 3 4 5 6 7)) => '(5 6 7 1 2 3 4) (-rotate 3 '(1 2 3 4 5 6 7)) => '(5 6 7 1 2 3 4)
(-rotate -3 '(1 2 3 4 5 6 7)) => '(4 5 6 7 1 2 3) (-rotate -3 '(1 2 3 4 5 6 7)) => '(4 5 6 7 1 2 3)
(-rotate 16 '(1 2 3 4 5 6 7)) => '(6 7 1 2 3 4 5) (-rotate 16 '(1 2 3 4 5 6 7)) => '(6 7 1 2 3 4 5)
(-rotate -16 '(1 2 3 4 5 6 7)) => '(3 4 5 6 7 1 2)) (-rotate -16 '(1 2 3 4 5 6 7)) => '(3 4 5 6 7 1 2)
(-rotate -1 ()) => ()
(-rotate 0 ()) => ()
(-rotate 1 ()) => ()
(-rotate -1 '(1)) => '(1)
(-rotate 0 '(1)) => '(1)
(-rotate 1 '(1)) => '(1)
(-rotate -1 '(1 2)) => '(2 1)
(-rotate 0 '(1 2)) => '(1 2)
(-rotate 1 '(1 2)) => '(2 1)
(-rotate 2 '(1 2)) => '(1 2))
(defexamples -repeat (defexamples -repeat
(-repeat 3 :a) => '(:a :a :a) (-repeat 3 :a) => '(:a :a :a)
@ -888,8 +912,8 @@ value rather than consuming a list to produce a single value."
(-take 5 (-cycle '(1 2 3))) => '(1 2 3 1 2) (-take 5 (-cycle '(1 2 3))) => '(1 2 3 1 2)
(-take 7 (-cycle '(1 "and" 3))) => '(1 "and" 3 1 "and" 3 1) (-take 7 (-cycle '(1 "and" 3))) => '(1 "and" 3 1 "and" 3 1)
(-zip (-cycle '(1 2 3)) '(1 2)) => '((1 . 1) (2 . 2)) (-zip (-cycle '(1 2 3)) '(1 2)) => '((1 . 1) (2 . 2))
(-zip-with 'cons (-cycle '(1 2 3)) '(1 2)) => '((1 . 1) (2 . 2)) (-zip-with #'cons (-cycle '(1 2 3)) '(1 2)) => '((1 . 1) (2 . 2))
(-map (-partial '-take 5) (-split-at 5 (-cycle '(1 2 3)))) => '((1 2 3 1 2) (3 1 2 3 1)) (-map (-partial #'-take 5) (-split-at 5 (-cycle '(1 2 3)))) => '((1 2 3 1 2) (3 1 2 3 1))
(let ((l (list 1))) (eq l (-cycle l))) => nil) (let ((l (list 1))) (eq l (-cycle l))) => nil)
(defexamples -pad (defexamples -pad
@ -985,10 +1009,11 @@ value rather than consuming a list to produce a single value."
(-list '(() 1)) => '(() 1)) (-list '(() 1)) => '(() 1))
(defexamples -fix (defexamples -fix
(-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3 4 5 6))) => '((1) (2) (3) (4) (5) (6)) (-fix (lambda (l) (-non-nil (--mapcat (-split-at (/ (length it) 2) it) l))) '((1 2 3))) => '((1) (2) (3))
(let ((data '(("starwars" "scifi") (let ((l '((starwars scifi)
("jedi" "starwars" "warrior")))) (jedi starwars warrior))))
(--fix (-uniq (--mapcat (cons it (cdr (assoc it data))) it)) '("jedi" "book"))) => '("jedi" "starwars" "warrior" "scifi" "book"))) (--fix (-uniq (--mapcat (cons it (cdr (assq it l))) it)) '(jedi book)))
=> '(jedi starwars warrior scifi book)))
(def-example-group "Tree operations" (def-example-group "Tree operations"
"Functions pretending lists are trees." "Functions pretending lists are trees."

Write Preview
Loading…
Cancel
Save