Clojurians Log v2

It used to be the case that empty seqs didn't exist, but it has not been the case in a long time

I believe Alex is trying to construct (or reconstruct) a taxonomy of concepts that most people just don't much attention to there

I think he is drawing a distinction between a sequence and a seq

The next section goes into that

Hum, ya it mixes weird with the (seq [1 2]) idiom though

Which made sense that you either have a seq with elements in it, or nil

But gets confusing when a seq can be empty

yes it used to be the case that (if s ... ...) was safe, but now(for years, the change was pretty close to clojure 1.0) you need (if (seq s) ... ...)

I guess in the taxonomy, what is the difference between s and what seq returns?

I'm trying to see if like there's a new word for a seq that can't be empty?

looking at it again, I think he is distinguishing between a seq and a lazy-seq (not a seq and a sequence), a seq is never empty (it is a seq of something or nil), a lazy-seq can be empty, and both of those are a sequence

but that doesn't help to make sense of the comment about (rest coll)

and like the type hint on rest says it returns an ISeq, the method call it bottoms out on (ISeq.more) says it returns an ISeq

> too many files to have one agent per file name > have the futures reset an agent...

I think we disagree about what agents are about? they are lightweight, in clojure terms at least, you can have a lot of them. and you send them actions - you wouldn't reset their file, you would close over the file handle and send them a function that makes them write. serializing writes is exactly the sort of thing agents are good at (as long as you aren't too worried about waiting for writes to finish before you move forward)

a quick example:

(require '[<http://clojure.java.io|clojure.java.io> :as io])

(defn writing-agent
  [fname]
  (let [handle (io/file fname)
        writer (io/writer handle)]
    (agent
     {:fresh (.createNewFile handle)
      :handle handle
      :writer writer
      :written 0})))

(defn append-to
  [the-agent the-string]
  (send the-agent
        (fn [{:keys [writer] :as m}]
          (.write writer the-string)
          (.flush writer)
          (update m :written + (count the-string)))))

(defn close
  [the-agent]
  (send the-agent
        (fn [{:keys [writer] :as m}]
          (.close writer)
          (assoc m :handle nil :writer nil))))

(cmd)user=> (.exists (io/file "foo.out"))
false
(cmd)user=> (def a (writing-agent "foo.out"))
#'user/a
(ins)user=> (pprint @a)
{:fresh false,
 :handle #object[java.io.File 0xff6077 "foo.out"],
 :writer
 #object[java.io.BufferedWriter 0x1280851e "java.io.BufferedWriter@1280851e"],
 :written 0}
nil
(ins)user=> (append-to a "hello")
#object[clojure.lang.Agent 0x12a160c2 {:status :ready, :val {:fresh false, :handle #object[java.io.File 0xff6077 "foo.out"], :writer #object[java.io.BufferedWriter 0x1280851e "java.io.BufferedWriter@1280851e"], :written 5}}]
(cmd)user=> (.exists (io/file "foo.out"))
true
(cmd)user=> (slurp "foo.out")
"hello"
(ins)user=> (append-to a ", world")
#object[clojure.lang.Agent 0x12a160c2 {:status :ready, :val {:fresh false, :handle #object[java.io.File 0xff6077 "foo.out"], :writer #object[java.io.BufferedWriter 0x1280851e "java.io.BufferedWriter@1280851e"], :written 5}}]
(cmd)user=> (slurp "foo.out")
"hello, world"
(ins)user=> (close a)
#object[clojure.lang.Agent 0x12a160c2 {:status :ready, :val {:fresh false, :handle #object[java.io.File 0xff6077 "foo.out"], :writer #object[java.io.BufferedWriter 0x1280851e "java.io.BufferedWriter@1280851e"], :written 12}}]
(ins)user=> (pprint @a)
{:fresh false, :handle nil, :writer nil, :written 12}
nil

I saw some weird behavior with .createNewFile btw- the docs say it creates a new fresh empty file only if it doesn't exist yet, but in my experiments it seems to be truncating the existing file before any writes

or maybe the writer I create is doing that - I should decouple for testing

i think you need {:append true} as options to the writer

I see, ok I think I'll try to use something like that. So far I have one agent that has a watcher that calls

(defn gz-write-line
  "Append data to gzipped target"
  [target content]
  (with-open [w (-> target
                    (<http://clojure.java.io/output-stream|clojure.java.io/output-stream> :append true)
                    java.util.zip.GZIPOutputStream.
                    <http://clojure.java.io/writer)]|clojure.java.io/writer)]>
    (binding [*out* w]
      (println content))))