clojure.core/halt-when

View this page on ClojureDocs

Type: function Added: Clojure 1.9 Examples: 5 Runnable: 3

([pred] [pred retf])

Returns a transducer that ends transduction when pred returns true for an input. When retf is supplied it must be a fn of 2 arguments - it will be passed the (completed) result so far and the input that triggered the predicate, and its return value (if it does not throw an exception) will be the return value of the transducer. If retf is not supplied, the input that triggered the predicate will be returned. If the predicate never returns true the transduction is unaffected.

Examples

by glts on 2018-03-11 ▶

(def letters (set "abcdefghijklmnopqrstuvwxyz")) (def vowels (set "aeiou")) ;; Remove the vowels from a string. (transduce (remove vowels) str "hello") ;;=> "hll" ;; Same, but halt when seeing a non-letter (and return that non-letter). (transduce (comp (remove vowels) (halt-when (complement letters))) str "hello") ;;=> "hll" (transduce (comp (remove vowels) (halt-when (complement letters))) str "hello world") ;;=> \space

by glts on 2018-03-11 . May have evaluation errors. ▶

;; "halt-when" can only really be used with "transduce" (and "into" ;; as of Clojure 1.11.1), but not with other functions that ;; support transducers like "sequence". (def v (vec (concat (range 5) [:x]))) (def xf (comp (take 10) (halt-when keyword?) (map inc))) (transduce xf conj [] v) ;;=> :x (into [] xf v) ;;=> ClassCastException! ;; Clojure 1.11.0 Alpha 4 updates "into" so that this works and produces: ;;=> :x (sequence xf v) ;;=> (1 2 3 4 5), wrong result!

by reborg on 2022-01-19 ▶

;; Using the second argument in halt-when (transduce (comp (halt-when #{30} ;; stop at 30th item (fn [acc itm] acc))) ;; return all items so far (completing conj #(reduce + %)) ;; sums items on exit (range)) ;; 435

by tomdl89 on 2022-07-21 . May have evaluation errors. ▶

;; Like `take-while`'s complement when we return the completed result so far (transduce (take-while #(< % 10)) + (range));; => 45 (transduce (halt-when #(>= % 10) (fn [acc _] acc)) + (range));; => 45 ;; So it's similar to medley's `take-upto` when `retf` = transduce's `f` (transduce (medley.core/take-upto #(>= % 10)) conj (range)) ;; => [0 1 2 3 4 5 6 7 8 9 10] (transduce (halt-when #(>= % 10) conj) conj (range)) ;; => [0 1 2 3 4 5 6 7 8 9 10]

by holyjak on 2023-05-30 ▶

;; Since Clojure 1.11 we can also use this with e.g. into: (into {} (comp (map (juxt :l :n)) (halt-when (comp (complement number?) second) (constantly ::invalid))) [{:l "A" :n 1} {:l "B" :n "not a number!"} {:l "C" :n 3}]) ;; => ::invalid ;; (remove the B entry to get `=> {"A" 1, "C" 3}`)

Note by glts

halt-when is an odd transducer in that it is supposed to be used with transduce, but not in other transducible contexts like sequence or into.

Says Alex Miller at https://dev.clojure.org/jira/browse/CLJ-1451: ‘Yeah, halt-when is a little tricky to use in transducible contexts other than transduce.’ Some more discussion at https://groups.google.com/d/msg/clojure/6HvmJIUsXKk/gLqUsfcnAwAJ.

Note by holyjak

Not anymore, as pointed out above, at least into works fine under Clojure 1.11

See also

• clojure.core/transduce (5)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.