emacs-elpa-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[elpa] fix/group-by-write-out 2aeeacb 07/14: Release 2.11.0


From: Phillip Lord
Subject: [elpa] fix/group-by-write-out 2aeeacb 07/14: Release 2.11.0
Date: Tue, 04 Aug 2015 19:45:06 +0000

branch: fix/group-by-write-out
commit 2aeeacb090479e326ce937e4f3bb33309241ffae
Author: Magnar Sveen <address@hidden>
Commit: Magnar Sveen <address@hidden>

    Release 2.11.0
---
 README.md          |   15 +-
 dash-template.texi |    6 +-
 dash.el            |    2 +-
 dash.info          |  523 ++++++++++++++++++++++++++++++++++------------------
 dash.texi          |   12 +-
 readme-template.md |    8 +-
 6 files changed, 372 insertions(+), 194 deletions(-)

diff --git a/README.md b/README.md
index d09d288..763a8ae 100644
--- a/README.md
+++ b/README.md
@@ -19,11 +19,11 @@ If you want the function combinators, then also:
 
 Add this to the big comment block at the top:
 
-    ;; Package-Requires: ((dash "2.10.0"))
+    ;; Package-Requires: ((dash "2.11.0"))
 
 To get function combinators:
 
-    ;; Package-Requires: ((dash "2.10.0") (dash-functional "1.2.0") (emacs 
"24"))
+    ;; Package-Requires: ((dash "2.11.0") (dash-functional "1.2.0") (emacs 
"24"))
 
 ## Syntax highlighting of dash functions
 
@@ -238,7 +238,7 @@ Functions pretending lists are trees.
 ### Threading macros
 
 * [->](#--x-optional-form-rest-more) `(x &optional form &rest more)`
-* [->>](#--x-form-rest-more) `(x form &rest more)`
+* [->>](#--x-optional-form-rest-more) `(x &optional form &rest more)`
 * [-->](#---x-form-rest-more) `(x form &rest more)`
 
 ### Binding
@@ -338,7 +338,7 @@ See also: [`-map-when`](#-map-when-pred-rep-list), 
[`-replace-first`](#-replace-
 
 #### -map-last `(pred rep list)`
 
-Replace last item in `list` satisfying `pred` with result of `rep` called on 
this item.
+Replace first item in `list` satisfying `pred` with result of `rep` called on 
this item.
 
 See also: [`-map-when`](#-map-when-pred-rep-list), 
[`-replace-last`](#-replace-last-old-new-list)
 
@@ -397,6 +397,7 @@ See also: [`-splice`](#-splice-pred-fun-list), 
[`-insert-at`](#-insert-at-n-x-li
 ```el
 (-splice-list 'keywordp '(a b c) '(1 :foo 2)) ;; => '(1 a b c 2)
 (-splice-list 'keywordp nil '(1 :foo 2)) ;; => '(1 2)
+(--splice-list (keywordp it) '(a b c) '(1 :foo 2)) ;; => '(1 a b c 2)
 ```
 
 #### -mapcat `(fn list)`
@@ -1741,7 +1742,7 @@ second item in second form, etc.
 (-> '(2 3 5) (append '(8 13)) (-slice 1 -1)) ;; => '(3 5 8)
 ```
 
-#### ->> `(x form &rest more)`
+#### ->> `(x &optional form &rest more)`
 
 Thread the expr through the forms. Insert `x` as the last item
 in the first form, making a list of it if it is not a list
@@ -2320,6 +2321,10 @@ Change `readme-template.md` or `examples-to-docs.el` 
instead.
 
 ## Changelist
 
+### From 2.10 to 2.11
+
+- Lots of clean up wrt byte compilation, debug macros and tests
+
 ### From 2.9 to 2.10
 
 - Add `-let` destructuring to `-if-let` and `-when-let` (Fredrik Bergroth)
diff --git a/dash-template.texi b/dash-template.texi
index 0e7dfc2..54071e2 100644
--- a/dash-template.texi
+++ b/dash-template.texi
@@ -13,7 +13,7 @@
 
 @copying
 
-This manual is for @code{dash.el} version 2.10.0.
+This manual is for @code{dash.el} version 2.11.0.
 
 Copyright © 2012-2015 Magnar Sveen
 
@@ -109,13 +109,13 @@ Alternatively, you can just dump @verb{~dash.el~} or
 Add this to the big comment block at the top:
 
 @lisp
-;; Package-Requires: ((dash "2.10.0"))
+;; Package-Requires: ((dash "2.11.0"))
 @end lisp
 
 @noindent To get function combinators:
 
 @lisp
-;; Package-Requires: ((dash "2.10.0") (dash-functional "1.2.0") (emacs "24"))
+;; Package-Requires: ((dash "2.11.0") (dash-functional "1.2.0") (emacs "24"))
 @end lisp
 
 @node Syntax highlighting of dash functions
diff --git a/dash.el b/dash.el
index 483b080..8a380b2 100644
--- a/dash.el
+++ b/dash.el
@@ -3,7 +3,7 @@
 ;; Copyright (C) 2012-2014 Magnar Sveen
 
 ;; Author: Magnar Sveen <address@hidden>
-;; Version: 2.10.0
+;; Version: 2.11.0
 ;; Keywords: lists
 
 ;; This program is free software; you can redistribute it and/or modify
diff --git a/dash.info b/dash.info
index 900f0d0..29d93ef 100644
--- a/dash.info
+++ b/dash.info
@@ -5,7 +5,7 @@ START-INFO-DIR-ENTRY
 * Dash: (dash.info). A modern list library for GNU Emacs
 END-INFO-DIR-ENTRY
 
-   This manual is for `dash.el' version 2.10.0.
+   This manual is for `dash.el' version 2.11.0.
 
    Copyright © 2012-2015 Magnar Sveen
 
@@ -29,7 +29,7 @@ File: dash.info,  Node: Top,  Next: Installation,  Up: (dir)
 dash
 ****
 
-This manual is for `dash.el' version 2.10.0.
+This manual is for `dash.el' version 2.11.0.
 
    Copyright © 2012-2015 Magnar Sveen
 
@@ -117,11 +117,11 @@ File: dash.info,  Node: Using in a package,  Next: Syntax 
highlighting of dash f
 
 Add this to the big comment block at the top:
 
-     ;; Package-Requires: ((dash "2.10.0"))
+     ;; Package-Requires: ((dash "2.11.0"))
 
 To get function combinators:
 
-     ;; Package-Requires: ((dash "2.10.0") (dash-functional "1.2.0") (emacs 
"24"))
+     ;; Package-Requires: ((dash "2.11.0") (dash-functional "1.2.0") (emacs 
"24"))
 
 
 File: dash.info,  Node: Syntax highlighting of dash functions,  Prev: Using in 
a package,  Up: Installation
@@ -221,6 +221,34 @@ list.  The results are collected in order and returned as 
new list.
           (--map-when (= it 2) 17 '(1 2 3 4))
               => '(1 17 3 4)
 
+ -- Function: -map-first (pred rep list)
+     Replace first item in LIST satisfying PRED with result of REP
+     called on this item.
+
+     See also: `-map-when' (*note -map-when::), `-replace-first'
+     (*note -replace-first::)
+
+          (-map-first 'even? 'square '(1 2 3 4))
+              => '(1 4 3 4)
+          (--map-first (> it 2) (* it it) '(1 2 3 4))
+              => '(1 2 9 4)
+          (--map-first (= it 2) 17 '(1 2 3 2))
+              => '(1 17 3 2)
+
+ -- Function: -map-last (pred rep list)
+     Replace first item in LIST satisfying PRED with result of REP
+     called on this item.
+
+     See also: `-map-when' (*note -map-when::), `-replace-last'
+     (*note -replace-last::)
+
+          (-map-last 'even? 'square '(1 2 3 4))
+              => '(1 2 3 16)
+          (--map-last (> it 2) (* it it) '(1 2 3 4))
+              => '(1 2 3 16)
+          (--map-last (= it 2) 17 '(1 2 3 2))
+              => '(1 2 3 17)
+
  -- Function: -map-indexed (fn list)
      Return a new list consisting of the result of (FN index item)
      for each item in LIST.
@@ -274,6 +302,8 @@ list.  The results are collected in order and returned as 
new list.
               => '(1 a b c 2)
           (-splice-list 'keywordp nil '(1 :foo 2))
               => '(1 2)
+          (--splice-list (keywordp it) '(a b c) '(1 :foo 2))
+              => '(1 a b c 2)
 
  -- Function: -mapcat (fn list)
      Return the concatenation of the result of mapping FN over LIST.
@@ -328,6 +358,48 @@ Functions returning a sublist of the original list.
           (--remove (= 0 (% it 2)) '(1 2 3 4))
               => '(1 3)
 
+ -- Function: -remove-first (pred list)
+     Return a new list with the first item matching PRED removed.
+
+     Alias: `-reject-first'
+
+     See also: `-remove' (*note -remove::), `-map-first' (*note
+     -map-first::)
+
+          (-remove-first 'even? '(1 3 5 4 7 8 10))
+              => '(1 3 5 7 8 10)
+          (-remove-first 'stringp '(1 2 "first" "second" "third"))
+              => '(1 2 "second" "third")
+          (--remove-first (> it 3) '(1 2 3 4 5 6 7 8 9 10))
+              => '(1 2 3 5 6 7 8 9 10)
+
+ -- Function: -remove-last (pred list)
+     Return a new list with the last item matching PRED removed.
+
+     Alias: `-reject-last'
+
+     See also: `-remove' (*note -remove::), `-map-last' (*note
+     -map-last::)
+
+          (-remove-last 'even? '(1 3 5 4 7 8 10 11))
+              => '(1 3 5 4 7 8 11)
+          (-remove-last 'stringp '(1 2 "last" "second" "third"))
+              => '(1 2 "last" "second")
+          (--remove-last (> it 3) '(1 2 3 4 5 6 7 8 9 10))
+              => '(1 2 3 4 5 6 7 8 9)
+
+ -- Function: -remove-item (item list)
+     Remove all occurences of ITEM from LIST.
+
+     Comparison is done with `equal'.
+
+          (-remove-item 3 '(1 2 3 2 3 4 5 3))
+              => '(1 2 2 4 5)
+          (-remove-item 'foo '(foo bar baz foo))
+              => '(bar baz)
+          (-remove-item "bob" '("alice" "bob" "eve" "bob" "dave"))
+              => '("alice" "eve" "dave")
+
  -- Function: -non-nil (list)
      Return all non-nil elements of LIST.
 
@@ -412,6 +484,9 @@ Bag of various functions which modify input list.
      Return a new list of the non-nil results of applying FN to the
      items in LIST.
 
+     If you want to select the original items satisfying a predicate
+     use `-filter' (*note -filter::).
+
           (-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))
@@ -469,6 +544,34 @@ Bag of various functions which modify input list.
           (-replace 1 2 nil)
               => nil
 
+ -- Function: -replace-first (old new list)
+     Replace the first occurence of OLD with NEW in LIST.
+
+     Elements are compared using `equal'.
+
+     See also: `-map-first' (*note -map-first::)
+
+          (-replace-first 1 "1" '(1 2 3 4 3 2 1))
+              => '("1" 2 3 4 3 2 1)
+          (-replace-first "foo" "bar" '("a" "nice" "foo" "sentence" "about" 
"foo"))
+              => '("a" "nice" "bar" "sentence" "about" "foo")
+          (-replace-first 1 2 nil)
+              => nil
+
+ -- Function: -replace-last (old new list)
+     Replace the last occurence of OLD with NEW in LIST.
+
+     Elements are compared using `equal'.
+
+     See also: `-map-last' (*note -map-last::)
+
+          (-replace-last 1 "1" '(1 2 3 4 3 2 1))
+              => '(1 2 3 4 3 2 "1")
+          (-replace-last "foo" "bar" '("a" "nice" "foo" "sentence" "about" 
"foo"))
+              => '("a" "nice" "foo" "sentence" "about" "bar")
+          (-replace-last 1 2 nil)
+              => nil
+
  -- Function: -insert-at (n x list)
      Return a list with X inserted into LIST at position N.
 
@@ -1588,7 +1691,7 @@ File: dash.info,  Node: Threading macros,  Next: Binding, 
 Prev: Tree operations
           (-> '(2 3 5) (append '(8 13)) (-slice 1 -1))
               => '(3 5 8)
 
- -- Function: ->> (x form &rest more)
+ -- Function: ->> (x &optional form &rest more)
      Thread the expr through the forms. Insert X as the last item in
      the first form, making a list of it if it is not a list already.
      If there are more forms, insert the first form as the last item
@@ -1765,6 +1868,48 @@ control.
      This binds N values from the list to a1 ... aN, then interprets
      the cdr as a plist (see key/value matching above).
 
+     You can name the source using the syntax SYMBOL &as PATTERN.
+     This syntax works with lists (proper or improper), vectors and
+     all types of maps.
+
+     (list &as a b c) (list 1 2 3)
+
+     binds A to 1, B to 2, C to 3 and LIST to (1 2 3).
+
+     Similarly:
+
+     (bounds &as beg . end) (cons 1 2)
+
+     binds BEG to 1, END to 2 and BOUNDS to (1 . 2).
+
+     (items &as first . rest) (list 1 2 3)
+
+     binds FIRST to 1, REST to (2 3) and ITEMS to (1 2 3)
+
+     [vect &as _ b c] [1 2 3]
+
+     binds B to 2, C to 3 and VECT to [1 2 3] (_ avoids binding as
+     usual).
+
+     (plist &as &plist :b b) (list :a 1 :b 2 :c 3)
+
+     binds B to 2 and PLIST to (:a 1 :b 2 :c 3).  Same for &alist and
+     &hash.
+
+     This is especially useful when we want to capture the result of a
+     computation and destructure at the same time.  Consider the form
+     (function-returning-complex-structure) returning a list of two
+     vectors with two items each.  We want to capture this entire
+     result and pass it to another computation, but at the same time
+     we want to get the second item from each vector.  We can achieve
+     it with pattern
+
+     (result &as [_ a] [_ b]) (function-returning-complex-structure)
+
+     Note: Clojure programmers may know this feature as the ":as
+     binding".  The difference is that we put the &as at the front
+     because we need to support improper list binding.
+
           (-let (([a (b c) d] [1 (2 3) 4])) (list a b c d))
               => '(1 2 3 4)
           (-let [(a b c . d) (list 1 2 3 4 5 6)] (list a b c d))
@@ -2327,6 +2472,12 @@ File: dash.info,  Node: Contributors,  Prev: Changes,  
Up: Development
    * Mark Oteiza (https://github.com/holomorph) contributed the
      script to create an info manual.
 
+   * Vasilij Schneidermann (https://github.com/wasamasa) contributed
+     `-some'.
+
+   * William West (https://github.com/occidens) made `-fixfn' more
+     robust at handling floats.
+
    Thanks!
 
 
@@ -2348,7 +2499,7 @@ Index
 * -all?:                                 Predicates.        (line  19)
 * -andfn:                                Function combinators.
                                                             (line 141)
-* -annotate:                             Maps.              (line  51)
+* -annotate:                             Maps.              (line  79)
 * -any?:                                 Predicates.        (line   7)
 * -applify:                              Function combinators.
                                                             (line  57)
@@ -2357,13 +2508,13 @@ Index
 * -clone:                                Tree operations.   (line 124)
 * -compose:                              Function combinators.
                                                             (line  43)
-* -concat:                               List to list.      (line  20)
+* -concat:                               List to list.      (line  23)
 * -cons*:                                Other list operations.
                                                             (line  29)
 * -const:                                Function combinators.
                                                             (line  94)
 * -contains?:                            Predicates.        (line  58)
-* -copy:                                 Maps.              (line 104)
+* -copy:                                 Maps.              (line 134)
 * -count:                                Reductions.        (line  79)
 * -cut:                                  Function combinators.
                                                             (line 107)
@@ -2372,8 +2523,8 @@ Index
 * -difference:                           Set operations.    (line  21)
 * -distinct:                             Set operations.    (line  45)
 * -dotimes:                              Side-effects.      (line  29)
-* -drop:                                 Sublist selection. (line  66)
-* -drop-while:                           Sublist selection. (line  85)
+* -drop:                                 Sublist selection. (line 108)
+* -drop-while:                           Sublist selection. (line 127)
 * -each:                                 Side-effects.      (line   9)
 * -each-while:                           Side-effects.      (line  20)
 * -elem-index:                           Indexing.          (line  10)
@@ -2390,8 +2541,8 @@ Index
                                                             (line 275)
 * -fixfn:                                Function combinators.
                                                             (line 178)
-* -flatten:                              List to list.      (line  31)
-* -flatten-n:                            List to list.      (line  44)
+* -flatten:                              List to list.      (line  34)
+* -flatten-n:                            List to list.      (line  47)
 * -flip:                                 Function combinators.
                                                             (line  82)
 * -grade-down:                           Indexing.          (line  78)
@@ -2399,7 +2550,7 @@ Index
 * -group-by:                             Partitioning.      (line 146)
 * -if-let:                               Binding.           (line  35)
 * -if-let*:                              Binding.           (line  46)
-* -insert-at:                            List to list.      (line  70)
+* -insert-at:                            List to list.      (line 101)
 * -interleave:                           Other list operations.
                                                             (line  67)
 * -interpose:                            Other list operations.
@@ -2414,24 +2565,26 @@ Index
 * -juxt:                                 Function combinators.
                                                             (line  32)
 * -keep:                                 List to list.      (line   9)
-* -lambda:                               Binding.           (line 179)
+* -lambda:                               Binding.           (line 221)
 * -last:                                 Other list operations.
                                                             (line 212)
 * -last-item:                            Other list operations.
                                                             (line 230)
 * -let:                                  Binding.           (line  60)
-* -let*:                                 Binding.           (line 159)
+* -let*:                                 Binding.           (line 201)
 * -list:                                 Other list operations.
                                                             (line 262)
 * -map:                                  Maps.              (line  11)
-* -map-indexed:                          Maps.              (line  39)
+* -map-first:                            Maps.              (line  39)
+* -map-indexed:                          Maps.              (line  67)
+* -map-last:                             Maps.              (line  53)
 * -map-when:                             Maps.              (line  22)
-* -mapcat:                               Maps.              (line  93)
+* -mapcat:                               Maps.              (line 123)
 * -max:                                  Reductions.        (line 131)
 * -max-by:                               Reductions.        (line 141)
 * -min:                                  Reductions.        (line 107)
 * -min-by:                               Reductions.        (line 117)
-* -non-nil:                              Sublist selection. (line  35)
+* -non-nil:                              Sublist selection. (line  77)
 * -none?:                                Predicates.        (line  31)
 * -not:                                  Function combinators.
                                                             (line 120)
@@ -2458,28 +2611,33 @@ Index
 * -reduce-r:                             Reductions.        (line  58)
 * -reduce-r-from:                        Reductions.        (line  25)
 * -remove:                               Sublist selection. (line  22)
-* -remove-at:                            List to list.      (line 107)
-* -remove-at-indices:                    List to list.      (line 120)
+* -remove-at:                            List to list.      (line 138)
+* -remove-at-indices:                    List to list.      (line 151)
+* -remove-first:                         Sublist selection. (line  35)
+* -remove-item:                          Sublist selection. (line  65)
+* -remove-last:                          Sublist selection. (line  50)
 * -repeat:                               Other list operations.
                                                             (line  18)
-* -replace:                              List to list.      (line  56)
-* -replace-at:                           List to list.      (line  81)
+* -replace:                              List to list.      (line  59)
+* -replace-at:                           List to list.      (line 112)
+* -replace-first:                        List to list.      (line  73)
+* -replace-last:                         List to list.      (line  87)
 * -rotate:                               Other list operations.
                                                             (line   9)
 * -rpartial:                             Function combinators.
                                                             (line  21)
 * -same-items?:                          Predicates.        (line  73)
-* -select-by-indices:                    Sublist selection. (line  96)
+* -select-by-indices:                    Sublist selection. (line 138)
 * -separate:                             Partitioning.      (line  64)
-* -slice:                                Sublist selection. (line  41)
+* -slice:                                Sublist selection. (line  83)
 * -snoc:                                 Other list operations.
                                                             (line  43)
 * -some:                                 Other list operations.
                                                             (line 199)
 * -sort:                                 Other list operations.
                                                             (line 248)
-* -splice:                               Maps.              (line  62)
-* -splice-list:                          Maps.              (line  82)
+* -splice:                               Maps.              (line  90)
+* -splice-list:                          Maps.              (line 110)
 * -split-at:                             Partitioning.      (line   9)
 * -split-on:                             Partitioning.      (line  29)
 * -split-when:                           Partitioning.      (line  47)
@@ -2489,8 +2647,8 @@ Index
                                                             (line 141)
 * -table-flat:                           Other list operations.
                                                             (line 160)
-* -take:                                 Sublist selection. (line  57)
-* -take-while:                           Sublist selection. (line  74)
+* -take:                                 Sublist selection. (line  99)
+* -take-while:                           Sublist selection. (line 116)
 * -tree-map:                             Tree operations.   (line  29)
 * -tree-map-nodes:                       Tree operations.   (line  40)
 * -tree-mapreduce:                       Tree operations.   (line  86)
@@ -2500,7 +2658,7 @@ Index
 * -tree-seq:                             Tree operations.   (line   9)
 * -unfold:                               Unfolding.         (line  26)
 * -union:                                Set operations.    (line   9)
-* -update-at:                            List to list.      (line  94)
+* -update-at:                            List to list.      (line 125)
 * -when-let:                             Binding.           (line  10)
 * -when-let*:                            Binding.           (line  23)
 * -zip:                                  Other list operations.
@@ -2521,155 +2679,162 @@ Node: Functions3740
 Node: Maps4941
 Ref: -map5237
 Ref: -map-when5575
-Ref: -map-indexed6149
-Ref: -annotate6551
-Ref: -splice7038
-Ref: -splice-list7804
-Ref: -mapcat8164
-Ref: -copy8537
-Node: Sublist selection8723
-Ref: -filter8916
-Ref: -remove9283
-Ref: -non-nil9638
-Ref: -slice9796
-Ref: -take10325
-Ref: -drop10577
-Ref: -take-while10776
-Ref: -drop-while11123
-Ref: -select-by-indices11476
-Node: List to list11983
-Ref: -keep12170
-Ref: -concat12558
-Ref: -flatten12852
-Ref: -flatten-n13204
-Ref: -replace13584
-Ref: -insert-at14036
-Ref: -replace-at14353
-Ref: -update-at14741
-Ref: -remove-at15221
-Ref: -remove-at-indices15698
-Node: Reductions16265
-Ref: -reduce-from16434
-Ref: -reduce-r-from17111
-Ref: -reduce17798
-Ref: -reduce-r18486
-Ref: -count19298
-Ref: -sum19520
-Ref: -product19706
-Ref: -min19912
-Ref: -min-by20135
-Ref: -max20651
-Ref: -max-by20873
-Node: Unfolding21394
-Ref: -iterate21633
-Ref: -unfold22075
-Node: Predicates22866
-Ref: -any?22990
-Ref: -all?23303
-Ref: -none?23618
-Ref: -only-some?23913
-Ref: -contains?24383
-Ref: -same-items?24755
-Ref: -is-prefix?25133
-Ref: -is-suffix?25449
-Ref: -is-infix?25765
-Node: Partitioning26112
-Ref: -split-at26300
-Ref: -split-with26583
-Ref: -split-on26983
-Ref: -split-when27647
-Ref: -separate28276
-Ref: -partition28715
-Ref: -partition-all29164
-Ref: -partition-in-steps29589
-Ref: -partition-all-in-steps30083
-Ref: -partition-by30565
-Ref: -partition-by-header30944
-Ref: -group-by31544
-Node: Indexing31974
-Ref: -elem-index32176
-Ref: -elem-indices32568
-Ref: -find-index32948
-Ref: -find-last-index33388
-Ref: -find-indices33845
-Ref: -grade-up34250
-Ref: -grade-down34651
-Node: Set operations35059
-Ref: -union35242
-Ref: -difference35673
-Ref: -intersection36077
-Ref: -distinct36501
-Node: Other list operations36809
-Ref: -rotate37034
-Ref: -repeat37327
-Ref: -cons*37587
-Ref: -snoc37971
-Ref: -interpose38377
-Ref: -interleave38672
-Ref: -zip-with39038
-Ref: -zip39726
-Ref: -zip-fill40373
-Ref: -cycle40694
-Ref: -pad41064
-Ref: -table41384
-Ref: -table-flat42167
-Ref: -first43156
-Ref: -some43519
-Ref: -last43882
-Ref: -first-item44213
-Ref: -last-item44410
-Ref: -butlast44603
-Ref: -sort44847
-Ref: -list45337
-Ref: -fix45665
-Node: Tree operations46199
-Ref: -tree-seq46395
-Ref: -tree-map47250
-Ref: -tree-map-nodes47690
-Ref: -tree-reduce48542
-Ref: -tree-reduce-from49417
-Ref: -tree-mapreduce50016
-Ref: -tree-mapreduce-from50860
-Ref: -clone52130
-Node: Threading macros52457
-Ref: ->52602
-Ref: ->>53092
-Ref: -->53586
-Node: Binding54101
-Ref: -when-let54305
-Ref: -when-let*54795
-Ref: -if-let55214
-Ref: -if-let*55605
-Ref: -let56112
-Ref: -let*59832
-Ref: -lambda60769
-Node: Side-effects61566
-Ref: -each61760
-Ref: -each-while62163
-Ref: -dotimes62521
-Node: Destructive operations62822
-Ref: !cons62995
-Ref: !cdr63202
-Node: Function combinators63398
-Ref: -partial63667
-Ref: -rpartial64060
-Ref: -juxt64460
-Ref: -compose64889
-Ref: -applify65443
-Ref: -on65887
-Ref: -flip66407
-Ref: -const66716
-Ref: -cut67057
-Ref: -not67510
-Ref: -orfn67821
-Ref: -andfn68254
-Ref: -iteratefn68747
-Ref: -fixfn69444
-Ref: -prodfn70999
-Node: Development72046
-Node: Contribute72395
-Node: Changes73116
-Node: Contributors75730
-Node: Index77068
+Ref: -map-first6149
+Ref: -map-last6616
+Ref: -map-indexed7079
+Ref: -annotate7481
+Ref: -splice7968
+Ref: -splice-list8734
+Ref: -mapcat9185
+Ref: -copy9558
+Node: Sublist selection9744
+Ref: -filter9937
+Ref: -remove10304
+Ref: -remove-first10659
+Ref: -remove-last11171
+Ref: -remove-item11677
+Ref: -non-nil12064
+Ref: -slice12222
+Ref: -take12751
+Ref: -drop13003
+Ref: -take-while13202
+Ref: -drop-while13549
+Ref: -select-by-indices13902
+Node: List to list14409
+Ref: -keep14596
+Ref: -concat15092
+Ref: -flatten15386
+Ref: -flatten-n15738
+Ref: -replace16118
+Ref: -replace-first16570
+Ref: -replace-last17055
+Ref: -insert-at17533
+Ref: -replace-at17850
+Ref: -update-at18238
+Ref: -remove-at18718
+Ref: -remove-at-indices19195
+Node: Reductions19762
+Ref: -reduce-from19931
+Ref: -reduce-r-from20608
+Ref: -reduce21295
+Ref: -reduce-r21983
+Ref: -count22795
+Ref: -sum23017
+Ref: -product23203
+Ref: -min23409
+Ref: -min-by23632
+Ref: -max24148
+Ref: -max-by24370
+Node: Unfolding24891
+Ref: -iterate25130
+Ref: -unfold25572
+Node: Predicates26363
+Ref: -any?26487
+Ref: -all?26800
+Ref: -none?27115
+Ref: -only-some?27410
+Ref: -contains?27880
+Ref: -same-items?28252
+Ref: -is-prefix?28630
+Ref: -is-suffix?28946
+Ref: -is-infix?29262
+Node: Partitioning29609
+Ref: -split-at29797
+Ref: -split-with30080
+Ref: -split-on30480
+Ref: -split-when31144
+Ref: -separate31773
+Ref: -partition32212
+Ref: -partition-all32661
+Ref: -partition-in-steps33086
+Ref: -partition-all-in-steps33580
+Ref: -partition-by34062
+Ref: -partition-by-header34441
+Ref: -group-by35041
+Node: Indexing35471
+Ref: -elem-index35673
+Ref: -elem-indices36065
+Ref: -find-index36445
+Ref: -find-last-index36885
+Ref: -find-indices37342
+Ref: -grade-up37747
+Ref: -grade-down38148
+Node: Set operations38556
+Ref: -union38739
+Ref: -difference39170
+Ref: -intersection39574
+Ref: -distinct39998
+Node: Other list operations40306
+Ref: -rotate40531
+Ref: -repeat40824
+Ref: -cons*41084
+Ref: -snoc41468
+Ref: -interpose41874
+Ref: -interleave42169
+Ref: -zip-with42535
+Ref: -zip43223
+Ref: -zip-fill43870
+Ref: -cycle44191
+Ref: -pad44561
+Ref: -table44881
+Ref: -table-flat45664
+Ref: -first46653
+Ref: -some47016
+Ref: -last47379
+Ref: -first-item47710
+Ref: -last-item47907
+Ref: -butlast48100
+Ref: -sort48344
+Ref: -list48834
+Ref: -fix49162
+Node: Tree operations49696
+Ref: -tree-seq49892
+Ref: -tree-map50747
+Ref: -tree-map-nodes51187
+Ref: -tree-reduce52039
+Ref: -tree-reduce-from52914
+Ref: -tree-mapreduce53513
+Ref: -tree-mapreduce-from54357
+Ref: -clone55627
+Node: Threading macros55954
+Ref: ->56099
+Ref: ->>56589
+Ref: -->57093
+Node: Binding57608
+Ref: -when-let57812
+Ref: -when-let*58302
+Ref: -if-let58721
+Ref: -if-let*59112
+Ref: -let59619
+Ref: -let*64745
+Ref: -lambda65682
+Node: Side-effects66479
+Ref: -each66673
+Ref: -each-while67076
+Ref: -dotimes67434
+Node: Destructive operations67735
+Ref: !cons67908
+Ref: !cdr68115
+Node: Function combinators68311
+Ref: -partial68580
+Ref: -rpartial68973
+Ref: -juxt69373
+Ref: -compose69802
+Ref: -applify70356
+Ref: -on70800
+Ref: -flip71320
+Ref: -const71629
+Ref: -cut71970
+Ref: -not72423
+Ref: -orfn72734
+Ref: -andfn73167
+Ref: -iteratefn73660
+Ref: -fixfn74357
+Ref: -prodfn75912
+Node: Development76959
+Node: Contribute77308
+Node: Changes78029
+Node: Contributors80643
+Node: Index82165
 
 End Tag Table
diff --git a/dash.texi b/dash.texi
index f47b7b5..7dbdd2b 100644
--- a/dash.texi
+++ b/dash.texi
@@ -13,7 +13,7 @@
 
 @copying
 
-This manual is for @code{dash.el} version 2.10.0.
+This manual is for @code{dash.el} version 2.11.0.
 
 Copyright © 2012-2015 Magnar Sveen
 
@@ -124,13 +124,13 @@ Alternatively, you can just dump @verb{~dash.el~} or
 Add this to the big comment block at the top:
 
 @lisp
-;; Package-Requires: ((dash "2.10.0"))
+;; Package-Requires: ((dash "2.11.0"))
 @end lisp
 
 @noindent To get function combinators:
 
 @lisp
-;; Package-Requires: ((dash "2.10.0") (dash-functional "1.2.0") (emacs "24"))
+;; Package-Requires: ((dash "2.11.0") (dash-functional "1.2.0") (emacs "24"))
 @end lisp
 
 @node Syntax highlighting of dash functions
@@ -376,6 +376,10 @@ See also: @code{-splice} (@pxref{-splice}), 
@code{-insert-at} (@pxref{-insert-at
 (-splice-list 'keywordp nil '(1 :foo 2))
     @result{} '(1 2)
 @end group
address@hidden
+(--splice-list (keywordp it) '(a b c) '(1 :foo 2))
+    @result{} '(1 a b c 2)
address@hidden group
 @end example
 @end defun
 
@@ -2702,7 +2706,7 @@ second item in second form, etc.
 @end defun
 
 @anchor{->>}
address@hidden ->> (x form &rest more)
address@hidden ->> (x &optional form &rest more)
 Thread the expr through the forms. Insert @var{x} as the last item
 in the first form, making a list of it if it is not a list
 already. If there are more forms, insert the first form as the
diff --git a/readme-template.md b/readme-template.md
index b0cabc1..0d43c66 100644
--- a/readme-template.md
+++ b/readme-template.md
@@ -19,11 +19,11 @@ If you want the function combinators, then also:
 
 Add this to the big comment block at the top:
 
-    ;; Package-Requires: ((dash "2.10.0"))
+    ;; Package-Requires: ((dash "2.11.0"))
 
 To get function combinators:
 
-    ;; Package-Requires: ((dash "2.10.0") (dash-functional "1.2.0") (emacs 
"24"))
+    ;; Package-Requires: ((dash "2.11.0") (dash-functional "1.2.0") (emacs 
"24"))
 
 ## Syntax highlighting of dash functions
 
@@ -91,6 +91,10 @@ Change `readme-template.md` or `examples-to-docs.el` instead.
 
 ## Changelist
 
+### From 2.10 to 2.11
+
+- Lots of clean up wrt byte compilation, debug macros and tests
+
 ### From 2.9 to 2.10
 
 - Add `-let` destructuring to `-if-let` and `-when-let` (Fredrik Bergroth)



reply via email to

[Prev in Thread] Current Thread [Next in Thread]