[elpa] externals/dash 38307e3 223/439: Partition docs

[Phillip Lord]

branch: externals/dash
commit 38307e3126a41189ed4db546af711125bb678971
Author: Magnar Sveen <address@hidden>
Commit: Magnar Sveen <address@hidden>

    Partition docs
---
 README.md                |  660 +++++++++++++++++++-----------------
 dash-functional.el       |   28 +--
 dev/examples-to-docs.el  |   35 ++-
 dev/examples-to-tests.el |    2 +
 dev/examples.el          |  856 +++++++++++++++++++++++-----------------------
 readme-template.md       |    6 +-
 6 files changed, 816 insertions(+), 771 deletions(-)

diff --git a/README.md b/README.md
index 069f462..c54211d 100644
--- a/README.md
+++ b/README.md
@@ -27,11 +27,10 @@ Or you can just dump `dash.el` in your load path somewhere.
 
 ## Functions
 
+
+### List to list
+
 * [-map](#-map-fn-list) `(fn list)`
-* [-reduce-from](#-reduce-from-fn-initial-value-list) `(fn initial-value list)`
-* [-reduce-r-from](#-reduce-r-from-fn-initial-value-list) `(fn initial-value 
list)`
-* [-reduce](#-reduce-fn-list) `(fn list)`
-* [-reduce-r](#-reduce-r-fn-list) `(fn list)`
 * [-filter](#-filter-pred-list) `(pred list)`
 * [-remove](#-remove-pred-list) `(pred list)`
 * [-keep](#-keep-fn-list) `(fn list)`
@@ -40,7 +39,20 @@ Or you can just dump `dash.el` in your load path somewhere.
 * [-flatten](#-flatten-l) `(l)`
 * [-concat](#-concat-rest-lists) `(&rest lists)`
 * [-mapcat](#-mapcat-fn-list) `(fn list)`
-* [-cons*](#-cons-rest-args) `(&rest args)`
+* [-slice](#-slice-list-from-optional-to) `(list from &optional to)`
+* [-take](#-take-n-list) `(n list)`
+* [-drop](#-drop-n-list) `(n list)`
+* [-take-while](#-take-while-pred-list) `(pred list)`
+* [-drop-while](#-drop-while-pred-list) `(pred list)`
+* [-rotate](#-rotate-n-list) `(n list)`
+* [-insert-at](#-insert-at-n-x-list) `(n x list)`
+
+### Reductions
+
+* [-reduce-from](#-reduce-from-fn-initial-value-list) `(fn initial-value list)`
+* [-reduce-r-from](#-reduce-r-from-fn-initial-value-list) `(fn initial-value 
list)`
+* [-reduce](#-reduce-fn-list) `(fn list)`
+* [-reduce-r](#-reduce-r-fn-list) `(fn list)`
 * [-count](#-count-pred-list) `(pred list)`
 * [-sum](#-sum-list) `(list)`
 * [-product](#-product-list) `(list)`
@@ -48,22 +60,18 @@ Or you can just dump `dash.el` in your load path somewhere.
 * [-min-by](#-min-by-comparator-list) `(comparator list)`
 * [-max](#-max-list) `(list)`
 * [-max-by](#-max-by-comparator-list) `(comparator list)`
+
+### Predicates
+
 * [-any?](#-any-pred-list) `(pred list)`
 * [-all?](#-all-pred-list) `(pred list)`
 * [-none?](#-none-pred-list) `(pred list)`
 * [-only-some?](#-only-some-pred-list) `(pred list)`
-* [-each](#-each-list-fn) `(list fn)`
-* [-each-while](#-each-while-list-pred-fn) `(list pred fn)`
-* [-dotimes](#-dotimes-num-fn) `(num fn)`
-* [-repeat](#-repeat-n-x) `(n x)`
-* [-slice](#-slice-list-from-optional-to) `(list from &optional to)`
-* [-take](#-take-n-list) `(n list)`
-* [-drop](#-drop-n-list) `(n list)`
-* [-take-while](#-take-while-pred-list) `(pred list)`
-* [-drop-while](#-drop-while-pred-list) `(pred list)`
+* [-contains?](#-contains-list-element) `(list element)`
+
+### Partitioning
+
 * [-split-at](#-split-at-n-list) `(n list)`
-* [-rotate](#-rotate-n-list) `(n list)`
-* [-insert-at](#-insert-at-n-x-list) `(n x list)`
 * [-split-with](#-split-with-pred-list) `(pred list)`
 * [-separate](#-separate-pred-list) `(pred list)`
 * [-partition](#-partition-n-list) `(n list)`
@@ -73,6 +81,18 @@ Or you can just dump `dash.el` in your load path somewhere.
 * [-partition-by](#-partition-by-fn-list) `(fn list)`
 * [-partition-by-header](#-partition-by-header-fn-list) `(fn list)`
 * [-group-by](#-group-by-fn-list) `(fn list)`
+
+### Set operations
+
+* [-union](#-union-list-list2) `(list list2)`
+* [-difference](#-difference-list-list2) `(list list2)`
+* [-intersection](#-intersection-list-list2) `(list list2)`
+* [-distinct](#-distinct-list) `(list)`
+
+### Other list operations
+
+* [-repeat](#-repeat-n-x) `(n x)`
+* [-cons*](#-cons-rest-args) `(&rest args)`
 * [-interpose](#-interpose-sep-list) `(sep list)`
 * [-interleave](#-interleave-rest-lists) `(&rest lists)`
 * [-zip-with](#-zip-with-fn-list1-list2) `(fn list1 list2)`
@@ -81,19 +101,37 @@ Or you can just dump `dash.el` in your load path somewhere.
 * [-last](#-last-pred-list) `(pred list)`
 * [-first-item](#-first-item-list) `(list)`
 * [-last-item](#-last-item-list) `(list)`
-* [-union](#-union-list-list2) `(list list2)`
-* [-difference](#-difference-list-list2) `(list list2)`
-* [-intersection](#-intersection-list-list2) `(list list2)`
-* [-distinct](#-distinct-list) `(list)`
-* [-contains?](#-contains-list-element) `(list element)`
 * [-sort](#-sort-predicate-list) `(predicate list)`
+
+### Threading macros
+
 * [->](#--x-optional-form-rest-more) `(x &optional form &rest more)`
 * [->>](#--x-form-rest-more) `(x form &rest more)`
 * [-->](#---x-form-rest-more) `(x form &rest more)`
+
+### Binding
+
 * [-when-let](#-when-let-var-val-rest-body) `(var-val &rest body)`
 * [-when-let*](#-when-let-vars-vals-rest-body) `(vars-vals &rest body)`
 * [-if-let](#-if-let-var-val-then-optional-else) `(var-val then &optional 
else)`
 * [-if-let*](#-if-let-vars-vals-then-optional-else) `(vars-vals then &optional 
else)`
+
+### Side-effects
+
+* [-each](#-each-list-fn) `(list fn)`
+* [-each-while](#-each-while-list-pred-fn) `(list pred fn)`
+* [-dotimes](#-dotimes-num-fn) `(num fn)`
+
+### Destructive operations
+
+* [!cons](#-cons-car-cdr) `(car cdr)`
+* [!cdr](#-cdr-list) `(list)`
+
+### Function composition
+
+
+These combinators require Emacs 24 for its lexical scope. So you'll have to 
include them with `(require 'dash-functional)`.
+
 * [-partial](#-partial-fn-rest-args) `(fn &rest args)`
 * [-rpartial](#-rpartial-fn-rest-args) `(fn &rest args)`
 * [-juxt](#-juxt-rest-fns) `(&rest fns)`
@@ -105,14 +143,12 @@ Or you can just dump `dash.el` in your load path 
somewhere.
 * [-not](#-not-pred) `(pred)`
 * [-orfn](#-orfn-rest-preds) `(&rest preds)`
 * [-andfn](#-andfn-rest-preds) `(&rest preds)`
-* [!cons](#-cons-car-cdr) `(car cdr)`
-* [!cdr](#-cdr-list) `(list)`
-
-There are also anaphoric versions of these functions where that makes sense,
-prefixed with two dashes instead of one.
 
 ## Anaphoric functions
 
+There are also anaphoric versions of functions where that makes sense,
+prefixed with two dashes instead of one.
+
 While `-map` takes a function to map over the list, you can also use
 the anaphoric form with double dashes - which will then be executed
 with `it` exposed as the list item. Here's an example:
@@ -135,6 +171,7 @@ which demonstrates the usefulness of both versions.
 
 ## Documentation and examples
 
+
 ### -map `(fn list)`
 
 Returns a new list consisting of the result of applying `fn` to the items in 
`list`.
@@ -145,74 +182,6 @@ Returns a new list consisting of the result of applying 
`fn` to the items in `li
 (--map (* it it) '(1 2 3 4)) ;; => '(1 4 9 16)
 ```
 
-### -reduce-from `(fn initial-value list)`
-
-Returns the result of applying `fn` to `initial-value` and the
-first item in `list`, then applying `fn` to that result and the 2nd
-item, etc. If `list` contains no items, returns `initial-value` and
-`fn` is not called.
-
-In the anaphoric form `--reduce-from`, the accumulated value is
-exposed as `acc`.
-
-```cl
-(-reduce-from '- 10 '(1 2 3)) ;; => 4
-(-reduce-from (lambda (memo item) (concat "(" memo " - " (int-to-string item) 
")")) "10" '(1 2 3)) ;; => "(((10 - 1) - 2) - 3)"
-(--reduce-from (concat acc " " it) "START" '("a" "b" "c")) ;; => "START a b c"
-```
-
-### -reduce-r-from `(fn initial-value list)`
-
-Replace conses with `fn`, nil with `initial-value` and evaluate
-the resulting expression. If `list` is empty, `initial-value` is
-returned and `fn` is not called.
-
-Note: this function works the same as `-reduce-from` but the
-operation associates from right instead of from left.
-
-```cl
-(-reduce-r-from '- 10 '(1 2 3)) ;; => -8
-(-reduce-r-from (lambda (item memo) (concat "(" (int-to-string item) " - " 
memo ")")) "10" '(1 2 3)) ;; => "(1 - (2 - (3 - 10)))"
-(--reduce-r-from (concat it " " acc) "END" '("a" "b" "c")) ;; => "a b c END"
-```
-
-### -reduce `(fn list)`
-
-Returns the result of applying `fn` to the first 2 items in `list`,
-then applying `fn` to that result and the 3rd item, etc. If `list`
-contains no items, `fn` must accept no arguments as well, and
-reduce returns the result of calling `fn` with no arguments. If
-`list` has only 1 item, it is returned and `fn` is not called.
-
-In the anaphoric form `--reduce`, the accumulated value is
-exposed as `acc`.
-
-```cl
-(-reduce '- '(1 2 3 4)) ;; => -8
-(-reduce (lambda (memo item) (format "%s-%s" memo item)) '(1 2 3)) ;; => 
"1-2-3"
-(--reduce (format "%s-%s" acc it) '(1 2 3)) ;; => "1-2-3"
-```
-
-### -reduce-r `(fn list)`
-
-Replace conses with `fn` and evaluate the resulting expression.
-The final nil is ignored. If `list` contains no items, `fn` must
-accept no arguments as well, and reduce returns the result of
-calling `fn` with no arguments. If `list` has only 1 item, it is
-returned and `fn` is not called.
-
-The first argument of `fn` is the new item, the second is the
-accumulated value.
-
-Note: this function works the same as `-reduce` but the operation
-associates from right instead of from left.
-
-```cl
-(-reduce-r '- '(1 2 3 4)) ;; => -2
-(-reduce-r (lambda (item memo) (format "%s-%s" memo item)) '(1 2 3)) ;; => 
"3-2-1"
-(--reduce-r (format "%s-%s" acc it) '(1 2 3)) ;; => "3-2-1"
-```
-
 ### -filter `(pred list)`
 
 Returns a new list of the items in `list` for which `pred` returns a non-nil 
value.
@@ -301,18 +270,141 @@ Thus function `fn` should return a list.
 (--mapcat (list 0 it) '(1 2 3)) ;; => '(0 1 0 2 0 3)
 ```
 
-### -cons* `(&rest args)`
+### -slice `(list from &optional to)`
 
-Makes a new list from the elements of `args`.
+Return copy of `list`, starting from index `from` to index `to`.
+`from` or `to` may be negative.
 
-The last 2 members of `args` are used as the final cons of the
-result so if the final member of `args` is not a list the result is
-a dotted list.
+```cl
+(-slice '(1 2 3 4 5) 1) ;; => '(2 3 4 5)
+(-slice '(1 2 3 4 5) 0 3) ;; => '(1 2 3)
+(-slice '(1 2 3 4 5) 1 -1) ;; => '(2 3 4)
+```
+
+### -take `(n list)`
+
+Returns a new list of the first `n` items in `list`, or all items if there are 
fewer than `n`.
 
 ```cl
-(-cons* 1 2) ;; => '(1 . 2)
-(-cons* 1 2 3) ;; => '(1 2 . 3)
-(-cons* 1) ;; => 1
+(-take 3 '(1 2 3 4 5)) ;; => '(1 2 3)
+(-take 17 '(1 2 3 4 5)) ;; => '(1 2 3 4 5)
+```
+
+### -drop `(n list)`
+
+Returns the tail of `list` without the first `n` items.
+
+```cl
+(-drop 3 '(1 2 3 4 5)) ;; => '(4 5)
+(-drop 17 '(1 2 3 4 5)) ;; => '()
+```
+
+### -take-while `(pred list)`
+
+Returns a new list of successive items from `list` while (`pred` item) returns 
a non-nil value.
+
+```cl
+(-take-while 'even? '(1 2 3 4)) ;; => '()
+(-take-while 'even? '(2 4 5 6)) ;; => '(2 4)
+(--take-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(1 2 3)
+```
+
+### -drop-while `(pred list)`
+
+Returns the tail of `list` starting from the first item for which (`pred` 
item) returns nil.
+
+```cl
+(-drop-while 'even? '(1 2 3 4)) ;; => '(1 2 3 4)
+(-drop-while 'even? '(2 4 5 6)) ;; => '(5 6)
+(--drop-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(4 3 2 1)
+```
+
+### -rotate `(n list)`
+
+Rotate `list` `n` places to the right.  With `n` negative, rotate to the left.
+The time complexity is `o`(n).
+
+```cl
+(-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)
+```
+
+### -insert-at `(n x list)`
+
+Returns a list with `x` inserted into `list` at position `n`.
+
+```cl
+(-insert-at 1 'x '(a b c)) ;; => '(a x b c)
+(-insert-at 12 'x '(a b c)) ;; => '(a b c x)
+```
+
+
+### -reduce-from `(fn initial-value list)`
+
+Returns the result of applying `fn` to `initial-value` and the
+first item in `list`, then applying `fn` to that result and the 2nd
+item, etc. If `list` contains no items, returns `initial-value` and
+`fn` is not called.
+
+In the anaphoric form `--reduce-from`, the accumulated value is
+exposed as `acc`.
+
+```cl
+(-reduce-from '- 10 '(1 2 3)) ;; => 4
+(-reduce-from (lambda (memo item) (concat "(" memo " - " (int-to-string item) 
")")) "10" '(1 2 3)) ;; => "(((10 - 1) - 2) - 3)"
+(--reduce-from (concat acc " " it) "START" '("a" "b" "c")) ;; => "START a b c"
+```
+
+### -reduce-r-from `(fn initial-value list)`
+
+Replace conses with `fn`, nil with `initial-value` and evaluate
+the resulting expression. If `list` is empty, `initial-value` is
+returned and `fn` is not called.
+
+Note: this function works the same as `-reduce-from` but the
+operation associates from right instead of from left.
+
+```cl
+(-reduce-r-from '- 10 '(1 2 3)) ;; => -8
+(-reduce-r-from (lambda (item memo) (concat "(" (int-to-string item) " - " 
memo ")")) "10" '(1 2 3)) ;; => "(1 - (2 - (3 - 10)))"
+(--reduce-r-from (concat it " " acc) "END" '("a" "b" "c")) ;; => "a b c END"
+```
+
+### -reduce `(fn list)`
+
+Returns the result of applying `fn` to the first 2 items in `list`,
+then applying `fn` to that result and the 3rd item, etc. If `list`
+contains no items, `fn` must accept no arguments as well, and
+reduce returns the result of calling `fn` with no arguments. If
+`list` has only 1 item, it is returned and `fn` is not called.
+
+In the anaphoric form `--reduce`, the accumulated value is
+exposed as `acc`.
+
+```cl
+(-reduce '- '(1 2 3 4)) ;; => -8
+(-reduce (lambda (memo item) (format "%s-%s" memo item)) '(1 2 3)) ;; => 
"1-2-3"
+(--reduce (format "%s-%s" acc it) '(1 2 3)) ;; => "1-2-3"
+```
+
+### -reduce-r `(fn list)`
+
+Replace conses with `fn` and evaluate the resulting expression.
+The final nil is ignored. If `list` contains no items, `fn` must
+accept no arguments as well, and reduce returns the result of
+calling `fn` with no arguments. If `list` has only 1 item, it is
+returned and `fn` is not called.
+
+The first argument of `fn` is the new item, the second is the
+accumulated value.
+
+Note: this function works the same as `-reduce` but the operation
+associates from right instead of from left.
+
+```cl
+(-reduce-r '- '(1 2 3 4)) ;; => -2
+(-reduce-r (lambda (item memo) (format "%s-%s" memo item)) '(1 2 3)) ;; => 
"3-2-1"
+(--reduce-r (format "%s-%s" acc it) '(1 2 3)) ;; => "3-2-1"
 ```
 
 ### -count `(pred list)`
@@ -392,6 +484,7 @@ comparing them.
 (--max-by (> (car it) (car other)) '((2 2 3) (3) (1 2))) ;; => '(3)
 ```
 
+
 ### -any? `(pred list)`
 
 Returns t if (`pred` x) is non-nil for any x in `list`, else nil.
@@ -416,142 +509,47 @@ Alias: `-every?`
 (--all? (= 0 (% it 2)) '(2 4 6)) ;; => t
 ```
 
-### -none? `(pred list)`
-
-Returns t if (`pred` x) is nil for all x in `list`, else nil.
-
-```cl
-(-none? 'even? '(1 2 3)) ;; => nil
-(-none? 'even? '(1 3 5)) ;; => t
-(--none? (= 0 (% it 2)) '(1 2 3)) ;; => nil
-```
-
-### -only-some? `(pred list)`
-
-Returns `t` if there is a mix of items in `list` that matches and does not 
match `pred`.
-Returns `nil` both if all items match the predicate, and if none of the items 
match the predicate.
-
-```cl
-(-only-some? 'even? '(1 2 3)) ;; => t
-(-only-some? 'even? '(1 3 5)) ;; => nil
-(-only-some? 'even? '(2 4 6)) ;; => nil
-```
-
-### -each `(list fn)`
-
-Calls `fn` with every item in `list`. Returns nil, used for side-effects only.
-
-```cl
-(let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) ;; => nil
-(let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s)))) s) ;; => '(3 
2 1)
-(let (s) (--each '(1 2 3) (setq s (cons it s))) s) ;; => '(3 2 1)
-```
-
-### -each-while `(list pred fn)`
-
-Calls `fn` with every item in `list` while (`pred` item) is non-nil.
-Returns nil, used for side-effects only.
-
-```cl
-(let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) ;; 
=> '(4 2)
-(let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) ;; => '(2 1)
-```
-
-### -dotimes `(num fn)`
-
-Repeatedly calls `fn` (presumably for side-effects) passing in integers from 0 
through n-1.
-
-```cl
-(let (s) (-dotimes 3 (lambda (n) (!cons n s))) s) ;; => '(2 1 0)
-(let (s) (--dotimes 5 (!cons it s)) s) ;; => '(4 3 2 1 0)
-```
-
-### -repeat `(n x)`
-
-Return a list with `x` repeated `n` times.
-Returns nil if `n` is less than 1.
-
-```cl
-(-repeat 3 :a) ;; => '(:a :a :a)
-(-repeat 1 :a) ;; => '(:a)
-(-repeat 0 :a) ;; => nil
-```
-
-### -slice `(list from &optional to)`
-
-Return copy of `list`, starting from index `from` to index `to`.
-`from` or `to` may be negative.
-
-```cl
-(-slice '(1 2 3 4 5) 1) ;; => '(2 3 4 5)
-(-slice '(1 2 3 4 5) 0 3) ;; => '(1 2 3)
-(-slice '(1 2 3 4 5) 1 -1) ;; => '(2 3 4)
-```
-
-### -take `(n list)`
-
-Returns a new list of the first `n` items in `list`, or all items if there are 
fewer than `n`.
-
-```cl
-(-take 3 '(1 2 3 4 5)) ;; => '(1 2 3)
-(-take 17 '(1 2 3 4 5)) ;; => '(1 2 3 4 5)
-```
-
-### -drop `(n list)`
-
-Returns the tail of `list` without the first `n` items.
-
-```cl
-(-drop 3 '(1 2 3 4 5)) ;; => '(4 5)
-(-drop 17 '(1 2 3 4 5)) ;; => '()
-```
-
-### -take-while `(pred list)`
-
-Returns a new list of successive items from `list` while (`pred` item) returns 
a non-nil value.
-
-```cl
-(-take-while 'even? '(1 2 3 4)) ;; => '()
-(-take-while 'even? '(2 4 5 6)) ;; => '(2 4)
-(--take-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(1 2 3)
-```
-
-### -drop-while `(pred list)`
+### -none? `(pred list)`
 
-Returns the tail of `list` starting from the first item for which (`pred` 
item) returns nil.
+Returns t if (`pred` x) is nil for all x in `list`, else nil.
 
 ```cl
-(-drop-while 'even? '(1 2 3 4)) ;; => '(1 2 3 4)
-(-drop-while 'even? '(2 4 5 6)) ;; => '(5 6)
-(--drop-while (< it 4) '(1 2 3 4 3 2 1)) ;; => '(4 3 2 1)
+(-none? 'even? '(1 2 3)) ;; => nil
+(-none? 'even? '(1 3 5)) ;; => t
+(--none? (= 0 (% it 2)) '(1 2 3)) ;; => nil
 ```
 
-### -split-at `(n list)`
+### -only-some? `(pred list)`
 
-Returns a list of ((-take `n` `list`) (-drop `n` `list`)), in no more than one 
pass through the list.
+Returns `t` if there is a mix of items in `list` that matches and does not 
match `pred`.
+Returns `nil` both if all items match the predicate, and if none of the items 
match the predicate.
 
 ```cl
-(-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)
+(-only-some? 'even? '(1 2 3)) ;; => t
+(-only-some? 'even? '(1 3 5)) ;; => nil
+(-only-some? 'even? '(2 4 6)) ;; => nil
 ```
 
-### -rotate `(n list)`
+### -contains? `(list element)`
 
-Rotate `list` `n` places to the right.  With `n` negative, rotate to the left.
-The time complexity is `o`(n).
+Return whether `list` contains `element`.
+The test for equality is done with `equal`,
+or with `-compare-fn` if that's non-nil.
 
 ```cl
-(-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)
+(-contains? '(1 2 3) 1) ;; => t
+(-contains? '(1 2 3) 2) ;; => t
+(-contains? '(1 2 3) 4) ;; => nil
 ```
 
-### -insert-at `(n x list)`
 
-Returns a list with `x` inserted into `list` at position `n`.
+### -split-at `(n list)`
+
+Returns a list of ((-take `n` `list`) (-drop `n` `list`)), in no more than one 
pass through the list.
 
 ```cl
-(-insert-at 1 'x '(a b c)) ;; => '(a x b c)
-(-insert-at 12 'x '(a b c)) ;; => '(a b c x)
+(-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-with `(pred list)`
@@ -654,6 +652,82 @@ elements of `list`.  Keys are compared by `equal`.
 (--group-by (car (split-string it "/")) '("a/b" "c/d" "a/e")) ;; => '(("a" 
"a/b" "a/e") ("c" "c/d"))
 ```
 
+
+### -union `(list list2)`
+
+Return a new list containing the elements of `list1` and elements of `list2` 
that are not in `list1`.
+The test for equality is done with `equal`,
+or with `-compare-fn` if that's non-nil.
+
+```cl
+(-union '(1 2 3) '(3 4 5)) ;; => '(1 2 3 4 5)
+(-union '(1 2 3 4) '()) ;; => '(1 2 3 4)
+(-union '(1 1 2 2) '(3 2 1)) ;; => '(1 1 2 2 3)
+```
+
+### -difference `(list list2)`
+
+Return a new list with only the members of `list` that are not in `list2`.
+The test for equality is done with `equal`,
+or with `-compare-fn` if that's non-nil.
+
+```cl
+(-difference '() '()) ;; => '()
+(-difference '(1 2 3) '(4 5 6)) ;; => '(1 2 3)
+(-difference '(1 2 3 4) '(3 4 5 6)) ;; => '(1 2)
+```
+
+### -intersection `(list list2)`
+
+Return a new list containing only the elements that are members of both `list` 
and `list2`.
+The test for equality is done with `equal`,
+or with `-compare-fn` if that's non-nil.
+
+```cl
+(-intersection '() '()) ;; => '()
+(-intersection '(1 2 3) '(4 5 6)) ;; => '()
+(-intersection '(1 2 3 4) '(3 4 5 6)) ;; => '(3 4)
+```
+
+### -distinct `(list)`
+
+Return a new list with all duplicates removed.
+The test for equality is done with `equal`,
+or with `-compare-fn` if that's non-nil.
+
+Alias: `-uniq`
+
+```cl
+(-distinct '()) ;; => '()
+(-distinct '(1 2 2 4)) ;; => '(1 2 4)
+```
+
+
+### -repeat `(n x)`
+
+Return a list with `x` repeated `n` times.
+Returns nil if `n` is less than 1.
+
+```cl
+(-repeat 3 :a) ;; => '(:a :a :a)
+(-repeat 1 :a) ;; => '(:a)
+(-repeat 0 :a) ;; => nil
+```
+
+### -cons* `(&rest args)`
+
+Makes a new list from the elements of `args`.
+
+The last 2 members of `args` are used as the final cons of the
+result so if the final member of `args` is not a list the result is
+a dotted list.
+
+```cl
+(-cons* 1 2) ;; => '(1 . 2)
+(-cons* 1 2 3) ;; => '(1 2 . 3)
+(-cons* 1) ;; => 1
+```
+
 ### -interpose `(sep list)`
 
 Returns a new list of all elements in `list` separated by `sep`.
@@ -743,67 +817,6 @@ Returns the first item of `list`, or nil on an empty list.
 (-last-item nil) ;; => nil
 ```
 
-### -union `(list list2)`
-
-Return a new list containing the elements of `list1` and elements of `list2` 
that are not in `list1`.
-The test for equality is done with `equal`,
-or with `-compare-fn` if that's non-nil.
-
-```cl
-(-union '(1 2 3) '(3 4 5)) ;; => '(1 2 3 4 5)
-(-union '(1 2 3 4) '()) ;; => '(1 2 3 4)
-(-union '(1 1 2 2) '(3 2 1)) ;; => '(1 1 2 2 3)
-```
-
-### -difference `(list list2)`
-
-Return a new list with only the members of `list` that are not in `list2`.
-The test for equality is done with `equal`,
-or with `-compare-fn` if that's non-nil.
-
-```cl
-(-difference '() '()) ;; => '()
-(-difference '(1 2 3) '(4 5 6)) ;; => '(1 2 3)
-(-difference '(1 2 3 4) '(3 4 5 6)) ;; => '(1 2)
-```
-
-### -intersection `(list list2)`
-
-Return a new list containing only the elements that are members of both `list` 
and `list2`.
-The test for equality is done with `equal`,
-or with `-compare-fn` if that's non-nil.
-
-```cl
-(-intersection '() '()) ;; => '()
-(-intersection '(1 2 3) '(4 5 6)) ;; => '()
-(-intersection '(1 2 3 4) '(3 4 5 6)) ;; => '(3 4)
-```
-
-### -distinct `(list)`
-
-Return a new list with all duplicates removed.
-The test for equality is done with `equal`,
-or with `-compare-fn` if that's non-nil.
-
-Alias: `-uniq`
-
-```cl
-(-distinct '()) ;; => '()
-(-distinct '(1 2 2 4)) ;; => '(1 2 4)
-```
-
-### -contains? `(list element)`
-
-Return whether `list` contains `element`.
-The test for equality is done with `equal`,
-or with `-compare-fn` if that's non-nil.
-
-```cl
-(-contains? '(1 2 3) 1) ;; => t
-(-contains? '(1 2 3) 2) ;; => t
-(-contains? '(1 2 3) 4) ;; => nil
-```
-
 ### -sort `(predicate list)`
 
 Sort `list`, stably, comparing elements using `predicate`.
@@ -817,6 +830,7 @@ if the first element should sort before the second.
 (--sort (< it other) '(3 1 2)) ;; => '(1 2 3)
 ```
 
+
 ### -> `(x &optional form &rest more)`
 
 Threads the expr through the forms. Inserts `x` as the second
@@ -856,6 +870,7 @@ in in second form, etc.
 (--> "def" (concat "abc" it "ghi") upcase) ;; => "ABCDEFGHI"
 ```
 
+
 ### -when-let `(var-val &rest body)`
 
 If `val` evaluates to non-nil, bind it to `var` and execute body.
@@ -899,6 +914,57 @@ If all `vals` evaluate to true, bind them to their 
corresponding
 (-if-let* ((x 5) (y nil) (z 7)) (+ x y z) "foo") ;; => "foo"
 ```
 
+
+### -each `(list fn)`
+
+Calls `fn` with every item in `list`. Returns nil, used for side-effects only.
+
+```cl
+(let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) ;; => nil
+(let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s)))) s) ;; => '(3 
2 1)
+(let (s) (--each '(1 2 3) (setq s (cons it s))) s) ;; => '(3 2 1)
+```
+
+### -each-while `(list pred fn)`
+
+Calls `fn` with every item in `list` while (`pred` item) is non-nil.
+Returns nil, used for side-effects only.
+
+```cl
+(let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) ;; 
=> '(4 2)
+(let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) ;; => '(2 1)
+```
+
+### -dotimes `(num fn)`
+
+Repeatedly calls `fn` (presumably for side-effects) passing in integers from 0 
through n-1.
+
+```cl
+(let (s) (-dotimes 3 (lambda (n) (!cons n s))) s) ;; => '(2 1 0)
+(let (s) (--dotimes 5 (!cons it s)) s) ;; => '(4 3 2 1 0)
+```
+
+
+### !cons `(car cdr)`
+
+Destructive: Sets `cdr` to the cons of `car` and `cdr`.
+
+```cl
+(let (l) (!cons 5 l) l) ;; => '(5)
+(let ((l '(3))) (!cons 5 l) l) ;; => '(5 3)
+```
+
+### !cdr `(list)`
+
+Destructive: Sets `list` to the cdr of `list`.
+
+```cl
+(let ((l '(3))) (!cdr l) l) ;; => '()
+(let ((l '(3 5))) (!cdr l) l) ;; => '(5)
+```
+
+
+
 ### -partial `(fn &rest args)`
 
 Takes a function `fn` and fewer than the normal arguments to `fn`,
@@ -958,8 +1024,6 @@ results (in the same order).
 
 In types: (b -> b -> c) -> (a -> b) -> a -> a -> c
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (-sort (-on '< 'length) '((1 2 3) (1) (1 2))) ;; => '((1) (1 2) (1 2 3))
 (-sort (-on 'string-lessp 'int-to-string) '(10 12 1 2 22)) ;; => '(1 10 12 2 
22)
@@ -972,8 +1036,6 @@ Swap the order of arguments for binary function `func`.
 
 In types: (a -> b -> c) -> b -> a -> c
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (funcall (-flip '<) 2 1) ;; => t
 (funcall (-flip '-) 3 8) ;; => 5
@@ -986,8 +1048,6 @@ Return a function that returns `c` ignoring any additional 
arguments.
 
 In types: a -> b -> a
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (funcall (-const 2) 1 3 "foo") ;; => 2
 (-map (-const 1) '("a" "b" "c" "d")) ;; => '(1 1 1 1)
@@ -1001,8 +1061,6 @@ Arguments denoted by <> will be left unspecialized.
 
 See `srfi-26` for detailed description.
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (funcall (-cut list 1 <> 3 <> 5) 2 4) ;; => '(1 2 3 4 5)
 (-map (-cut funcall <> 5) '(1+ 1- (lambda (x) (/ 1.0 x)))) ;; => '(6 4 0.2)
@@ -1015,8 +1073,6 @@ Take an unary predicates `pred` and return an unary 
predicate
 that returns t if `pred` returns nil and nil if `pred` returns
 non-nil.
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (funcall (-not 'even?) 5) ;; => t
 (-filter (-not (-partial '< 4)) '(1 2 3 4 5 6 7 8)) ;; => '(1 2 3 4)
@@ -1030,8 +1086,6 @@ the `preds` returns non-nil on x.
 
 In types: [a -> Bool] -> a -> Bool
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (-filter (-orfn 'even? (-partial (-flip '<) 5)) '(1 2 3 4 5 6 7 8 9 10)) ;; => 
'(1 2 3 4 6 8 10)
 (funcall (-orfn 'stringp 'even?) "foo") ;; => t
@@ -1045,32 +1099,12 @@ predicate with argument x that returns non-nil if all 
of the
 
 In types: [a -> Bool] -> a -> Bool
 
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher.
-
 ```cl
 (funcall (-andfn (-cut < <> 10) 'even?) 6) ;; => t
 (funcall (-andfn (-cut < <> 10) 'even?) 12) ;; => nil
 (-filter (-andfn (-not 'even?) (-cut >= 5 <>)) '(1 2 3 4 5 6 7 8 9 10)) ;; => 
'(1 3 5)
 ```
 
-### !cons `(car cdr)`
-
-Destructive: Sets `cdr` to the cons of `car` and `cdr`.
-
-```cl
-(let (l) (!cons 5 l) l) ;; => '(5)
-(let ((l '(3))) (!cons 5 l) l) ;; => '(5 3)
-```
-
-### !cdr `(list)`
-
-Destructive: Sets `list` to the cdr of `list`.
-
-```cl
-(let ((l '(3))) (!cdr l) l) ;; => '()
-(let ((l '(3 5))) (!cdr l) l) ;; => '(5)
-```
-
 
 ## Contribute
 
diff --git a/dash-functional.el b/dash-functional.el
index 7d21e23..1530758 100644
--- a/dash-functional.el
+++ b/dash-functional.el
@@ -64,34 +64,26 @@ expects a list with n items as arguments"
 TRANSFORMER to each of them and then applies OPERATOR on the
 results (in the same order).
 
-In types: (b -> b -> c) -> (a -> b) -> a -> a -> c
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+In types: (b -> b -> c) -> (a -> b) -> a -> a -> c"
   (lambda (x y) (funcall operator (funcall transformer x) (funcall transformer 
y))))
 
 (defun -flip (func)
   "Swap the order of arguments for binary function FUNC.
 
-In types: (a -> b -> c) -> b -> a -> c
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+In types: (a -> b -> c) -> b -> a -> c"
   (lambda (x y) (funcall func y x)))
 
 (defun -const (c)
   "Return a function that returns C ignoring any additional arguments.
 
-In types: a -> b -> a
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+In types: a -> b -> a"
   (lambda (&rest _) c))
 
 (defmacro -cut (&rest params)
   "Take n-ary function and n arguments and specialize some of them.
 Arguments denoted by <> will be left unspecialized.
 
-See SRFI-26 for detailed description.
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+See SRFI-26 for detailed description."
   (let* ((i 0)
          (args (mapcar (lambda (_) (setq i (1+ i)) (make-symbol (format "D%d" 
i)))
                        (-filter (-partial 'eq '<>) params))))
@@ -101,9 +93,7 @@ Available by `(require 'dash-functional)`. Requires Emacs 24 
or higher."
 (defun -not (pred)
   "Take an unary predicates PRED and return an unary predicate
 that returns t if PRED returns nil and nil if PRED returns
-non-nil.
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+non-nil."
   (lambda (x) (not (funcall pred x))))
 
 (defun -orfn (&rest preds)
@@ -111,9 +101,7 @@ Available by `(require 'dash-functional)`. Requires Emacs 
24 or higher."
 predicate with argument x that returns non-nil if at least one of
 the PREDS returns non-nil on x.
 
-In types: [a -> Bool] -> a -> Bool
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+In types: [a -> Bool] -> a -> Bool"
   (lambda (x) (-any? (-cut funcall <> x) preds)))
 
 (defun -andfn (&rest preds)
@@ -121,9 +109,7 @@ Available by `(require 'dash-functional)`. Requires Emacs 
24 or higher."
 predicate with argument x that returns non-nil if all of the
 PREDS returns non-nil on x.
 
-In types: [a -> Bool] -> a -> Bool
-
-Available by `(require 'dash-functional)`. Requires Emacs 24 or higher."
+In types: [a -> Bool] -> a -> Bool"
   (lambda (x) (-all? (-cut funcall <> x) preds)))
 
 (provide 'dash-functional)
diff --git a/dev/examples-to-docs.el b/dev/examples-to-docs.el
index bb5d618..6635d1b 100644
--- a/dev/examples-to-docs.el
+++ b/dev/examples-to-docs.el
@@ -43,6 +43,13 @@ FUNCTION may reference an elisp function, alias, macro or a 
subr."
                             (documentation ',cmd)
                             (-map 'example-to-string (-partition 3 
',examples)))))
 
+(defmacro def-example-group (group desc &rest examples)
+  `(progn
+     (add-to-list 'functions ,(concat "### " group))
+     (when ,desc
+       (add-to-list 'functions ,desc))
+     ,@examples))
+
 (defun quote-and-downcase (string)
   (format "`%s`" (downcase string)))
 
@@ -53,15 +60,17 @@ FUNCTION may reference an elisp function, alias, macro or a 
subr."
       (replace-regexp-in-string "`\\([^ ]+\\)'" "`\\1`" it t))))
 
 (defun function-to-md (function)
-  (let ((command-name (car function))
-        (signature (cadr function))
-        (docstring (quote-docstring (nth 2 function)))
-        (examples (nth 3 function)))
-    (format "### %s `%s`\n\n%s\n\n```cl\n%s\n```\n"
-            command-name
-            signature
-            docstring
-            (mapconcat 'identity (-take 3 examples) "\n"))))
+  (if (stringp function)
+      ""
+    (let ((command-name (car function))
+          (signature (cadr function))
+          (docstring (quote-docstring (nth 2 function)))
+          (examples (nth 3 function)))
+      (format "### %s `%s`\n\n%s\n\n```cl\n%s\n```\n"
+              command-name
+              signature
+              docstring
+              (mapconcat 'identity (-take 3 examples) "\n")))))
 
 (defun docs--chop-suffix (suffix s)
   "Remove SUFFIX if it is at end of S."
@@ -77,9 +86,11 @@ FUNCTION may reference an elisp function, alias, macro or a 
subr."
    (replace-regexp-in-string "[^a-zA-Z0-9-]+" "-" (format "%S %S" command-name 
signature))))
 
 (defun function-summary (function)
-  (let ((command-name (car function))
-        (signature (cadr function)))
-    (format "* [%s](#%s) `%s`" command-name (github-id command-name signature) 
signature)))
+  (if (stringp function)
+      (concat "\n" function "\n")
+    (let ((command-name (car function))
+          (signature (cadr function)))
+      (format "* [%s](#%s) `%s`" command-name (github-id command-name 
signature) signature))))
 
 (defun simplify-quotes ()
   (goto-char (point-min))
diff --git a/dev/examples-to-tests.el b/dev/examples-to-tests.el
index 51e82c7..6cee1a3 100644
--- a/dev/examples-to-tests.el
+++ b/dev/examples-to-tests.el
@@ -11,4 +11,6 @@
   `(ert-deftest ,cmd ()
      ,@(-map 'example-to-should (-partition 3 examples))))
 
+(defun def-example-group (&rest _)) ; ignore
+
 (provide 'examples-to-tests)
diff --git a/dev/examples.el b/dev/examples.el
index 0e64612..d7ac41f 100644
--- a/dev/examples.el
+++ b/dev/examples.el
@@ -9,426 +9,438 @@
 (defun square (num) (* num num))
 (defun three-letters () '("A" "B" "C"))
 
-(defexamples -map
-  (-map (lambda (num) (* num num)) '(1 2 3 4)) => '(1 4 9 16)
-  (-map 'square '(1 2 3 4)) => '(1 4 9 16)
-  (--map (* it it) '(1 2 3 4)) => '(1 4 9 16)
-  (--map (concat it it) (three-letters)) => '("AA" "BB" "CC"))
-
-(defexamples -reduce-from
-  (-reduce-from '- 10 '(1 2 3)) => 4
-  (-reduce-from (lambda (memo item)
+(def-example-group "List to list" nil
+  (defexamples -map
+    (-map (lambda (num) (* num num)) '(1 2 3 4)) => '(1 4 9 16)
+    (-map 'square '(1 2 3 4)) => '(1 4 9 16)
+    (--map (* it it) '(1 2 3 4)) => '(1 4 9 16)
+    (--map (concat it it) (three-letters)) => '("AA" "BB" "CC"))
+
+  (defexamples -filter
+    (-filter (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) => '(2 4)
+    (-filter 'even? '(1 2 3 4)) => '(2 4)
+    (--filter (= 0 (% it 2)) '(1 2 3 4)) => '(2 4))
+
+  (defexamples -remove
+    (-remove (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) => '(1 3)
+    (-remove 'even? '(1 2 3 4)) => '(1 3)
+    (--remove (= 0 (% it 2)) '(1 2 3 4)) => '(1 3)
+    (let ((mod 2)) (-remove (lambda (num) (= 0 (% num mod))) '(1 2 3 4))) => 
'(1 3)
+    (let ((mod 2)) (--remove (= 0 (% it mod)) '(1 2 3 4))) => '(1 3))
+
+  (defexamples -keep
+    (-keep 'cdr '((1 2 3) (4 5) (6))) => '((2 3) (5))
+    (-keep (lambda (num) (when (> num 3) (* 10 num))) '(1 2 3 4 5 6)) => '(40 
50 60)
+    (--keep (when (> it 3) (* 10 it)) '(1 2 3 4 5 6)) => '(40 50 60))
+
+  (defexamples -map-when
+    (-map-when 'even? 'square '(1 2 3 4)) => '(1 4 3 16)
+    (--map-when (> it 2) (* it it) '(1 2 3 4)) => '(1 2 9 16)
+    (--map-when (= it 2) 17 '(1 2 3 4)) => '(1 17 3 4)
+    (-map-when (lambda (n) (= n 3)) (lambda (n) 0) '(1 2 3 4)) => '(1 2 0 4))
+
+  (defexamples -map-indexed
+    (-map-indexed (lambda (index item) (- item index)) '(1 2 3 4)) => '(1 1 1 
1)
+    (--map-indexed (- it it-index) '(1 2 3 4)) => '(1 1 1 1))
+
+  (defexamples -flatten
+    (-flatten '((1))) => '(1)
+    (-flatten '((1 (2 3) (((4 (5))))))) => '(1 2 3 4 5)
+    (-flatten '(1 2 (3 . 4))) => '(1 2 (3 . 4)))
+
+  (defexamples -concat
+    (-concat '(1)) => '(1)
+    (-concat '(1) '(2)) => '(1 2)
+    (-concat '(1) '(2 3) '(4)) => '(1 2 3 4)
+    (-concat) => nil)
+
+  (defexamples -mapcat
+    (-mapcat 'list '(1 2 3)) => '(1 2 3)
+    (-mapcat (lambda (item) (list 0 item)) '(1 2 3)) => '(0 1 0 2 0 3)
+    (--mapcat (list 0 it) '(1 2 3)) => '(0 1 0 2 0 3))
+
+  (defexamples -slice
+    (-slice '(1 2 3 4 5) 1) => '(2 3 4 5)
+    (-slice '(1 2 3 4 5) 0 3) => '(1 2 3)
+    (-slice '(1 2 3 4 5) 1 -1) => '(2 3 4))
+
+  (defexamples -take
+    (-take 3 '(1 2 3 4 5)) => '(1 2 3)
+    (-take 17 '(1 2 3 4 5)) => '(1 2 3 4 5))
+
+  (defexamples -drop
+    (-drop 3 '(1 2 3 4 5)) => '(4 5)
+    (-drop 17 '(1 2 3 4 5)) => '())
+
+  (defexamples -take-while
+    (-take-while 'even? '(1 2 3 4)) => '()
+    (-take-while 'even? '(2 4 5 6)) => '(2 4)
+    (--take-while (< it 4) '(1 2 3 4 3 2 1)) => '(1 2 3))
+
+  (defexamples -drop-while
+    (-drop-while 'even? '(1 2 3 4)) => '(1 2 3 4)
+    (-drop-while 'even? '(2 4 5 6)) => '(5 6)
+    (--drop-while (< it 4) '(1 2 3 4 3 2 1)) => '(4 3 2 1))
+
+  (defexamples -rotate
+    (-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))
+
+  (defexamples -insert-at
+    (-insert-at 1 'x '(a b c)) => '(a x b c)
+    (-insert-at 12 'x '(a b c)) => '(a b c x)))
+
+(def-example-group "Reductions" nil
+  (defexamples -reduce-from
+    (-reduce-from '- 10 '(1 2 3)) => 4
+    (-reduce-from (lambda (memo item)
                     (concat "(" memo " - " (int-to-string item) ")")) "10" '(1 
2 3)) => "(((10 - 1) - 2) - 3)"
-  (--reduce-from (concat acc " " it) "START" '("a" "b" "c")) => "START a b c"
-  (-reduce-from '+ 7 '()) => 7
-  (-reduce-from '+ 7 '(1)) => 8)
-
-(defexamples -reduce-r-from
-  (-reduce-r-from '- 10 '(1 2 3)) => -8
-  (-reduce-r-from (lambda (item memo)
-                    (concat "(" (int-to-string item) " - " memo ")")) "10" '(1 
2 3)) => "(1 - (2 - (3 - 10)))"
-  (--reduce-r-from (concat it " " acc) "END" '("a" "b" "c")) => "a b c END"
-  (-reduce-r-from '+ 7 '()) => 7
-  (-reduce-r-from '+ 7 '(1)) => 8)
-
-(defexamples -reduce
-  (-reduce '- '(1 2 3 4)) => -8
-  (-reduce (lambda (memo item) (format "%s-%s" memo item)) '(1 2 3)) => "1-2-3"
-  (--reduce (format "%s-%s" acc it) '(1 2 3)) => "1-2-3"
-  (-reduce '+ '()) => 0
-  (-reduce '+ '(1)) => 1
-  (--reduce (format "%s-%s" acc it) '()) => "nil-nil")
-
-(defexamples -reduce-r
-  (-reduce-r '- '(1 2 3 4)) => -2
-  (-reduce-r (lambda (item memo) (format "%s-%s" memo item)) '(1 2 3)) => 
"3-2-1"
-  (--reduce-r (format "%s-%s" acc it) '(1 2 3)) => "3-2-1"
-  (-reduce-r '+ '()) => 0
-  (-reduce-r '+ '(1)) => 1
-  (--reduce-r (format "%s-%s" it acc) '()) => "nil-nil")
-
-(defexamples -filter
-  (-filter (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) => '(2 4)
-  (-filter 'even? '(1 2 3 4)) => '(2 4)
-  (--filter (= 0 (% it 2)) '(1 2 3 4)) => '(2 4))
-
-(defexamples -remove
-  (-remove (lambda (num) (= 0 (% num 2))) '(1 2 3 4)) => '(1 3)
-  (-remove 'even? '(1 2 3 4)) => '(1 3)
-  (--remove (= 0 (% it 2)) '(1 2 3 4)) => '(1 3)
-  (let ((mod 2)) (-remove (lambda (num) (= 0 (% num mod))) '(1 2 3 4))) => '(1 
3)
-  (let ((mod 2)) (--remove (= 0 (% it mod)) '(1 2 3 4))) => '(1 3))
-
-(defexamples -keep
-  (-keep 'cdr '((1 2 3) (4 5) (6))) => '((2 3) (5))
-  (-keep (lambda (num) (when (> num 3) (* 10 num))) '(1 2 3 4 5 6)) => '(40 50 
60)
-  (--keep (when (> it 3) (* 10 it)) '(1 2 3 4 5 6)) => '(40 50 60))
-
-(defexamples -map-when
-  (-map-when 'even? 'square '(1 2 3 4)) => '(1 4 3 16)
-  (--map-when (> it 2) (* it it) '(1 2 3 4)) => '(1 2 9 16)
-  (--map-when (= it 2) 17 '(1 2 3 4)) => '(1 17 3 4)
-  (-map-when (lambda (n) (= n 3)) (lambda (n) 0) '(1 2 3 4)) => '(1 2 0 4))
-
-(defexamples -map-indexed
-  (-map-indexed (lambda (index item) (- item index)) '(1 2 3 4)) => '(1 1 1 1)
-  (--map-indexed (- it it-index) '(1 2 3 4)) => '(1 1 1 1))
-
-(defexamples -flatten
-  (-flatten '((1))) => '(1)
-  (-flatten '((1 (2 3) (((4 (5))))))) => '(1 2 3 4 5)
-  (-flatten '(1 2 (3 . 4))) => '(1 2 (3 . 4)))
-
-(defexamples -concat
-  (-concat '(1)) => '(1)
-  (-concat '(1) '(2)) => '(1 2)
-  (-concat '(1) '(2 3) '(4)) => '(1 2 3 4)
-  (-concat) => nil)
-
-(defexamples -mapcat
-  (-mapcat 'list '(1 2 3)) => '(1 2 3)
-  (-mapcat (lambda (item) (list 0 item)) '(1 2 3)) => '(0 1 0 2 0 3)
-  (--mapcat (list 0 it) '(1 2 3)) => '(0 1 0 2 0 3))
-
-(defexamples -cons*
-  (-cons* 1 2) => '(1 . 2)
-  (-cons* 1 2 3) => '(1 2 . 3)
-  (-cons* 1) => 1)
-
-(defexamples -count
-  (-count 'even? '(1 2 3 4 5)) => 2
-  (--count (< it 4) '(1 2 3 4)) => 3)
-
-(defexamples -sum
-  (-sum '()) => 0
-  (-sum '(1)) => 1
-  (-sum '(1 2 3)) => 6)
-
-(defexamples -product
-  (-product '()) => 1
-  (-product '(1)) => 1
-  (-product '(1 2 3)) => 6)
-
-(defexamples -min
-  (-min '(0)) => 0
-  (-min '(3 2 1)) => 1
-  (-min '(1 2 3)) => 1)
-
-(unless (version< emacs-version "24") ;; required for -on
- (defexamples -min-by
-   (-min-by '> '(4 3 6 1)) => 1
-   (-min-by (-on '> 'length) '((1 2 3) (1) (1 2))) => '(1)
-   (--min-by (> (length it) (length other)) '((1 2 3) (1) (1 2))) => '(1)
-   (-min-by (-on 'string-lessp 'int-to-string) '(2 100 22)) => 22
-   (-min-by '< '(4 3 6 1)) => 6))
-
-(defexamples -max
-  (-max '(0)) => 0
-  (-max '(3 2 1)) => 3
-  (-max '(1 2 3)) => 3)
-
-(unless (version< emacs-version "24") ;; required for -on
- (defexamples -max-by
-   (-max-by '> '(4 3 6 1)) => 6
-   (-max-by (-on '> 'car) '((2 2 3) (3) (1 2))) => '(3)
-   (--max-by (> (car it) (car other)) '((2 2 3) (3) (1 2))) => '(3)
-   (-max-by (-on '> 'string-to-int) '("1" "2" "3")) => "3"
-   (-max-by '< '(4 3 6 1)) => 1))
-
-(defexamples -any?
-  (-any? 'even? '(1 2 3)) => t
-  (-any? 'even? '(1 3 5)) => nil
-  (--any? (= 0 (% it 2)) '(1 2 3)) => t)
-
-(defexamples -all?
-  (-all? 'even? '(1 2 3)) => nil
-  (-all? 'even? '(2 4 6)) => t
-  (--all? (= 0 (% it 2)) '(2 4 6)) => t)
-
-(defexamples -none?
-  (-none? 'even? '(1 2 3)) => nil
-  (-none? 'even? '(1 3 5)) => t
-  (--none? (= 0 (% it 2)) '(1 2 3)) => nil)
-
-(defexamples -only-some?
-  (-only-some? 'even? '(1 2 3)) => t
-  (-only-some? 'even? '(1 3 5)) => nil
-  (-only-some? 'even? '(2 4 6)) => nil
-  (--only-some? (> it 2) '(1 2 3)) => t)
-
-(defexamples -each
-  (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) => nil
-  (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s)))) s) => '(3 2 
1)
-  (let (s) (--each '(1 2 3) (setq s (cons it s))) s) => '(3 2 1)
-  (let (s) (--each (reverse (three-letters)) (setq s (cons it s))) s) => '("A" 
"B" "C"))
-
-(defexamples -each-while
-  (let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) 
=> '(4 2)
-  (let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) => '(2 1))
-
-(defexamples -dotimes
-  (let (s) (-dotimes 3 (lambda (n) (!cons n s))) s) => '(2 1 0)
-  (let (s) (--dotimes 5 (!cons it s)) s) => '(4 3 2 1 0))
-
-(defexamples -repeat
-  (-repeat 3 :a) => '(:a :a :a)
-  (-repeat 1 :a) => '(:a)
-  (-repeat 0 :a) => nil
-  (-repeat -1 :a) => nil)
-
-(defexamples -slice
-  (-slice '(1 2 3 4 5) 1) => '(2 3 4 5)
-  (-slice '(1 2 3 4 5) 0 3) => '(1 2 3)
-  (-slice '(1 2 3 4 5) 1 -1) => '(2 3 4))
-
-(defexamples -take
-  (-take 3 '(1 2 3 4 5)) => '(1 2 3)
-  (-take 17 '(1 2 3 4 5)) => '(1 2 3 4 5))
-
-(defexamples -drop
-  (-drop 3 '(1 2 3 4 5)) => '(4 5)
-  (-drop 17 '(1 2 3 4 5)) => '())
-
-(defexamples -take-while
-  (-take-while 'even? '(1 2 3 4)) => '()
-  (-take-while 'even? '(2 4 5 6)) => '(2 4)
-  (--take-while (< it 4) '(1 2 3 4 3 2 1)) => '(1 2 3))
-
-(defexamples -drop-while
-  (-drop-while 'even? '(1 2 3 4)) => '(1 2 3 4)
-  (-drop-while 'even? '(2 4 5 6)) => '(5 6)
-  (--drop-while (< it 4) '(1 2 3 4 3 2 1)) => '(4 3 2 1))
-
-(defexamples -split-at
-  (-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))
-
-(defexamples -rotate
-  (-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))
-
-(defexamples -insert-at
-  (-insert-at 1 'x '(a b c)) => '(a x b c)
-  (-insert-at 12 'x '(a b c)) => '(a b c x))
-
-(defexamples -split-with
-  (-split-with 'even? '(1 2 3 4)) => '(() (1 2 3 4))
-  (-split-with 'even? '(2 4 5 6)) => '((2 4) (5 6))
-  (--split-with (< it 4) '(1 2 3 4 3 2 1)) => '((1 2 3) (4 3 2 1)))
-
-(defexamples -separate
-  (-separate (lambda (num) (= 0 (% num 2))) '(1 2 3 4 5 6 7)) => '((2 4 6) (1 
3 5 7))
-  (--separate (< it 5) '(3 7 5 9 3 2 1 4 6)) => '((3 3 2 1 4) (7 5 9 6))
-  (-separate 'cdr '((1 2) (1) (1 2 3) (4))) => '(((1 2) (1 2 3)) ((1) (4))))
-
-(defexamples -partition
-  (-partition 2 '(1 2 3 4 5 6)) => '((1 2) (3 4) (5 6))
-  (-partition 2 '(1 2 3 4 5 6 7)) => '((1 2) (3 4) (5 6))
-  (-partition 3 '(1 2 3 4 5 6 7)) => '((1 2 3) (4 5 6)))
-
-(defexamples -partition-all-in-steps
-  (-partition-all-in-steps 2 1 '(1 2 3 4)) => '((1 2) (2 3) (3 4) (4))
-  (-partition-all-in-steps 3 2 '(1 2 3 4)) => '((1 2 3) (3 4))
-  (-partition-all-in-steps 3 2 '(1 2 3 4 5)) => '((1 2 3) (3 4 5) (5))
-  (-partition-all-in-steps 2 1 '(1)) => '((1)))
-
-(defexamples -partition-in-steps
-  (-partition-in-steps 2 1 '(1 2 3 4)) => '((1 2) (2 3) (3 4))
-  (-partition-in-steps 3 2 '(1 2 3 4)) => '((1 2 3))
-  (-partition-in-steps 3 2 '(1 2 3 4 5)) => '((1 2 3) (3 4 5))
-  (-partition-in-steps 2 1 '(1)) => '())
-
-(defexamples -partition-all
-  (-partition-all 2 '(1 2 3 4 5 6)) => '((1 2) (3 4) (5 6))
-  (-partition-all 2 '(1 2 3 4 5 6 7)) => '((1 2) (3 4) (5 6) (7))
-  (-partition-all 3 '(1 2 3 4 5 6 7)) => '((1 2 3) (4 5 6) (7)))
-
-(defexamples -partition-by
-  (-partition-by 'even? '()) => '()
-  (-partition-by 'even? '(1 1 2 2 2 3 4 6 8)) => '((1 1) (2 2 2) (3) (4 6 8))
-  (--partition-by (< it 3) '(1 2 3 4 3 2 1)) => '((1 2) (3 4 3) (2 1)))
-
-(defexamples -partition-by-header
-  (--partition-by-header (= it 1) '(1 2 3 1 2 1 2 3 4)) => '((1 2 3) (1 2) (1 
2 3 4))
-  (--partition-by-header (> it 0) '(1 2 0 1 0 1 2 3 0)) => '((1 2 0) (1 0) (1 
2 3 0))
-  (-partition-by-header 'even? '(2 1 1 1 4 1 3 5 6 6 1)) => '((2 1 1 1) (4 1 3 
5) (6 6 1)))
-
-(defexamples -group-by
-  (-group-by 'even? '()) => '()
-  (-group-by 'even? '(1 1 2 2 2 3 4 6 8)) => '((nil . (1 1 3)) (t . (2 2 2 4 6 
8)))
-  (--group-by (car (split-string it "/")) '("a/b" "c/d" "a/e")) => '(("a" . 
("a/b" "a/e")) ("c" . ("c/d"))))
-
-(defexamples -interpose
-  (-interpose "-" '()) => '()
-  (-interpose "-" '("a")) => '("a")
-  (-interpose "-" '("a" "b" "c")) => '("a" "-" "b" "-" "c"))
-
-(defexamples -interleave
-  (-interleave '(1 2) '("a" "b")) => '(1 "a" 2 "b")
-  (-interleave '(1 2) '("a" "b") '("A" "B")) => '(1 "a" "A" 2 "b" "B")
-  (-interleave '(1 2 3) '("a" "b")) => '(1 "a" 2 "b")
-  (-interleave '(1 2 3) '("a" "b" "c" "d")) => '(1 "a" 2 "b" 3 "c"))
-
-(defexamples -zip-with
-  (-zip-with '+ '(1 2 3) '(4 5 6)) => '(5 7 9)
-  (-zip-with 'cons '(1 2 3) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
-  (--zip-with (concat it " and " other) '("Batman" "Jekyll") '("Robin" 
"Hyde")) => '("Batman and Robin" "Jekyll and Hyde"))
-
-(defexamples -zip
-  (-zip '(1 2 3) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
-  (-zip '(1 2 3) '(4 5 6 7)) => '((1 . 4) (2 . 5) (3 . 6))
-  (-zip '(1 2 3 4) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6)))
-
-(defexamples -first
-  (-first 'even? '(1 2 3)) => 2
-  (-first 'even? '(1 3 5)) => nil
-  (--first (> it 2) '(1 2 3)) => 3)
-
-(defexamples -last
-  (-last 'even? '(1 2 3 4 5 6 3 3 3)) => 6
-  (-last 'even? '(1 3 7 5 9)) => nil
-  (--last (> (length it) 3) '("a" "looong" "word" "and" "short" "one")) => 
"short")
-
-(defexamples -first-item
-  (-first-item '(1 2 3)) => 1
-  (-first-item nil) => nil)
-
-(defexamples -last-item
-  (-last-item '(1 2 3)) => 3
-  (-last-item nil) => nil)
-
-(defexamples -union
-  (-union '(1 2 3) '(3 4 5))  => '(1 2 3 4 5)
-  (-union '(1 2 3 4) '())  => '(1 2 3 4)
-  (-union '(1 1 2 2) '(3 2 1))  => '(1 1 2 2 3))
-
-(defexamples -difference
-  (-difference '() '()) => '()
-  (-difference '(1 2 3) '(4 5 6)) => '(1 2 3)
-  (-difference '(1 2 3 4) '(3 4 5 6)) => '(1 2))
-
-(defexamples -intersection
-  (-intersection '() '()) => '()
-  (-intersection '(1 2 3) '(4 5 6)) => '()
-  (-intersection '(1 2 3 4) '(3 4 5 6)) => '(3 4))
-
-(defexamples -distinct
-  (-distinct '()) => '()
-  (-distinct '(1 2 2 4)) => '(1 2 4))
-
-(defexamples -contains?
-  (-contains? '(1 2 3) 1) => t
-  (-contains? '(1 2 3) 2) => t
-  (-contains? '(1 2 3) 4) => nil
-  (-contains? '() 1) => nil
-  (-contains? '() '()) => nil)
-
-(defexamples -sort
-  (-sort '< '(3 1 2)) => '(1 2 3)
-  (-sort '> '(3 1 2)) => '(3 2 1)
-  (--sort (< it other) '(3 1 2)) => '(1 2 3)
-  (let ((l '(3 1 2))) (-sort '> l) l) => '(3 1 2))
-
-(defexamples ->
-  (-> "Abc") => "Abc"
-  (-> "Abc" (concat "def")) => "Abcdef"
-  (-> "Abc" (concat "def") (concat "ghi")) => "Abcdefghi"
-  (-> 5 square) => 25
-  (-> 5 (+ 3) square) => 64)
-
-(defexamples ->>
-  (->> "Abc" (concat "def")) => "defAbc"
-  (->> "Abc" (concat "def") (concat "ghi")) => "ghidefAbc"
-  (->> 5 (- 8)) => 3
-  (->> 5 (- 3) square) => 4)
-
-(defexamples -->
-  (--> "def" (concat "abc" it "ghi")) => "abcdefghi"
-  (--> "def" (concat "abc" it "ghi") (upcase it)) => "ABCDEFGHI"
-  (--> "def" (concat "abc" it "ghi") upcase) => "ABCDEFGHI")
-
-(defexamples -when-let
-  (-when-let (match-index (string-match "d" "abcd")) (+ match-index 2)) => 5
-  (--when-let (member :b '(:a :b :c)) (cons :d it)) => '(:d :b :c)
-  (--when-let (even? 3) (cat it :a)) => nil)
-
-(defexamples -when-let*
-  (-when-let* ((x 5) (y 3) (z (+ y 4))) (+ x y z)) => 15
-  (-when-let* ((x 5) (y nil) (z 7)) (+ x y z)) => nil)
-
-(defexamples -if-let
-  (-if-let (match-index (string-match "d" "abc")) (+ match-index 3) 7) => 7
-  (--if-let (even? 4) it nil) => t)
-
-(defexamples -if-let*
-  (-if-let* ((x 5) (y 3) (z 7)) (+ x y z) "foo") => 15
-  (-if-let* ((x 5) (y nil) (z 7)) (+ x y z) "foo") => "foo")
-
-(defexamples -partial
-  (funcall (-partial '- 5) 3) => 2
-  (funcall (-partial '+ 5 2) 3) => 10)
-
-(unless (version< emacs-version "24")
-  (defexamples -rpartial
-    (funcall (-rpartial '- 5) 8) => 3
-    (funcall (-rpartial '- 5 2) 10) => 3)
-
-  (defexamples -juxt
-    (funcall (-juxt '+ '-) 3 5) => '(8 -2)
-    (-map (-juxt 'identity 'square) '(1 2 3)) => '((1 1) (2 4) (3 9))))
-
-(defexamples -applify
-  (-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5))) => '(3 6 15)
-  (-map (-applify (lambda (a b c) `(,a (,b (,c))))) '((1 1 1) (1 2 3) (5 5 
5))) => '((1 (1 (1))) (1 (2 (3))) (5 (5 (5))))
-  (funcall (-applify '<) '(3 6)) => t)
-
-(unless (version< emacs-version "24")
-  (defexamples -on
-    (-sort (-on '< 'length) '((1 2 3) (1) (1 2))) => '((1) (1 2) (1 2 3))
-    (-sort (-on 'string-lessp 'int-to-string) '(10 12 1 2 22)) => '(1 10 12 2 
22)
-    (funcall (-on '+ '1+) 1 2) => 5
-    (funcall (-on '+ 'identity) 1 2) => 3
-    (funcall (-on '* 'length) '(1 2 3) '(4 5)) => 6
-    (funcall (-on (-on '+ 'length) 'cdr) '(1 2 3) '(4 5)) => 3
-    (funcall (-on '+ (lambda (x) (length (cdr x)))) '(1 2 3) '(4 5)) => 3
-    (-sort (-on '< 'car) '((3 2 5) (2) (1 2))) => '((1 2) (2) (3 2 5))
-    (-sort (-on '< (lambda (x) (length x))) '((1 2 3) (1) (1 2))) => '((1) (1 
2) (1 2 3))
-    (-sort (-on (-on '< 'car) 'cdr) '((0 3) (2 1) (4 2 8))) => '((2 1) (4 2 8) 
(0 3))
-    (-sort (-on '< 'cadr) '((0 3) (2 1) (4 2 8))) => '((2 1) (4 2 8) (0 3)))
-
-  (defexamples -flip
-    (funcall (-flip '<) 2 1) => t
-    (funcall (-flip '-) 3 8) => 5
-    (-sort (-flip '<) '(4 3 6 1)) => '(6 4 3 1))
-
-  (defexamples -const
-    (funcall (-const 2) 1 3 "foo") => 2
-    (-map (-const 1) '("a" "b" "c" "d")) => '(1 1 1 1)
-    (-sum (-map (-const 1) '("a" "b" "c" "d"))) => 4)
-
-  (defexamples -cut
-    (funcall (-cut list 1 <> 3 <> 5) 2 4) => '(1 2 3 4 5)
-    (-map (-cut funcall <> 5) '(1+ 1- (lambda (x) (/ 1.0 x)))) => '(6 4 0.2)
-    (-filter (-cut < <> 5) '(1 3 5 7 9)) => '(1 3))
-
-  (defexamples -not
-    (funcall (-not 'even?) 5) => t
-    (-filter (-not (-partial '< 4)) '(1 2 3 4 5 6 7 8)) => '(1 2 3 4))
-
-  (defexamples -orfn
-    (-filter (-orfn 'even? (-partial (-flip '<) 5)) '(1 2 3 4 5 6 7 8 9 10)) 
=> '(1 2 3 4 6 8 10)
-    (funcall (-orfn 'stringp 'even?) "foo") => t)
-
-  (defexamples -andfn
-    (funcall (-andfn (-cut < <> 10) 'even?) 6) => t
-    (funcall (-andfn (-cut < <> 10) 'even?) 12) => nil
-    (-filter (-andfn (-not 'even?) (-cut >= 5 <>)) '(1 2 3 4 5 6 7 8 9 10)) => 
'(1 3 5))
-  )
-
-(defexamples !cons
-  (let (l) (!cons 5 l) l) => '(5)
-  (let ((l '(3))) (!cons 5 l) l) => '(5 3))
-
-(defexamples !cdr
-  (let ((l '(3))) (!cdr l) l) => '()
-  (let ((l '(3 5))) (!cdr l) l) => '(5))
+                    (--reduce-from (concat acc " " it) "START" '("a" "b" "c")) 
=> "START a b c"
+                    (-reduce-from '+ 7 '()) => 7
+                    (-reduce-from '+ 7 '(1)) => 8)
+
+  (defexamples -reduce-r-from
+    (-reduce-r-from '- 10 '(1 2 3)) => -8
+    (-reduce-r-from (lambda (item memo)
+                      (concat "(" (int-to-string item) " - " memo ")")) "10" 
'(1 2 3)) => "(1 - (2 - (3 - 10)))"
+                      (--reduce-r-from (concat it " " acc) "END" '("a" "b" 
"c")) => "a b c END"
+                      (-reduce-r-from '+ 7 '()) => 7
+                      (-reduce-r-from '+ 7 '(1)) => 8)
+
+  (defexamples -reduce
+    (-reduce '- '(1 2 3 4)) => -8
+    (-reduce (lambda (memo item) (format "%s-%s" memo item)) '(1 2 3)) => 
"1-2-3"
+    (--reduce (format "%s-%s" acc it) '(1 2 3)) => "1-2-3"
+    (-reduce '+ '()) => 0
+    (-reduce '+ '(1)) => 1
+    (--reduce (format "%s-%s" acc it) '()) => "nil-nil")
+
+  (defexamples -reduce-r
+    (-reduce-r '- '(1 2 3 4)) => -2
+    (-reduce-r (lambda (item memo) (format "%s-%s" memo item)) '(1 2 3)) => 
"3-2-1"
+    (--reduce-r (format "%s-%s" acc it) '(1 2 3)) => "3-2-1"
+    (-reduce-r '+ '()) => 0
+    (-reduce-r '+ '(1)) => 1
+    (--reduce-r (format "%s-%s" it acc) '()) => "nil-nil")
+
+  (defexamples -count
+    (-count 'even? '(1 2 3 4 5)) => 2
+    (--count (< it 4) '(1 2 3 4)) => 3)
+
+  (defexamples -sum
+    (-sum '()) => 0
+    (-sum '(1)) => 1
+    (-sum '(1 2 3)) => 6)
+
+  (defexamples -product
+    (-product '()) => 1
+    (-product '(1)) => 1
+    (-product '(1 2 3)) => 6)
+
+  (defexamples -min
+    (-min '(0)) => 0
+    (-min '(3 2 1)) => 1
+    (-min '(1 2 3)) => 1)
+
+  (unless (version< emacs-version "24") ;; required for -on
+    (defexamples -min-by
+      (-min-by '> '(4 3 6 1)) => 1
+      (-min-by (-on '> 'length) '((1 2 3) (1) (1 2))) => '(1)
+      (--min-by (> (length it) (length other)) '((1 2 3) (1) (1 2))) => '(1)
+      (-min-by (-on 'string-lessp 'int-to-string) '(2 100 22)) => 22
+      (-min-by '< '(4 3 6 1)) => 6))
+
+  (defexamples -max
+    (-max '(0)) => 0
+    (-max '(3 2 1)) => 3
+    (-max '(1 2 3)) => 3)
+
+  (unless (version< emacs-version "24") ;; required for -on
+    (defexamples -max-by
+      (-max-by '> '(4 3 6 1)) => 6
+      (-max-by (-on '> 'car) '((2 2 3) (3) (1 2))) => '(3)
+      (--max-by (> (car it) (car other)) '((2 2 3) (3) (1 2))) => '(3)
+      (-max-by (-on '> 'string-to-int) '("1" "2" "3")) => "3"
+      (-max-by '< '(4 3 6 1)) => 1)))
+
+(def-example-group "Predicates" nil
+  (defexamples -any?
+    (-any? 'even? '(1 2 3)) => t
+    (-any? 'even? '(1 3 5)) => nil
+    (--any? (= 0 (% it 2)) '(1 2 3)) => t)
+
+  (defexamples -all?
+    (-all? 'even? '(1 2 3)) => nil
+    (-all? 'even? '(2 4 6)) => t
+    (--all? (= 0 (% it 2)) '(2 4 6)) => t)
+
+  (defexamples -none?
+    (-none? 'even? '(1 2 3)) => nil
+    (-none? 'even? '(1 3 5)) => t
+    (--none? (= 0 (% it 2)) '(1 2 3)) => nil)
+
+  (defexamples -only-some?
+    (-only-some? 'even? '(1 2 3)) => t
+    (-only-some? 'even? '(1 3 5)) => nil
+    (-only-some? 'even? '(2 4 6)) => nil
+    (--only-some? (> it 2) '(1 2 3)) => t)
+
+  (defexamples -contains?
+    (-contains? '(1 2 3) 1) => t
+    (-contains? '(1 2 3) 2) => t
+    (-contains? '(1 2 3) 4) => nil
+    (-contains? '() 1) => nil
+    (-contains? '() '()) => nil))
+
+(def-example-group "Partitioning" nil
+  (defexamples -split-at
+    (-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))
+
+  (defexamples -split-with
+    (-split-with 'even? '(1 2 3 4)) => '(() (1 2 3 4))
+    (-split-with 'even? '(2 4 5 6)) => '((2 4) (5 6))
+    (--split-with (< it 4) '(1 2 3 4 3 2 1)) => '((1 2 3) (4 3 2 1)))
+
+  (defexamples -separate
+    (-separate (lambda (num) (= 0 (% num 2))) '(1 2 3 4 5 6 7)) => '((2 4 6) 
(1 3 5 7))
+    (--separate (< it 5) '(3 7 5 9 3 2 1 4 6)) => '((3 3 2 1 4) (7 5 9 6))
+    (-separate 'cdr '((1 2) (1) (1 2 3) (4))) => '(((1 2) (1 2 3)) ((1) (4))))
+
+  (defexamples -partition
+    (-partition 2 '(1 2 3 4 5 6)) => '((1 2) (3 4) (5 6))
+    (-partition 2 '(1 2 3 4 5 6 7)) => '((1 2) (3 4) (5 6))
+    (-partition 3 '(1 2 3 4 5 6 7)) => '((1 2 3) (4 5 6)))
+
+  (defexamples -partition-all-in-steps
+    (-partition-all-in-steps 2 1 '(1 2 3 4)) => '((1 2) (2 3) (3 4) (4))
+    (-partition-all-in-steps 3 2 '(1 2 3 4)) => '((1 2 3) (3 4))
+    (-partition-all-in-steps 3 2 '(1 2 3 4 5)) => '((1 2 3) (3 4 5) (5))
+    (-partition-all-in-steps 2 1 '(1)) => '((1)))
+
+  (defexamples -partition-in-steps
+    (-partition-in-steps 2 1 '(1 2 3 4)) => '((1 2) (2 3) (3 4))
+    (-partition-in-steps 3 2 '(1 2 3 4)) => '((1 2 3))
+    (-partition-in-steps 3 2 '(1 2 3 4 5)) => '((1 2 3) (3 4 5))
+    (-partition-in-steps 2 1 '(1)) => '())
+
+  (defexamples -partition-all
+    (-partition-all 2 '(1 2 3 4 5 6)) => '((1 2) (3 4) (5 6))
+    (-partition-all 2 '(1 2 3 4 5 6 7)) => '((1 2) (3 4) (5 6) (7))
+    (-partition-all 3 '(1 2 3 4 5 6 7)) => '((1 2 3) (4 5 6) (7)))
+
+  (defexamples -partition-by
+    (-partition-by 'even? '()) => '()
+    (-partition-by 'even? '(1 1 2 2 2 3 4 6 8)) => '((1 1) (2 2 2) (3) (4 6 8))
+    (--partition-by (< it 3) '(1 2 3 4 3 2 1)) => '((1 2) (3 4 3) (2 1)))
+
+  (defexamples -partition-by-header
+    (--partition-by-header (= it 1) '(1 2 3 1 2 1 2 3 4)) => '((1 2 3) (1 2) 
(1 2 3 4))
+    (--partition-by-header (> it 0) '(1 2 0 1 0 1 2 3 0)) => '((1 2 0) (1 0) 
(1 2 3 0))
+    (-partition-by-header 'even? '(2 1 1 1 4 1 3 5 6 6 1)) => '((2 1 1 1) (4 1 
3 5) (6 6 1)))
+
+  (defexamples -group-by
+    (-group-by 'even? '()) => '()
+    (-group-by 'even? '(1 1 2 2 2 3 4 6 8)) => '((nil . (1 1 3)) (t . (2 2 2 4 
6 8)))
+    (--group-by (car (split-string it "/")) '("a/b" "c/d" "a/e")) => '(("a" . 
("a/b" "a/e")) ("c" . ("c/d")))))
+
+(def-example-group "Set operations" nil
+  (defexamples -union
+    (-union '(1 2 3) '(3 4 5))  => '(1 2 3 4 5)
+    (-union '(1 2 3 4) '())  => '(1 2 3 4)
+    (-union '(1 1 2 2) '(3 2 1))  => '(1 1 2 2 3))
+
+  (defexamples -difference
+    (-difference '() '()) => '()
+    (-difference '(1 2 3) '(4 5 6)) => '(1 2 3)
+    (-difference '(1 2 3 4) '(3 4 5 6)) => '(1 2))
+
+  (defexamples -intersection
+    (-intersection '() '()) => '()
+    (-intersection '(1 2 3) '(4 5 6)) => '()
+    (-intersection '(1 2 3 4) '(3 4 5 6)) => '(3 4))
+
+  (defexamples -distinct
+    (-distinct '()) => '()
+    (-distinct '(1 2 2 4)) => '(1 2 4)))
+
+(def-example-group "Other list operations" nil
+  (defexamples -repeat
+    (-repeat 3 :a) => '(:a :a :a)
+    (-repeat 1 :a) => '(:a)
+    (-repeat 0 :a) => nil
+    (-repeat -1 :a) => nil)
+
+  (defexamples -cons*
+    (-cons* 1 2) => '(1 . 2)
+    (-cons* 1 2 3) => '(1 2 . 3)
+    (-cons* 1) => 1)
+
+  (defexamples -interpose
+    (-interpose "-" '()) => '()
+    (-interpose "-" '("a")) => '("a")
+    (-interpose "-" '("a" "b" "c")) => '("a" "-" "b" "-" "c"))
+
+  (defexamples -interleave
+    (-interleave '(1 2) '("a" "b")) => '(1 "a" 2 "b")
+    (-interleave '(1 2) '("a" "b") '("A" "B")) => '(1 "a" "A" 2 "b" "B")
+    (-interleave '(1 2 3) '("a" "b")) => '(1 "a" 2 "b")
+    (-interleave '(1 2 3) '("a" "b" "c" "d")) => '(1 "a" 2 "b" 3 "c"))
+
+  (defexamples -zip-with
+    (-zip-with '+ '(1 2 3) '(4 5 6)) => '(5 7 9)
+    (-zip-with 'cons '(1 2 3) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
+    (--zip-with (concat it " and " other) '("Batman" "Jekyll") '("Robin" 
"Hyde")) => '("Batman and Robin" "Jekyll and Hyde"))
+
+  (defexamples -zip
+    (-zip '(1 2 3) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6))
+    (-zip '(1 2 3) '(4 5 6 7)) => '((1 . 4) (2 . 5) (3 . 6))
+    (-zip '(1 2 3 4) '(4 5 6)) => '((1 . 4) (2 . 5) (3 . 6)))
+
+  (defexamples -first
+    (-first 'even? '(1 2 3)) => 2
+    (-first 'even? '(1 3 5)) => nil
+    (--first (> it 2) '(1 2 3)) => 3)
+
+  (defexamples -last
+    (-last 'even? '(1 2 3 4 5 6 3 3 3)) => 6
+    (-last 'even? '(1 3 7 5 9)) => nil
+    (--last (> (length it) 3) '("a" "looong" "word" "and" "short" "one")) => 
"short")
+
+  (defexamples -first-item
+    (-first-item '(1 2 3)) => 1
+    (-first-item nil) => nil)
+
+  (defexamples -last-item
+    (-last-item '(1 2 3)) => 3
+    (-last-item nil) => nil)
+
+  (defexamples -sort
+    (-sort '< '(3 1 2)) => '(1 2 3)
+    (-sort '> '(3 1 2)) => '(3 2 1)
+    (--sort (< it other) '(3 1 2)) => '(1 2 3)
+    (let ((l '(3 1 2))) (-sort '> l) l) => '(3 1 2)))
+
+(def-example-group "Threading macros" nil
+  (defexamples ->
+    (-> "Abc") => "Abc"
+    (-> "Abc" (concat "def")) => "Abcdef"
+    (-> "Abc" (concat "def") (concat "ghi")) => "Abcdefghi"
+    (-> 5 square) => 25
+    (-> 5 (+ 3) square) => 64)
+
+  (defexamples ->>
+    (->> "Abc" (concat "def")) => "defAbc"
+    (->> "Abc" (concat "def") (concat "ghi")) => "ghidefAbc"
+    (->> 5 (- 8)) => 3
+    (->> 5 (- 3) square) => 4)
+
+  (defexamples -->
+    (--> "def" (concat "abc" it "ghi")) => "abcdefghi"
+    (--> "def" (concat "abc" it "ghi") (upcase it)) => "ABCDEFGHI"
+    (--> "def" (concat "abc" it "ghi") upcase) => "ABCDEFGHI"))
+
+(def-example-group "Binding" nil
+  (defexamples -when-let
+    (-when-let (match-index (string-match "d" "abcd")) (+ match-index 2)) => 5
+    (--when-let (member :b '(:a :b :c)) (cons :d it)) => '(:d :b :c)
+    (--when-let (even? 3) (cat it :a)) => nil)
+
+  (defexamples -when-let*
+    (-when-let* ((x 5) (y 3) (z (+ y 4))) (+ x y z)) => 15
+    (-when-let* ((x 5) (y nil) (z 7)) (+ x y z)) => nil)
+
+  (defexamples -if-let
+    (-if-let (match-index (string-match "d" "abc")) (+ match-index 3) 7) => 7
+    (--if-let (even? 4) it nil) => t)
+
+  (defexamples -if-let*
+    (-if-let* ((x 5) (y 3) (z 7)) (+ x y z) "foo") => 15
+    (-if-let* ((x 5) (y nil) (z 7)) (+ x y z) "foo") => "foo"))
+
+(def-example-group "Side-effects" nil
+  (defexamples -each
+    (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s))))) => nil
+    (let (s) (-each '(1 2 3) (lambda (item) (setq s (cons item s)))) s) => '(3 
2 1)
+    (let (s) (--each '(1 2 3) (setq s (cons it s))) s) => '(3 2 1)
+    (let (s) (--each (reverse (three-letters)) (setq s (cons it s))) s) => 
'("A" "B" "C"))
+
+  (defexamples -each-while
+    (let (s) (-each-while '(2 4 5 6) 'even? (lambda (item) (!cons item s))) s) 
=> '(4 2)
+    (let (s) (--each-while '(1 2 3 4) (< it 3) (!cons it s)) s) => '(2 1))
+
+  (defexamples -dotimes
+    (let (s) (-dotimes 3 (lambda (n) (!cons n s))) s) => '(2 1 0)
+    (let (s) (--dotimes 5 (!cons it s)) s) => '(4 3 2 1 0)))
+
+(def-example-group "Destructive operations" nil
+  (defexamples !cons
+    (let (l) (!cons 5 l) l) => '(5)
+    (let ((l '(3))) (!cons 5 l) l) => '(5 3))
+
+  (defexamples !cdr
+    (let ((l '(3))) (!cdr l) l) => '()
+    (let ((l '(3 5))) (!cdr l) l) => '(5)))
+
+(def-example-group "Function composition" "These combinators require Emacs 24 
for its lexical scope. So you'll have to include them with `(require 
'dash-functional)`."
+  (defexamples -partial
+    (funcall (-partial '- 5) 3) => 2
+    (funcall (-partial '+ 5 2) 3) => 10)
+
+  (unless (version< emacs-version "24")
+    (defexamples -rpartial
+      (funcall (-rpartial '- 5) 8) => 3
+      (funcall (-rpartial '- 5 2) 10) => 3)
+
+    (defexamples -juxt
+      (funcall (-juxt '+ '-) 3 5) => '(8 -2)
+      (-map (-juxt 'identity 'square) '(1 2 3)) => '((1 1) (2 4) (3 9))))
+
+  (defexamples -applify
+    (-map (-applify '+) '((1 1 1) (1 2 3) (5 5 5))) => '(3 6 15)
+    (-map (-applify (lambda (a b c) `(,a (,b (,c))))) '((1 1 1) (1 2 3) (5 5 
5))) => '((1 (1 (1))) (1 (2 (3))) (5 (5 (5))))
+    (funcall (-applify '<) '(3 6)) => t)
+
+  (unless (version< emacs-version "24")
+    (defexamples -on
+      (-sort (-on '< 'length) '((1 2 3) (1) (1 2))) => '((1) (1 2) (1 2 3))
+      (-sort (-on 'string-lessp 'int-to-string) '(10 12 1 2 22)) => '(1 10 12 
2 22)
+      (funcall (-on '+ '1+) 1 2) => 5
+      (funcall (-on '+ 'identity) 1 2) => 3
+      (funcall (-on '* 'length) '(1 2 3) '(4 5)) => 6
+      (funcall (-on (-on '+ 'length) 'cdr) '(1 2 3) '(4 5)) => 3
+      (funcall (-on '+ (lambda (x) (length (cdr x)))) '(1 2 3) '(4 5)) => 3
+      (-sort (-on '< 'car) '((3 2 5) (2) (1 2))) => '((1 2) (2) (3 2 5))
+      (-sort (-on '< (lambda (x) (length x))) '((1 2 3) (1) (1 2))) => '((1) 
(1 2) (1 2 3))
+      (-sort (-on (-on '< 'car) 'cdr) '((0 3) (2 1) (4 2 8))) => '((2 1) (4 2 
8) (0 3))
+      (-sort (-on '< 'cadr) '((0 3) (2 1) (4 2 8))) => '((2 1) (4 2 8) (0 3)))
+
+    (defexamples -flip
+      (funcall (-flip '<) 2 1) => t
+      (funcall (-flip '-) 3 8) => 5
+      (-sort (-flip '<) '(4 3 6 1)) => '(6 4 3 1))
+
+    (defexamples -const
+      (funcall (-const 2) 1 3 "foo") => 2
+      (-map (-const 1) '("a" "b" "c" "d")) => '(1 1 1 1)
+      (-sum (-map (-const 1) '("a" "b" "c" "d"))) => 4)
+
+    (defexamples -cut
+      (funcall (-cut list 1 <> 3 <> 5) 2 4) => '(1 2 3 4 5)
+      (-map (-cut funcall <> 5) '(1+ 1- (lambda (x) (/ 1.0 x)))) => '(6 4 0.2)
+      (-filter (-cut < <> 5) '(1 3 5 7 9)) => '(1 3))
+
+    (defexamples -not
+      (funcall (-not 'even?) 5) => t
+      (-filter (-not (-partial '< 4)) '(1 2 3 4 5 6 7 8)) => '(1 2 3 4))
+
+    (defexamples -orfn
+      (-filter (-orfn 'even? (-partial (-flip '<) 5)) '(1 2 3 4 5 6 7 8 9 10)) 
=> '(1 2 3 4 6 8 10)
+      (funcall (-orfn 'stringp 'even?) "foo") => t)
+
+    (defexamples -andfn
+      (funcall (-andfn (-cut < <> 10) 'even?) 6) => t
+      (funcall (-andfn (-cut < <> 10) 'even?) 12) => nil
+      (-filter (-andfn (-not 'even?) (-cut >= 5 <>)) '(1 2 3 4 5 6 7 8 9 10)) 
=> '(1 3 5))
+    ))
+
diff --git a/readme-template.md b/readme-template.md
index db1ed5a..070ab62 100644
--- a/readme-template.md
+++ b/readme-template.md
@@ -29,11 +29,11 @@ Or you can just dump `dash.el` in your load path somewhere.
 
 [[ function-list ]]
 
-There are also anaphoric versions of these functions where that makes sense,
-prefixed with two dashes instead of one.
-
 ## Anaphoric functions
 
+There are also anaphoric versions of functions where that makes sense,
+prefixed with two dashes instead of one.
+
 While `-map` takes a function to map over the list, you can also use
 the anaphoric form with double dashes - which will then be executed
 with `it` exposed as the list item. Here's an example: