https://docs.oracle.com/javase/tutorial/sound/capturing.html would you all interface directly with java to capture sound from a mic, or is there a clojure lib?

Suppose you find a great java library you want to use and not finding a clojure wrapper library extant, you decide to consider writing it yourself. Are there any guidelines that might be followed? any advice? any pitfalls to avoid?

in general? or in my case?

both?

I have no idea, thats one of the reasons why I was asking

tmtwd: there are some don't's for sure

don't make dynamic variables to "store" stateful things

that's actually something I would like to think about more or have someone else more familiar with the problem space chime in on.

as an example, if I just wrap calls to a Java library to make it idiomatic and nicer to use with Clojure, I still lose out on some of the niceties of doing it in Clojure and I fear with any reasonably non-trivial library it will quickly just become Java with lisp syntax and not Clojure inter-oping with Java.

Oh, I really wish people would just stop using dynamics

I would do (let [[hand new-deck] (split-at 3 @deck)] (reset! deck new-deck) hand))

depending on your concurrency story you may need to look into transactions features (out of my depth there)

Hi, here’s a bit of core.async code. I am trying to wrap a queue (a simple PersistentQueue) with a channel. Another process writes to that data-structure (using swap! conj) however, the recur doesn’t seem to pick up the next item - what am I doing wrong?

https://gist.github.com/shriphani/05bd7cf7c12f56603164

There doesn't seem to be a problem with your use of recur add some logging to see where its hanging

Hi, how do you do interactive development with seesaw? I tried a very simple snippet with a main function showing a frame (from https://github.com/daveray/seesaw) and then tried to reload it in the repl after changing the text, but nothing happened in my UI. Is there a trick to this?

anyone who can tell me what I did wrong here :

(= 25 ( fn[f] (f 5)) (fn [n] (* n n)))

I dunno, what it is supposed to do? In human words that is?

it's one of the koans

I think it supposed to calculated n * n = 25 , so the answer needs to be 5

@roelof: are you missing a set of parens?

right now you're just comparing an integer with two fn objects.

Hmmm, so I don't think that's what it does. This

(= 25 ( fn[f] (f 5))
         (fn [n] (* n n)))

(defn [f] (f 5))

(defn [n] (* n n))

(= 25 fn1 fn2)

^what he said

You're just comparing if a function (not the result of it's call) is equal to 25

And functions never equal to anything other than that one specific function instance IIRC.

oke, then I have the wrong answer again

this is the challenge :

"Higher-order functions take function arguments" (= 25 (_ (fn [n] (* n n))))

If that's the challenge then I think ian is correct

You wanted to do the right thing

You just misplaced a paren

((fn [f] (f 5)) (fn [n] (* n n)))

@jaen: a small specification to function equality - anonymous functions are all unique, but named functions are not. (= comp comp) evaluates to true.

@ian: yes, that's exactly what I've meant, but the way to put it is certainly more clear.

@roelof: what you're using to write your code?

at this moment light table

I think it has nice syntax highlighting with rainbow parens. They are really helpful - just pay attention to their colour - in your case you gobbled up the ( paren before the _ and it changed the meaning of your form.

oke, one question out of cursioity : can I change the fn part also to a #( ) part

yes.

they're semantically equivalent, it's just that sometimes it's nice to use one or the other.

Basically if the function is obvious enough you readily understand what %, %2 and so on mean in the context by all means use #(). Otherwise it's probably nicer to use fn and name the arguments.

Oh, and you also can't nest #(), so if you have to have a function within a function - use fn.

oke, I saw a few days ago a discussion about fn against #()

For example compare this change I did in a PR to kioo when fixing something once - https://github.com/ckirkendall/kioo/commit/18838fe504c3e6770752f87503766081746c188d

Which one is more readily understandable, the one with %s, or the one with names?

the names

when you use %2 you have to look every time what %2 is

So yeah, the rule of thumb is (reduce #(* % %2) some-collection) is probably still fine, if the function is more complex - you probably want names.

oke, so first choice will Always be to use fn

I would say as a rule of thumb, it's typically nicer to use fn, yes.

if the semantic meaning is extremely obvious due to the context or shape of the function, however, using the anonymous reader function syntax (#()) may be a reasonable choice.

Yeah; most of the time I decide to use #() first I then go back and turn it into fn anyway.

(defn return-a-fn-that-multiples-by-5 [] #(* % 5)) ((return-a-fn-that-multiples-by-5) 5) would return 25, and, arguably, using (fn [n] (* n 5)) is more noise than it needs to be.

that's a very extreme example though, so just use your best judgement. also, as always, it's good to be consistent.

what do you mean with more noise ?

I suppose by noise he mean visual noise and/or confusing code.

it's literally more characters is all.

oke, I think I like (fn [n] (* 5 n)) like the most

then you should go with that. whatever is easiest for you is best.

oke

Hm, is there any easy way to make all (keyword) keys in schema optional?

@jaen: https://github.com/metosin/schema-tools/blob/master/src/schema_tools/core.cljc#L217

@juhoteperi: So this takes care of keys inside things like conditional as opposed to a naive use of clojure.walk, yes?

@jaen: No, optional-keys is not recursive, it only works when given a map schema. There is however schema-tools.walk you could walk over a Schema and then call optional-keys for any maps.

Cool, let me check that out.

@juhoteperi: I've tried this:

(def EventType
  (s/enum :repair-requested))

(def RepairRequestedPayload
  schemas/RepairRequest)

(def Event
  (s/conditional
    #(= (:type %) :repair-requested)
      {:uuid UUID
       :type EventType
       :payload RepairRequestedPayload}))

(def EventQuery
  (st-walk/walk Event st/optional-keys identity))

(s/validate EventQuery {:type :repair-requested :payload {:type :stability}})

@jaen: Unline prewalk ja postwalk, walk is not recursive itself but you would need to call the walk again inside the inner

@jaen: Something like this could work:

clj
(defn recursive-optional-keys [s]
  (st-walk/walk s
                (fn [x]
                  (let [y (recursive-optional-keys x)]
                    (if (plain-map? y)
                      (optional-keys y)
                      y)))
                identity))

Also, could make sense to add prewalk and postwalk to schema-tools

I thought I did it similarly and I NPE'd, let me see what I did wrong.

Hey all, can anyone suggest a baby step to resolve StackOverflows from the attached code attempting to model the sieve of Eratosthenes... https://gist.github.com/paulspencerwilliams/9a5587d9826d1a6e5f94

@jaen: Perhaps you tried to call optional-keys on non-map schema?

Yes, I suspect that's that

I think you want to test for (and (map? schema) (not (record? schema)) to distinguish Schema records from plain maps

Yup, seems to work now, at least for my example case. Thanks a lot!

I don't imagine there's an easy way to have a common part of a conditional schema and have only some keys differ?

The experimental abstract-map Schema does allow something like that

Oh, interesting, I'll look into it.

Since you seem so knowledgeable about schema - do you think there's any way to do conditional coercion (that is a datum is coerced differently depending on the subschema it is in) with schema, or would I have to do it on top of that (by wrapping the values so I can differentiate them, or coercing separately)?

Hmm, the first option might be possible using dynamic binding, but I'm not sure

But that would only work in Clojure then, right? I guess I'll look into generating new schemas using the walker that would attach contextual information to relevant keys or something of the kind (because I don't think I'll be able to understand schema code well enough to modify it to let coercer get context information).

Thanks for all the help!

(s/defn test [a :- s/Int]
  (+ 2 a))
=> #'boot.user/test
(test 2)
=> 4
(test "derp")
java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Number

Is that the expected behaviour?

It seems as if the schema annotation is ignored.

@jaen: see http://prismatic.github.io/schema/schema.core.html#var-with-fn-validation

and https://github.com/prismatic/schema#schemas-in-practice

@ragge: thanks, wasn't aware of set-fn-validation!, I've only used schema for input/output validation & coercion, never for functions.

sreenath.n: cheers, just reading code now

Anyone using chime to schedule jobs? I can't seem to figure out how to pass in job data other than use global state. Which won't work for me.

jstew may i recommend https://github.com/zcaudate/cronj

cronj is nice, and I already started using it. I need to add a range of random seconds to the start of each job which is what made me look at chime.

ah

I can do the same with cronj, but have to start the job then sleep or timeout for a few random seconds but I don't want to do that if possible.

@jstew, I used cronj with an additional R pattern in the job schedule spec, e.g. R 0 0 *, where R was substituted with an (rand-int 60) before passing the spec to cronj. Didn't try chime...

@dm3 - nice! I didn't think about doing text substitution. That might work.

There's also quartzite but I kept swearing about it's verbosity.

I quite like Immutant's scheduling library

Though I don't know how it compares to Quartzite power-wise