Clojure Q&A - Recent questions tagged sequence

Infinite lazy sequence expands until JVM runs out of memory

Sat, 29 Jul 2023 23:20:23 +0000

Hello, I am new to Clojure and to lazy sequences.

(defn get-biggest-prime-factor [num]
  (let [max-check (inc (Math/sqrt num))
        lazy-primes (filter-lazy-seq is_prime naturals)]
    (loop [prime (first lazy-primes)
           max-factor 1]
      (cond (>= prime max-check) max-factor
            (= 0 (rem num prime)) (recur (first (rest lazy-primes)) (first lazy-primes))
            :else (recur (first (rest lazy-primes)) max-factor)))) )

naturals is an infinite lazy sequence of 1,2,3 ... ,
filter-lazy-seq is a function, which returns a lazy sequence derived from second argument. Every element of sequence is verified by first argument, which is a predicate
is-prime is a function that check if a number is prime

Any help is appreciated.

Use transducers on clojure.core lazy sequence transformations

Tue, 11 Apr 2023 06:55:00 +0000

Hi,

I heard that if transducers were included before in the language, they would have been used as the building blocks of all sequence lazy operations. Since they were added later, you need to adapt your code a bit to use transducers. And I was wondering why using eduction is not an option? I'm trying to understand the scenarios in which it's not a performance advantage to define the sequence lazy operations like this (of course assuming the same behaviour):

(defn map
  ([f] ;; the standard transducer definition
   ,,,)
  ([f coll]
   (eduction (map f) coll))

I'm trying to understand given the assumption (which might be an erroneous assumption) that

(->> (range 5000000)
     (eduction (map inc))
     (eduction (filter odd?))
     (eduction (map dec))
     (eduction (filter even?))
     (eduction (map (fn [n] (+ 3 n))))
     (eduction (filter odd?))
     (eduction (map inc))
     (eduction (filter odd?))
     (eduction (map dec))
     (eduction (filter even?))
     (eduction (map (fn [n] (+ 3 n))))
     (eduction (filter odd?))
     (into []))

is the same as

(->> (range 5000000)
     (map inc)
     (filter odd?)
     (map dec)
     (filter even?)
     (map (fn [n] (+ 3 n)))
     (filter odd?)
     (map inc)
     (filter odd?)
     (map dec)
     (filter even?)
     (map (fn [n] (+ 3 n)))
     (filter odd?)
     (into []))

Allow `keep` to accept multiple collections (a la map)

Mon, 13 Mar 2023 14:50:07 +0000

https://ask.clojure.org/index.php/3345/allow-map-indexed-to-accept-multiple-collections-a-la-map comments here indicated this should be its own jira. I couldn't see that a jira had actually been created though.

Why does '=' return false for these two sequences?

Thu, 18 Feb 2021 07:06:07 +0000

I have two sequences 'a' and 'b'. Both have the same length and their corresponding element compare equal with '='. But if these two sequences are passed to '=', the result is false:

(doseq [[x y] (zip-colls a b)]
  (println (= x y)))
true
true
true
true

(count a)
4
(count b)
4

(= a b)
false

This is in contradiction with the clojure equality rule:

Clojure’s = is true when called with two collections, if:

Both arguments are sequential (sequences, lists, vectors, queues, or Java collections implementing java.util.List) with = elements in the same order.

I'm comparing two instances of this class: https://github.com/fctorial/parse_struct/blob/master/src/clojure/lang/ROVec.java

Suspected bug in `clojure.core/partition`

Thu, 10 Dec 2020 02:54:45 +0000

2 problems:
- The docstring of clojure.core/partition is not clear on what "last partition" means.
- The behavior of partition is strange, IHMO it has a bug.

Please take a look at this:

(partition 3 1 [:a :b :c] (range 5))

; actual behavior
; => ((0 1 2) (1 2 3) (2 3 4) (3 4 :a))

; expected behavior, option 1
; => ((0 1 2) (1 2 3) (2 3 4))

; expected behavior, option 2
; => ((0 1 2) (1 2 3) (2 3 4) (3 4 :a) (4 :a :b))

I would expect the "last partition" to be defined as:

The last partition to contain elements from the input collection (not the padding collection) which are not present in any previous partition.

This is consistent with option 1 above.