@seancorfield thanks for the link, very useful. It's pointing me towards either maps or records as I'm building a small DSL

I'm still not clear on how to use core.match to pattern match on record types though.

but sounds like the advice is don't do it

Yeah, I think core.match is rarely used in reality. It has a fairly specialized use case -- structural pattern matching isn't an idiom in Clojure like it is in some other languages.

The default starting position is pretty much always "start with maps, switch to records only when you need them"

@seancorfield thanks, appreciate the advice

is lein uberjar good?

I see ppl remove it from a lot of projects

bad?

wait, what do you mean by removing it from projects?

from project.clj

uberjar is a task that lein can perform, do you mean they remove the uberjar specific config?

https://github.com/michaelklishin/monger/blob/master/project.clj this for example

it's not apropriate to use uberjar on a library, and leiningen should not be generating uberjar config for a libarary project

Sorry, it was my mistake, I was in a wrong folder... lol

in library we use deploy?

right, or install for local usage

its kind of hard to adapt.. i'm used to npm.. which is easy to get private from github

if what you want is to use a library like monger, you don't need to install it, just add it to your dependencies. If you need to use a library for your project, you'll need a private repo (or alternatively everyone can install it on their own machine, but having a private repo saves a lot of trouble)

Yes.. I guess it does.. I'm trying with this https://github.com/tobyhede/lein-git-deps but it doesnt help at all

@rcustodio You normally wouldn't pull in a dependency from GitHub in Clojure. What are you trying to do?

Any idea why eval-match always matches on A? (defrecord A []) (defrecord B [x]) (defrecord C [x y]) (defn eval-match [x] (cond (type x) A "Type A" B "Type B" C "Type C" (str "No Match: " x))) (eval-match (A.)) (eval-match (B. 1)) (eval-match (C. 1 2))

that's not how cond is used

think you mean case?

@sundarj I tried case, but I couldn't get it to match, it always returned No Match (defn eval-match [x] (case (type x) A "Type A" B "Type B" C "Type C" (str "No Match: " x)))

see what (type x) is outside of the function

This works, but was trying to figure out other ways to do matching (defn eval-cond [x] (cond = [(type x) x] [A x] (str "A " x) [B x] (str "B " x) [C x] (str "C " x))) (eval-cond (A.)) (eval-cond (B. 100)) (eval-cond (->C 100 200))

@sundarj it's test.match.A

this still returns No Match (defn eval-match [x] (case (type x) test.match.A "Type A" B "Type B" C "Type C" (str "No Match: " x))) (eval-match (A.)) '

ah

yeah looks like case treats the thing it is passed literally

I don't understand how to match on the type or a record as this also returns "No Match" (let [x (type (A.))] (case x A "A" test.match.A "test.match.A" "No Match"))

boot.user=> (case boot.user.A boot.user.A "a")

java.lang.IllegalArgumentException: No matching clause: class boot.user.A
boot.user=> (case 'boot.user.A boot.user.A "a")
"a"

@genec you can use condp or a multimethod

@sundarj the quote is interesting, but not sure how to quote the type of a function argument. I think you're right condp is the best option. I was just trying to understand case and cond better. Thanks for the help!

no problem 🙂

@sundarj this works (let [x (type (B. 1))] (condp #(= %1 %2) x A "A" B "B" "No Match"))

@genec you could just use = directly, no need for the anonymous fn

@sundarj right, I was building up to this, in which case I need the lambda. thanks. (defn type-to-string [x] (condp #(= %1 (type %2)) x A "A" B (str "B : " (:x x)) "No Match")) (type-to-string (A.)) (type-to-string (B. 100))

wouldn't (condp = (type x) ...) work?

but using the let looks cleaner

@sundarj omg! yes! thank you, that's it. (defn type-to-string [x] (condp = (type x) A "A" B (str "B : " (:x x)) "No Match")) (type-to-string (A.)) (type-to-string (B. 100))

@genec nice!

@genec for completeness, here's the multimethod version:

boot.user=> (defrecord A [])
boot.user.A
boot.user=> (defrecord B [x])
boot.user.B
boot.user=> (defmulti type->string type)
#'boot.user/type->string
boot.user=> (defmethod type->string A [x] "A")
#object[clojure.lang.MultiFn 0x4ccb03cd "clojure.lang.MultiFn@4ccb03cd"]
boot.user=> (defmethod type->string B [x] (str "B : " (:x x)))
#object[clojure.lang.MultiFn 0x4ccb03cd "clojure.lang.MultiFn@4ccb03cd"]
boot.user=> (type->string (A.))
"A"
boot.user=> (type->string (B. 42))
"B : 42"

oh right and the default:

boot.user=> (defmethod type->string :default [x] "No Match")
#object[clojure.lang.MultiFn 0x4ccb03cd "clojure.lang.MultiFn@4ccb03cd"]
boot.user=> (type->string 2)
"No Match"

@sundarj thank you very much, that's great

I forgot about the default too

anyone using vscode with visual:closure? i am getting exceptions in the repl when trying to evaluate stuff in the editor

Do you mean the clojureVSCode extension? I tried both of the vs code Clojure extensions as I really like vs code, but ended up using Atom with proto-repl as I had trouble getting the vs code / Clojure setup working.

@ashnur have yo watch this? https://www.youtube.com/watch?v=73PnuVBkXxU it's now called Clojure code

i have not

i meant visual:clojure https://marketplace.visualstudio.com/items?itemName=stiansivertsen.visualclojure

interesting, I hadn't heard of that one

will try a different one next time i will have time to mess with clojure.

@ashnur For vs code the Clojure nRepl extension by Andrey Lisin is the most popular and the latest version starts / connects to nRepl when you open an project now. There's also Atom with proto-repl that's pretty popular and also lighttable if you want something that just works out of the box for playing around with Clojure.

i ignored the mention of atom earlier, and thanks for suggesting, but will ignore it for a while, because sadly my machine doesn't bare the specs required for running atom with all the things that i need. vscode feels more lightweight, certainly more snappy

as i mentioned previously, next time i will have some time for learning, will try a different extension, actually, already installed the version Lisin authored

sounds good. I just updated and tested the extension from Andrey and it works fine, takes a few seconds to connect to the nRepl. ctrl + shift + e evaluates the file. Whereas the proto-repl lets you evaluate blocks of code so it's more interactive (if that makes sense)

we're fortunate to have so many open source tools to use

dunno, i wish i had 1 tool that works instead of 1000 that doesn't

certainly we are fortunate that we are allowed to create freely and give it away for corporations

freely

</protest>

Just realized that if you select a block of code and ctrl + shift + e then it evaluates just the selected block, if nothings selected then it evaluates the file. cool!

Hey friends, silly convention question. I’ve got a function that will either return a byte-array or nil. Whats the best convention for handling the optional return value of this function, from the callers perspecive?

@joe.lane some-> is handy if you know a result might be nil

great, thanks!

I am a Clojure noob. I want to build a desktop app using seesaw. However, I have a problem with the choice of the build tool. On one hand, if you google for leiningen vs boot you will get lots of hits praising superiority of boot, but on the other hand, I have big troubles making the basic examples work. To what extent I should trust Google preferring boot. From a noob perspective, is it better to ignore boot and stick to leiningen?

I like boot, but lein is fine and I used it for a long time

@ruby.object most things will assume lein familiarity, even boot related stuff often does

for a beginner, use lein until you know you need boot, I’d say

leiningen is also much more thoroughly documented

the reason there are a bunch of blog posts about 'boot is better than lein' is because lein is the defacto standard and it's what most people are familiar with

it's not cause lein is garbage

(lein is actually very good)

thanks

lein is great and don't forget there are plug-ins for it too

One thing I do like about boot as a beginner is the repl experience. When you work in a directory from boot repl, boot automatically creates a file called .nrepl_history which contains the repl expressions that you’ve executed. So, if i’m firing up a repl to do some quick experimenting I reach for boot repl.

But I agree in general about starting with lein.

Gorilla REPL is also a fun way to record repl history: http://gorilla-repl.org/index.html

I think .nrepl_history is a thing nrepl does, you get it with lein too

@ruby.object if you're learning seesaw you should also check out quil http://quil.info/

also, nothing beats clojure.jar for quick repl experiments (if you don’t need other deps)

@genec i definitely will have a look, now i need to find how to integrate it with a desktop application

todays your lucky day... https://noobtuts.com/clojure/2d-pong-game

https://noobtuts.com/clojure

@genec I guess it's time to start trying out the examples 🙂

@genec quil+lein is amazing, I did lein new quil hello quil, opened the core.clj file, started repl and selected menu Load all project files

and this thing worked first time, i saw the window with animated ball

@ruby.object I agree 100%, I find with clojure and lein things just work. There are some good lein tutorials on youtube that are worth watching. here's a good one to start with. https://www.youtube.com/watch?v=mDwNgQhh0hY