Cool

Hey guys, needed some help.

I haven't been able to make my function which determines whether a number is even or not performant.

(defn is-even?
  [x]
  (let [i (atom 0)
        even-or-maybe-odd (atom true)
        return? (atom false)
        result (atom nil)]
    (while (not @return?)
      (if (= @i (max x (- x)))
        (cond (true? @even-or-maybe-odd) (do (swap! return? (fn [r] true)) (swap! result (fn [k] "Even")))
              (false? @even-or-maybe-odd) (do (swap! return? (fn [r] true)) (swap! result (fn [k] "Odd"))))
        (do (swap! i (fn [n] (+ n 1)))
            (swap! even-or-maybe-odd (fn [n] (not n))))))
    @result))

It works fine for small values. But bigger values it takes time

Is that an accepted hit? Or am I doing something wrong?

I have no idea what you are trying to do but a normally performant way to check for even or odd on integers is bitwise and

https://github.com/clojure/clojure/blob/841fa60b41bc74367fb16ec65d025ea5bde7a617/src/clj/clojure/core.clj#L1378

But that returns boolean. I need to return a string.

Its also using a lot of java. Which would be difficult.

(str (even? 1)) ?

Yes but I need to return "Even" or "Odd" string.

ah

(if (even? x) "Even" "Odd")

Awesome.

(defn- even?
      [x]
      (let [i (atom 0)
            even-or-maybe-odd (atom true)
            return? (atom false)
            result (atom nil)]
           (while (not @return?)
                  (if (= @i (max x (- x)))
                    (cond (true? @even-or-maybe-odd) (do (swap! return? (fn [r] true)) (swap! result (fn [k] true)))
                          (false? @even-or-maybe-odd) (do (swap! return? (fn [r] true)) (swap! result (fn [k] false))))
                    (do (swap! i (fn [n] (+ n 1)))
                        (swap! even-or-maybe-odd (fn [n] (not n))))))
           @result))

(defn is-even?
      [x]
      (if (even? x) "Even" "Odd"))

Why can’t you use the built-in even??

I have to implement my own even?.

mod 0

But you didn't implement your own... you just wrapped the built in. edit: How did I look past the first fn? 😛

well, 2 = 0

@mihir

(defn even? [x]
  (= 0 (bit-and x 1))
)

You can use zero? instead of (= 0 ...)

Oh cool

I would use even? instead of writing my own tho 😄

I'm still not sure what we are doing here

(defn even? [x]
  (zero? (bit-and x 1)))

oh is that a style thing?

Looks a bit better

I'm a noob if you can't tell 🙂

https://github.com/bbatsov/clojure-style-guide

Is there a fmt thing that uses those rules?

Been enjoying gofmt at my day job

clj-fmt I think.

https://github.com/weavejester/cljfmt

Cool!

There are plugins for Leiningen and Boot too I think.

yeah looks like it

BTW folks, for "noobs", you can usually find folks will be more attentive and go into more detail in #beginners (since folks opt-in there to help new Clojurians).

@mihir Your algorithm is linear in the size of the number which is why it is slow for larger numbers.

You also have a lot of unnecessary complexity in your code. (swap! my-atom (fn [_] value)) could just be (reset! my-atom value) -- but that's all very procedural since you're using a lot of mutable state. Very non-idiomatic for Clojure...

Thank you.

Anyone familiar with https://github.com/dm3/clojure.java-time? I’m trying to set the seconds, and ms of a local-time to 0 but it’s not clear to me how to do that.

@jayzawrotny Sounds like you want to truncate to minutes?

(jt/truncate-to (jt/local-time) :minutes)

I looked at that function

Truncates this entity to the specified time unit. Only works for units that
divide into the length of standard day without remainder (up to `:days`).

@mihir I don't think threading helps readability there -- and a simple if is going to be clearer than using a lookup map

(defn even? [n] (if (zero? (mod n 2)) "Even" "Odd"))

"up to :days" means it can't be bigger than days -- but it can be smaller.

Been writing a lot of Swift code lately. holds head in hands Just a thank you to @richhickey for values-first so I don't have to craft boilerplate abominations like this in Clojure just to do copy-on-write structs:

public struct PIDParams {
   var kP: Double
   var kI: Double
   // ...etc.
}

protocol Cloneable { // uggghh
    func clone() -> Self
}

extension PIDParams: Cloneable {
    func clone() -> PIDParams {
        return PIDParams(
                kP: , kI: , kD: self.kD,
                deadzone: self.deadzone,
                minOutput: self.minOutput, maxOutput: self.minOutput,
                minWindup: self.minWindup, maxWindup: self.maxWindup)
    }
}

// in order to do convenient struct mutation:
let pid1 = PIDParams(kP: 0.5, kI: ...)
var pid2 = pid1.clone()
 = 0.7

haha, I love it when your langauge can't deal with minX: self.x, minY: self.y (* 1000) in any reasonable way

Hi all, somebody using clojure.jdbc? what method (eg: execute!) should one use for a query like “insert into .. returning id” (postgres)?

db-do-prepared-return-keys

@mping i use jdbc/execute! like this

@mavbozo tks I figured it out, was using a bad postgres driver

Hello. I'm testing the new alpha7 but I cant understand this error message: https://gist.github.com/souenzzo/17ec14b0ecbf676b7cb9af79aff5409b

@souenzzo that's not alpha7

Syntax error macroexpanding clojure.core/ns at (1:1). Cause: Call to clojure.core/ns did not conform to spec.
((:import [org.agrona.concurrent UnsafeBuffer] [java.nio.ByteOrder])) - failed: Extra input spec: :clojure.core.specs.alpha/ns-form

this is alpha7

and the issue is that the ns decl should be

(ns ^{:no-doc true} onyx.state.serializers.windowing-key-encoder
   (:import [org.agrona.concurrent UnsafeBuffer]
            java.nio.ByteOrder))

So (ns foo (:import [some.class])) is not working anymore

against the new core specs

is this intentional?

yes

the [foo bar] syntax is only intended for prefix usage

I'm using luminus and I did lein rollback and now lein migrate won't work... wth

@bronsa So I don't have to import anymore if don't need an alias?

no you still have to import

sorry I totally glossed over the "if I don't need an alias" part 🙃

you never had to import classes if you don't need aliases

classes are automatically loaded on first use

great thanks for clarification

why does it say "Migration reserved by another instance. Ignoring." and now the databse is empty, this is madenning

im just going to create a new project and copy all the files over..

Is there a way with transducers to instead of using conj function to tell it to conj by 3, or partition within the tranducer expression, or would that just have to be done afterwards.

@theeternalpulse your profile picture is amazing.

thanks lol, I made it myself

@theeternalpulse there's a partition-all transducer, if that's what you're looking for

bikeshedding question: When you have a boolean value in a config map, how do you name it?

(def option-a {:do-the-thing true})
(def option-b {:do-the-thing? true})
(def option-c {:should-do-the-thing? true})

If i'm going to be serializing to JSON I usually leave the question mark off. Otherwise I tend towards the middle option

{:the-thing? true}

+1 for {:the-thing? true} (unless you're serializing to JSON -- leave the question mark off)

(and, yes, deliberately without verb/sentence prefixes)

:would-do-the-thing? or :could-do-the-thing? depending on mood 😉

:under-prevailing-conditions-would-the-task-in-question-be-carried-out?

Looks like option b (more or less) is the big winner, the guy doing my PR is going to be so pleased

some fun trivia I learned today

ledger.tools.event-ids-test=> (.keySet {:a 0 :b 1})
#{:a :b}
ledger.tools.event-ids-test=> (get (.keySet {:a 0 :b 1}) :a)
nil

.keySet seems pretty rarely used even with in the Clojure implementation itself -- a couple of places in the compiler. Did you have a reason for using it vs. (set (keys my-map)) ?

it is interesting that get specifically checks java.util.Map, but not java.util.Set

yeah - it was more of a "wouldn't it be clever to use this built in method instead of (comp set keys)" followed by WAT

and easy to replace it with (comp set keys) given that result, of course :D

Oh, yeah. Another weirdness there, of course: (get (java.util.TreeSet. [1 2 3]) 1) => nil

There are other good reasons to avoid using mutable collections in Clojure, too.

ledger.tools.event-ids-test=> (.contains (.keySet {:a 0 :b 1}) :a)
true

e.g. clojure.core/hash is not consistent with clojure.core/=, so you typically cannot find mutable Java collections if you try to use them as set elements or map keys.

yeah, mutable items as keys only make sense with object identity

Hi. Does anyone know what is the status of clojure-in-clojure implementation? is it any usable in production?

I don't think there is a clojure-in-clojure implementation that has been maturing, but it is a dream

just checked out clojure.tools.emitter.jvm and trying to make it something