Isn't part of the issue with the desire that some would like it to work across both clj and cljs? I think the expression Sean gives above works for clj only.

no I mean, I don't understand the desire to use alias like that at all

I mean, I understand mechanically why people want it, and it does

but even using namespaced keywords, I never use alias to create a short way to type them

You type fully namespaced keywords out manually each time, and/or copy/paste, or Emacs dynamic abbrevations, etc?

Certainly I think some devs might not be taking better advantage of plain old copy/paste as often as they might.

I copy and paste and use tab completion

but I suspect it is born from the simple observation that they can easily create aliases for vars in other namespaces, so why not keywords?

maybe it is a sort of circular thing, they see aliases in examples, so they use aliases, and because they use aliases they it is annoying that cljs doesn't have them. and instead of walking all the way back and rethinking the decision to use aliases, they just want aliases in cljs?

People use aliases for namespace on vars all over both clj and cljs

Portably, in cljc files, too.

it isn't the same thing though

which makes me think, it is a shame the namespaces for keywords and namespaces for code are both called namespaces

I'm happy to get a deeper understanding of the differences, which I haven't thought through deeply, but at least at the level of X works for Y, why doesn't X also work for Z? kind of analogy reasoning, it is a reasonable question to ask, I think.

namespaces for code are a very formal thing, the runtime keeps track of them, and there are rules about them, and they exist independently of the names in them

keyword namespaces are just prefixes

like, a keyword is basically a pair [namespace-part, name-part]

Maybe it is a shame they are called the same thing, but that name is enshrined by Clojure core docs and functions like namespace and name, from folks that are usually pretty careful about what they call things.

well, they are literally namespaces

but calling them the same thing leads people to thinking they are connected in someway

They are connected in at least one way -- require with :as to create an alias for a namespace, you can use the alias both for Vars and for keywords.

these days we try to prefer the word "qualifier" for the first part of keywords and symbols

as in qualified-symbol?, qualified-keyword? etc

the qualifier may correspond to a namespace or an alias, or neither

how do you do authentication/authorization/session management in clojure?

one option: go with pure clojure land, e.g., buddy, but I am not sure for the maintenance and future support

the other option is: go with java libraries, e.g., spring security, but it seems too bloated, and I worry about the inter-op.

https://purelyfunctional.tv/article/clojure-web-security/

@seancorfield what’s your dev env? intellij+cursive or emacs+cider ?

A while ago someone mentioned Apache shiro(a Java library for all that) and it looked interesting but I haven't actually used it yet, just bookmarked it for the future

Ya, I think Shiro is a good option if your using a servlet server like jetty

It's very actively maintained

I think in theory it is possible to use in non servlet environments as well, people say you can even use it for command line apps. But I think in those cases you have more to manually setup

hi! how can I import two Java classes with the same base name? I've tried this but the compiler complains about Foo being already defined:

(ns my.ns
  (:import [my.first.package Foo]
           [my.other.package Foo]))

however, if I just add the fully qualified name, like this, the compiler also complains about ns not conforming to its spec:

(ns my.ns
  (:import [my.first.package.Foo]
           [my.other.package.Foo]))

Oh, I see. From the docs (https://clojure.org/reference/java_interop), I seems that the only way to do it to not import either class and use my.first.package.Foo or my.other.package.Foo everywhere in the code

Hi GM

at least for me its morning 😛. Question is there a function that lets me apply a transformation to a stream... meaning i want to consume a stream make an operation and return a stream (unknownFunction myTransformer (slurp myStream))

?

slurp returns a string, not a stream

but usually you want map

your stream is an input stream of bytes? you want to transform individual bytes?

yeah. so i would like it as a string first. but i would imagine that would be part of my transformation

string as in lines of text?

yeah as in html

there is line-seq for that that works on a reader

(->> (io/reader "my-file") line-seq (map str/upper-case))

(io/reader should be used with with-open though)

ohh cool i can then use map directly then

cool I think thats what i was looking for thank you

Is there a way to programatically obtain the source location for protocol implementations?

Say I have a protocol from a library (defprotocol Flippable (flip [x)) and then extend that protocol elsewhere in different namespaces

(ns my.app)
(extend-protocol other.lib/Flippable
  Pancake
  (flip [x] ...))

Then given the function flip and type Pancake, I want to somehow get the file/line number of the extend-protocol expression

hi everyone, why global atom isn't shared between deftest functions ?

It should be

Does anyone know of a good library for coercing column names and values from SQL results?

e.g. {:foo_id "test"} to {:foo/id :test} given some definition like [:foo :foo_id keyword name]

Does it have anything to do with sql?

I've used clojure.set for this before: https://clojuredocs.org/clojure.set/rename-keys

https://github.com/riverford/mappings is really interesting in this space if you're not after something sql specific

Thanks @dominicm, that looks interesting.

You could also check out https://github.com/wilkerlucio/spec-coerce

(sc/coerce `(s/map-of keyword? int?) {"foo" "42" "bar" "31"})
; => {:foo 42 :bar 31}

Does anyone remember what dependency combination will fix this exception?

No implementation of method: :has? of protocol: #'clojure.core.cache/CacheProtocol found for class: clojure.core.memoize.PluggableMemoization

@weavejester - saw this a couple of months ago, maybe it can fit your needs? https://github.com/noprompt/meander

I have a collection of email messages as Clojure data called threads that I'm trying to extract some info from, mostly via string/HTML parsing. Sometimes the messages have an unexpected format and for now I just want to ignore those errors. Something weird is happening when I eval at the repl. (map #(try (all-info (:body %)) (catch Throwable th nil)) threads) gives: Error printing return value (IllegalArgumentException) at clojure.core/-cache-protocol-fn (core_deftype.clj:583). No implementation of method: :date of protocol: #'tick.core/IExtraction found for class: nil The specific error doesn't really matter, what's weird to me is that it shows up at all since I'm catching everythng. Even weirder, (map #(try (dump (all-info (:body %))) (catch Throwable th nil)) threads) works as expected, returning the results without any error. dump is just a fn that pretty-prints its arg and returns it. I don't understanding why wrapping in a printing fn would affect the try/catch behavior.

Is all-info returning a lazy-seq? It probably is all-info calls map

No, all-info just returns a map: (defn all-info [thread] {:confirmation-number (second (re-find SUBJECT_CONFIRMATION_REGEX (subject-1 thread))) :departures (departures (html-resource (StringReader. (message-1 thread))))})

For a lazy-seq, the values aren't realized until they are requested. In this case they are being realized when the REPL looks at them to print them, which is past the try form

I see, so the dump call would realize the seq earlier

If any of those are lazy, you can get that behavior

Exactly

Wow, that is a tricky little interaction, thanks @jshaffer2112, saved me a while there. Do people generally just sprinkle in into calls or something to coerce to collections explicitly?

If I want instant realization, I use vec or mapv (mapv is just map that returns a vector instead of a seq)

Ok. I think the laziness is coming from a for buried inside departures.

But it's usually not for that reason. That type of error catching is really hard to debug. I would prefer to filter out things that will cause that type of error

and do any necessary try right around where the error can occur, not in a parent function

Yes, for is lazy. Normally laziness is good to have, so I rarely force realization

instead of (try (for ...) catch Ex e) you could write (for [i [...]] (let [x (try ... catch )]), i.e. make the error handling more local

at least, that's one way to do it

Usually, yes. Those have different behavior though. (try (vec (for ...) catch Ex e) will return nil if anything inside causes an error, while the second example will have a nil for each value that caused an error

Right, I'm just being lazy (pun intended) at this point since it's early prototyping on a side project. Also, it turns out that any message that doesn't parse for any reason is irrelevant anyway, so I'd rather just express that once at a high level than catch a bunch of specific parse failures, only to wrap and propagate them up for the same effect.

You could put the try inside all-info then, and just call (map #(all-info (:body %)) threads)

You would have to realize departures, so (vec (departures ...)) maybe

True, that might be better. It's interesting to see how laziness interacts with everything here. It feels like a non-local effect. Haven't been bitten by that before.

Laziness interacts in odd ways with lots of things: dynamic binding, side effects of most kinds, and exceptions.

Things go so much smoother if you write as many pure functions as possible

It is also something that you do not always notice in repl tests, due to the forcing of laziness caused by the P

Yes, that's definitely a good rule, but it's still interesting to think about. When you're in pure, data-manipulation code, laziness feels like a good default, but otherwise eager-by-default seems to fit better. I believe at one point Rich said laziness might not be as pervasive in the language if he'd landed on transducers earlier.

@jshaffer2112 Are you talking about pure to the point of using monadic composition for error propagation and avoiding try/catch?

No, I just filter out or just return nil for invalid values. I mean pure as in "when you call it, it does the same thing every time with no side effects". Not that it can't use side effecting operators like try-catch internally, just that they can't escape

I might throw IllegalArgumentException, and you can find ways to crash things, but usually exceptions are from programming errors

I want to give spec a try though. Then it'll be "pure as long as the spec validates"