isn't it the same as

(constantly true)

@a13 It also has built-in gen support like the other core predicates

I am having a hard time deciding between (:foo (:bar bat)) vs (-> bat :bar :foo)

just for the case of two calls

a third option to complicate (i think this is a matter of preference, really) (get-in bat [:bar :foo])

there's only one solution: graph them

hold on

nah, threading macro wins in every case over 2

My guess is ‘get-in‘ is the most idiomatic as it was created for this use case

I just realized I'm in #beginners

but I also realize that was a pretty noob question 😄

but I have been using Clojure since 2009

@jcromartie I tend to prefer (-> bat :bar :foo) unless I want to have a default value, then I use (get-in [:bar :foo] default-v)

i’m trying to implement an idiomatic-ish version of processing’s PVector

so far i’ve got this: https://gist.github.com/swizzard/aa1cf41c93bc476d5693caf2930f3891

i’m not sure if that’s the right way to go, however

@swizzard just a small thing, more elegant than try catch I think ^

oh word

i didn’t know about that 🙂

can you use protocols as type hints?

protocol methods don't need hints, but if you use the method call via interop, you can type hint with the interface the protocol creates

eg. if you have (defprotocol Foo (bar [this])) you can either use (bar x) or (.bar ^this.ns.Foo x)

no i meant could i (defprotocol MyProtocol (thing [foo] ...)) and then do (defn my-func [^MyProtocol mp1 ^MyProtocol mp2] (do-something-with (thing mp1) (thing mp2)))

you could but it doesn't do anything useful

protocol methods don't need hints

(the function version, non interop, that is)

ok

if you think about it - clojure knows that the argument to thing (a function) will also be a MyProtocol

as opposed to .thing, which could hypothetically come from somewhere unknowable to the compiler

which is what makes reflective code needed, which is why we have hinting

ooh ok