From 2aeeacb090479e326ce937e4f3bb33309241ffae Mon Sep 17 00:00:00 2001 From: Magnar Sveen Date: Wed, 1 Jul 2015 09:20:12 +0200 Subject: [PATCH] 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 -;; 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 +@group +(--splice-list (keywordp it) '(a b c) '(1 :foo 2)) + @result{} '(1 a b c 2) +@end group @end example @end defun @@ -2702,7 +2706,7 @@ second item in second form, etc. @end defun @anchor{->>} -@defun ->> (x form &rest more) +@defun ->> (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)