touch = update time stamp of a file; does clojure have a builtin for touching a file, or do I need to make a sytem call to call the touch command ?

I don't think it has

@qqq Take a look at http://rosettacode.org/wiki/File_modification_time#Clojure

clojure.java.shell/sh it is then

how do I convert a java.util.Collections to a list or a vector?

so in particular, I have an object of type Enumeration<String> (from Java)

and I want to convert it to a list of strings or vector of strings

eumeration-seq

Enumeration? i thought that was deprecated. If the collections implements Iterable , you can do: (seq coll)

I'm using Java 7 still

are you using Java 8?

Enumeration is from like java 1

yeah, but you're claiming it's deprecated

and if you're on 8 while I'm on 7, it may be because it was deprecated in 8

its not, but is more common to use Iterables from java 5 forward

when using webservers in clojure, can I directly reply with edn, or do I have to do clojure dta -> edn -> wrap it in a singleton json string ?

how does transit and edn compare for client/server communicating?

this is a good overview

https://swannodette.github.io/2014/07/26/transit-clojurescript

the short answer is to use transit

yeah, the 10x-20x stuff convinced me

thanks!

no prob!

http://cognitect.github.io/transit-clj/ mentions:

Usage: (writer out type)
       (writer out type {:keys [handlers]})
Creates a writer over the provided destination `out` using
the specified format, one of: :msgpack, :json or :json-verbose.

An optional opts map may be passed. Supported options are:

:handlers - a map of types to WriteHandler instances, they are merged
with the default-handlers and then with the default handlers
provided by transit-java.

Not a strictly clojure question, but is it correct to say that (-> col (map f) (filter g)) is more efficient if the map and filter functions are lazy?

map and filter are lazy, f isn't

(lazy as in potentially chunked etc etc, because.. clojure)

Yes, I meant map and filter. So my assumption is that it's closer to O(N) than it would be if map and filter were strict

kinda yes

nowadays you're better of using transducers when you have to chain map/filter & co, when you're looking to optimise things at least

So transducers basically solve the problem of intermediate collections, so that the number of passes doesn't go up with the number of filter/map/reduce... you want to apply, right?

So that it's more similar to a very specialized for loop

and not a series of for loops

Which I suppose is something like what the haskell compiler does

you still get chunkiness depending on how the seq was produced, but you at least skip intermediary seq instance creation

but depending on how you realize them (via sequence or into) you can make it totally eager

ex via (into (empty xs) xform xs)

ex:

vs.

depends on range in that case for chunkiness, but sequence respect lazyness of the underlying seq compared to into

Right, very nice. It always bothered me that I need to do multiple full passes on a collection when doing something very specific

in most case it's not that important tbh, but sometimes it helps

Yeah, I know. It still irks me (which perhaps is more my fault 🙂 ). And there have been a few times where it was a problem

hi! what should I do in cider after editing project.clj with a new dependency? restart emacs and do a cider-jack-in or is there some better solution?

@pwrflx you never need to restart Emacs 😉

M-x cider-restart is enough

@andrea.crotti thanks a lot!

hey guys I am trying to iterate over a vector and create a channel with all of its elements, what is the best way of doing that in a let block?

;(let [names [:a :b: :c]] (doseq [chan-name names] (let [cn (name chan-name)] (def cn (chan)))))

this looks so convoluted

(let [c (chan)
      v [1 2 3]]
  (a/onto-chan c v)
  c)

joshjones i am trying to dynamically create 3 channels

(doall (for [x ["a" "b" "c"]] (eval `(def ~(symbol x) 666))))

or

(doseq [x ["a" "b" "c"]]
  (intern *ns* (symbol x) 666))

just found it on SO

this does exactly that, unless you are not saying correctly what it means to "dynamically create 3 channels":

(defn get-chan
  [v]
  (let [c (chan 1 (map name))]
    (a/onto-chan c v)
    c))

(let [c (get-chan [:a :b :c])]
  (<!! c))

=> "a"

you can def there if you want, but why would you want to?

creating global state from a function is allowed, but usually a bad idea and unnecessary @istvan

is there a way to show parameter info in CIDER? eg show the documentation of the parameter I'm about to enter for the current function call.. I mean something that is similar to CTRL+P in IDEA

can you explain what you mean about documentation of the parameter?

for instance, in CIDER, it uses eldoc to show the signature of a function as you type and will bold the parameter that you are currently on

but there is no convention that lumps documentation about parameters that i know of in clojure

@dpsutton : ah ok! then eldoc is what I need! 😄 I've seen it on the modeline of some youtube tutorials but never cared to install.. I'll look into it! thanks!

👍

joshjones this is exactly what i want:

plugflow.main=> (doseq [x ["a" "b" "c"]] (intern *ns* (symbol x) (chan)))
nil
plugflow.main=> a
#object[clojure.core.async.impl.channels.ManyToManyChannel 0x35aab37b "clojure.core.async.impl.channels.ManyToManyChannel@35aab37b"]
plugflow.main=> b
#object[clojure.core.async.impl.channels.ManyToManyChannel 0x271ce487 "clojure.core.async.impl.channels.ManyToManyChannel@271ce487"]
plugflow.main=> c
#object[clojure.core.async.impl.channels.ManyToManyChannel 0x6011ced2 "clojure.core.async.impl.channels.ManyToManyChannel@6011ced2"]

create 3 channels using the names a b and c

a b and c coming from a configuration file

it does not need to be global, it can live in my (let [] )

is this what your code does too?

if it's not global, but only in the let binding, what do you care what they are named?

and i don't mean that in a rude way, but if they exist inside of your let binding, why can't you just refer to them with whatever name you like?

because i do not know them in advance

users can use different names they like

but it's running in your code, right?

right

can you post a snippet of where you're using them?

i just can't imagine a scenario where the name of a variable should be relevant

but if you need to take three channels in from a consumer of your code, why not make a function that takes three channels as input?

or perhaps let them make a map of channels

because my customer uses N channels

not 3

and because my customer names the channels as she wishes

and you want to go on the convention that the var name of the channel is how they are bound?

it is going to be customer_name-chan

for example user-chan

and later in the code i create a thread which reads it

i will show you the code when it is done, not yet 🙂

and you are searching through the ns-vars that are already interned to see which chans are created?

(this sounds like you should use a map of names to channels — not actual named vars)

yeah. my point is that the interned vars are just a map

so why not create your own map and use that

seancorfield would you mind giving me an example, i always learn from those

you would use {:name1 (chan) :name2 (chan) } ?

@istvan so, the customer gives you a channel name, call it "xyz". You have a global atom that maps "xyz" and all other names to a channel

(def chan-map (atom {}))
(defn add-chan
  [m n]
  (swap! m assoc n (chan)))

(add-chan chan-map "xyz")

to add a lot:

(run! #(add-chan chan-map %) ["chan-name1" "xyz" "abc"])

alright i am going to try this

if your code breaks because they name their chan something then you have bad code

further, what if they haven't named the var anything at all really

(call-your-code (chan 1))

would have no pleasant name at all

i really think your structure of recovering logic flow of your program from variable names is a bad first attempt

dpsutton absolutely, great point

maybe setup a contract of something like this?

{:company-name "company xyz"
 :channel-type :reporting
:channel (chan 1)
}

take in a map with all of the information that you need

and note that this offers no security

alright i give it a try

thank you guys, i just rewrote the code using a map for the channels and it works! 🙂

👍

@istvan you will be happy that you did it this way, or rather, you will never know the unhappiness you saved yourself by doing it this way 😉

i already hit a roadblock with my first solution 😄

since clojure keywords are lookup functions you can just use the keyword and lookup pretty easily something in a map

this is one reason why keywords are the most common types of keys in maps. if you use a string as a key though, you can also easily do (get map' str-key), to avoid converting between str<->keywords. but yes, keywords work well

are there convenient clojure wrappers for java.lang.Process?

@keymone For many uses, clojure.java.shell suffices: https://clojure.github.io/clojure/clojure.java.shell-api.html

(let [a 1 b 2]
  (let [{:keys [a b]} {:a 3}]
    [a b]))
=> [3 nil]

@hlolli My first inclination to solve your problem is to throw an :or {b b} in there.

(let [a 1 b 2]
   (let [{:keys [a b] :or {b b}} {:a 3}]
     [a b]))

bingo! @mfikes thanks! (This calles for a macro, want to do this with lots of keys 🙂)

@mfikes yes, but that’s for shell commands that exit immediately, i need one for long-running processes that can deal with pipes etc