with lein profiles/injections, is it possible to ensure that clojure.repl is require/use'd in every name space during interactive development? like, the equivalent of a global require? So that (doc doc) would work no matter which ns I change into as I develop?

In short, no

In long, there are various plugins in various tools that try to do some version of this but they’re all kinda meh

thanks - I like reading it right in the repl as opposed to an editor interface (like cider/emacs buffer for doc) or on a website, but I guess I'll make due

from all ns'es you can do (clojure.repl/doc foo)

I actually use Cursive and instead use the key command to open the doc typically, but sometimes use the fq form if I'm not in user

I have a fn #(set [% id]) which returns a set. It first creates a vector and then converts it into a set. Is it possible to this in one step like what the vector fn does.

@murtaza52 #(hash-set % id)

thanks @vlaaad

(let [ary (int-array 2 2)]
  (aset ary 0 1 3)
  (aset ary 1 0 4)
  ary)

Execution error (IllegalArgumentException) at java.lang.reflect.Array/set (Array.java:-2).
Argument is not an array

there is something wrong with arguments

args are array index val

(let [ary (int-array 2 2)]
  (aset ary 0 3)
  (aset ary 1 4)
  ary)

Oh it's the behavior of int-array

(let [ary (make-array Integer 2 2)]
  (aset ary 0 1 (int 3))
  (aset ary 1 0 (int 4))
  ary)

ah, it's nested arrays

Hello! Is there a predicate that is true only for vector, list, and set but not a map? Thanks!

#(not (map? %))

For MacOS, is installing Clojure via homebrew, and then Boot, a good way to get up and going?

Is there a different pathway for those thinking about Clojurescript?

I think the JS world is converging on advice for up-and-going setups

Is there anything like that for Clojure or Clojurescript?

Is there like a major blog post that people refer to for setting up their Clojure development environment?

@slack1899 https://corfield.org/blog/2018/04/18/all-the-paths/ - this gives some history / overview on clojure build tools

@slack1899 this can also be helpful - https://github.com/clojure/tools.deps.alpha/wiki/Tools#versioning-and-releasing - listing of different tools which build on tools.deps

meow, the guide on the Clojure site does a good job of going through the basics

Are you looking for something other than how to install the CLI?

I guess this can never happen in Clojure? just want to make sure:

(let [%x 1] #(+ %x 1))

what I want to make sure: if a symbol in a fn literal starts with percent, it's not something from the outer scope

@danielsz’s article about Lisp, following Heart of Clojure, is now #1 at Hacker News: https://news.ycombinator.com/item?id=20696931 .

@borkdude nobody sane would do it, but it's legal

@noisesmith not sure, because I can't get it to work in both CLJS and CLJ

oh wow, I thought it would be legal, but testing it I guess it's not

how does clojure decide what are the command line args to a script?

clj -e '(println *command-line-args*)' 1 2 3
(2 3)
Execution error (FileNotFoundException) at java.io.FileInputStream/open0 (FileInputStream.java:-2).
1 (No such file or directory)

I believe the command-line-args only apply to main classes

here clojure.main is taking two commands -e and an expression and the last args are being interpreted as a script to run (1) and the args to it (2 3)

so this isn't a valid command, which is making it kind of weird

@borkdude

$ clj -e '(println *command-line-args*)' - 1 2 3 </dev/null
(1 2 3)

that asks it to read from STDIN, then sends EOF on STDIN

alternate, golfed

$ echo '(println *command-line-args*)' | clj - 1 2 3
(1 2 3)

when implementing ISeq on a deftype, is it required to also place the ISequential marker protocol on the deftype?

what is ISequential? if it exists it isn't in clojure.lang

Sorry just Sequential

clojure.lang.Sequential to be precise, I would hope that was implied

I usually don't mess with deftypes but just now I was messing around and had a type that fully satisfied clojure.lang.ISeq, yet would complain that nth was not supported on the type

oh yeah, Sequential comes in via this codepath https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/RT.java#L900

i somewhat instinctually looked for protocols that may be associated with that method, found Indexed and Sequential, figured Indexed didn't make sense for my case and just shoved Sequential in there and all my problems went away.

but I kind of just blindly did it based on a hunch

ahh so that's called before Seq is actually called

provided it's not any of the prior cases (charsequence, array, matcher etc.)

so without Sequential it can't even call it's own seq implementation

hmm, even if you have Seqable I guess

yeah i had Seqable implemented

this took me quite a while to blindly stumble my way into

One more question ... when defining a function that shadows an existing protocol method in the same namespace, I was surprised that the protocol version still was visible. I assumed that latter defn would clobber the protocol version and this wouldn't work for example:

So it appears that the polymorphic version is still in the namespace, despite that I've defined over it. How does that work? Does the call to (some-thing 10 thing) somehow know there is an existing polymorphic version and check the types there first before dispatching on the "catch-all" (unimplemented) version or something? I wouldn't think so because for fallthrough implementations you have to explicitly implement them on Object.

the definition on L8 is shadowing the protocol def

you're in the realm of undefined behavior here

but it actually doesn't outright shadow it, because the body of the same function correctly dispatches on the first argument (the protocol version is called)

or maybe a better description is that it shadows it, but somehow the protocol version is still available in the namespace when called with the appropriate arguments

protocol functions have some metadata attached which the compiler uses to guide how they are compiled and re-defing doesn't clear that metadata

so some-thing is being compiled as a protocol call when it shouldn't be

hmm

i was going to say... it's as if every single call to some-thing is dispatching on it's type, whether or not implemented as a protcol method

like somehow the subsequent global def is being added to the protocol table as a catchall or something

no

i don't literally thing that is happening... i said "as if"

I would probably make the protocol version -some-thing to avoid any confusion, but I was surprised nonetheless that the shadowed version was available

it isn't

it is a weird compiler bug and you shouldn't use it as a feature or try to explain how it is working, which is what @ghadi was getting at by calling it undefined behavior

if you create a protocol function then def it as a normal function, assume the compiler is going to output code that will zero out your hard drive

yah, i know the standard behavior is to prefix the protocol method with "-" and wrap that if needed

I was more curious when I accidentally wrote the code how it was working, not planning on using it for real stuff

just trying to understand

why even use the same name in the same namespace?

strictly for my own education, I am not suggesting this is a good pattern

again, i would just do (defn some-thing [x this] (-some-thing this x)) if i needed this

Just trying to correct my mental model of how protocol definition/dispatch works, which was obviously not quite right when i stumbled on this

FWIW @creditobrasil the call (some-thing 10 thing) in your example causes a stack overflow in ClojureScript

that's what I would have expected

I'm not complaining or anything... just curious what's going on under the hood

Yeah, I suspect ClojureScript's behavior matches your mental model. 🙂

good enough for me

Even then, ClojureScript is a bit tricky (and I think so is Clojure) because the compiler can see and optimize a "self call"

i'll just stick with @hiredman's recommendation and assume any use of the shadowed version as presented will rm -rf my drive

nope

I could also evoke the dancing frog.

(re: optimizing self calls)

Clojure doesn't do anything with self-calls? Cool.

and calling it undefined behavior is kind of stretch too because that assumes a definition where it is left out so as to be undefined

and there rather pointedly isn't a spec for clojure or clojurescript

ClojureScript often uses Clojure for that purpose. 🙂

so if you call it a bug in the compiler that is hard to fix or undefined behavior to some degree depends on how close you orbit to rhickey

Hrm, (doc def) seems to double the copy... wonder if that is a regression.

^ https://clojure.atlassian.net/browse/CLJ-2295

there's an extra "Please see" in the middle, yeah

happens with if too

I was curious about whether it is specified that the init in a def can refer to the name being defined.

you can see it if you squint and read between the lines (the fact that it creates the binding, and then evaluates init, implies that the init can use the binding)

yeah, I agree