neat

problem is im not sure what I'm looking for

under Maps, in the “Examine” row, it shows the three most common ways

how to phrase it, rather

oh , i see

e.g. if your map’s keys are keywords, you can do (:some-key my-map)

if they’re not, you can do the opposite: (my-map "some-key") or (my-map 10001)

those are quick shorthands for accessing maps. you can also use the get function, which does about the same thing. for deeply nested maps, there’s also get-in where you can give it a path of keys to look up

oh great now i have a null pointer exception

fixed it

can I create a new instance of the list, but without the last item in it?

yep (drop-last list)

does (drop-nth exist?

(drop n list) does

ah, you want to drop the nth item

https://stackoverflow.com/questions/24553524/how-to-drop-the-nth-item-in-a-collection-in-clojure

the top solution is the one you should go with if you want it to be lazy like drop/`drop-last`

Anyone with some experience regarding batch-ques with rabbitmq? I am currently trying to implement a "User-notification-que" where they can Accept/Cancel. Grouping users together. I want to try and not save info in a database since they're not important to me if all 10 of them don't accept.

Hey! I want to use data_readers.clj in my project, but I get Attempting to call unbound fn: #'equipage.data-reader/money:

My file layouts look like this:

Question: I am trying to move environment variables from profiles.clj into the project.clj file. The only thing I want to keep in the profiles.clj is passwords/credentials. In my project.clj I have :profiles { :dev [:shared :project/dev :profiles/dev] } where :shared is defined as :shared { :env { :mysql-port "1433" } }

When I run lein with-profile clj,dev run I get an error

Error encountered performing task 'run' with profile(s): 'clj,shared,dev,dev'

I noticed that there are two dev profiles. Why is this?

It is my understanding that the two dev maps defined would get merged into one.

I suspect that is just the way Leiningen prints them (using name on :project/dev produces just "dev").

Leiningen prints the fill list of profiles being applied. Behind the scenes, they are merged into a single "profile".

@mario.cordova.862 Do you have the lein-environ plugin in your project.clj? (per this SO Q&A: https://stackoverflow.com/questions/21517583/cant-access-environment-variables-in-leiningen-project-clj-with-environ )

@seancorfield I do have that plugin installed but I got it working by changing the profile name to something else. So it became :profiles { :develop [:shared :project/dev :profiles/dev] }

profile name became :develop from :dev

Ah, interesting...

(there's a #leiningen channel if you get stuck with quirks of Leiningen and no one here seems to be able to help -- caveat: I don't know how active it is since I don't use lein)

@seancorfield apart from the confidence of using an “official” tool; have you found a tangible benefit since switching from lein/boot -> clj?

debating whether to take that leap

@dadair I like the simplicity and consistency of it (sorry for the slow reply -- was in a meeting from 11am).

I like that it adds less "weight" to the dev/test/build process.

We're looking at migrating at least some of our dev/test/build process at work from Boot to clj but we have a lot of machinery in Boot right now so that has proven challenging so far (I think I've had that branch open for a few months now!).

hey! I am trying to filter using or and two predicates but it doesnt work

(defn calcMultiples [limit n] (take n (filter (or multipleOf3 multipleOf5) (range limit))))

or takes two Boolean (or at least truthy) values...

okay, i see

looks like I have to work on the predicate

You could either write it out explicitly -- (fn [v] (or (multiple-of-3 v) (multiple-of-5 v))) -- or look at some-fn

And a word on style: in Clojure we use kebab-case for most names, rather than camelCase (like Java etc).

And "Welcome to Clojure!" @gold88

Thank you for your feedback and helpful advice on my first lines of clojure 🙂 happy to be here @seancorfield

How would I impose an upper limit to a lazy sequence?

>whose values do not exceed four million. I just added a predicate like before but It can't be the right thing.

since the filter is called after the number has been calculated, i probably wanna check that before

take-while 🙂

(although, in this case, don't you just want to ensure limit is no bigger than four million?)

https://projecteuler.net/problem=2 it's talking about the computed fibonacci values which are even

so i guess, I can't limit it in another sensible way 😕

ralf what was your solution?

wait, what do you mean in a sensible way?

(defn fib ([] (fib 0 1)) ([a b] (lazy-seq (cons a (fib b (+ a b))))))
(defn even-fib [n] (take-while #(> 4000000 %) (filter even? (fib))))

nice. very similar to what i did

fib was not my original idea, I looked at the clojuredocs

even-fib is mine tho 😛

yeah. it's a good one to get used to the lazy-seq macro.

my first idea was to just use a loop

nice. you can also just piece everything together like

(->> (fibs)
     (take-while (fn [v] (< v 4000000)))
     (filter even?)
     (reduce + 0))

clojure is very good at making these expressible chains

right now im scared of anything that has a ->

the threading macros ->> and -> can really aid in readability

yours is (->> (fib) (filter even?) (take-while #(> 4000000 %)))

I think I avoided the threading macros for the first month or two

they'll come when they come 🙂

And, like anything else you will soon be overusing them :)

The main trick, IMHO is to realize they are lexical.

I do prefer reading code left to right

thanks for the example @dpsutton

In other words, they don’t pass the result of one function to the next like you might imagine.

they dont?

They end up behaving that way, but you’ll see, with some corner cases, that they are best thought of as macros that rearrange your code.

(I misunderstood them for quite a while.)

try evaluating (-> [a 2, b 3] (let (+ a b)))

Inline anonymous function declarations bite me occasionally

that's my favorite example (the ->> version is almost like where in ml / haskell)

The canonical problematic example is if you have an anonymous fn in the chain

@sundarj i dont even understand that line

i thought , is whitespace

=> (->> (+ lexical demo) (let [lexical 11 demo 31]))
42

@gold88 yes, , is whitespace, that has nothing to do with what's happening there

, is whitespace, i used it for readability

the thing shown in these examples is that it isn't passing a result to the next form - it's injecting the literal form into the other literal form before compiling

(-> [a 2, b 3] (let (+ a b))) expands to (let [a 2, b 3] (+ a b))

thanks for clarifying

i guess threading is something when I have a solid grasp of 'things'

if you use threading in the normal way it's fine for a beginner - this is a sample that helps you when an unexpected bug happens

eg. (-> 2 (fn [x] (* x x))) - that expands to (fn 2 [x] (* x x))

okay, i'll be cautious 🔎

by the way, clojuredocs is a blessing

i just copy paste commands that i dont know yet in there and i dont need to do (doc fname)

(defn ->host
  [{:keys [domain repo-name branch-name]}]
  (str (sanitize-name repo-name) "-" (sanitize-name branch-name) "." domain))

(defn subdomain->host
  [domain subdomain]
  (str subdomain "." domain))

is this naming style or does it actually mean something?

it's a naming convention. ->host means 'make a host', and subdomain->host means 'convert a subdomain into a host'

if someone has (defrecord foo ...) clojure will create ->foo and map->foo automatically. we also use names like that directly

-, >, +, *, |, and many others are not "special" in clojure, they are just part of a name

(`.` and / on the other hand do have some "magic" to them in the reader so aren't as free)

https://github.com/bbatsov/clojure-style-guide#arrow-instead-of-to covers the second one

map->foo = convert a map into foo?

into a foo, yeah

(def ^:dynamic *buffer-size* 1024) okay this one has two question: ^: ? and asterisk wrapped strings?

*ear-muffs* is a convention to indicate dynamic variables -- names that can be bound to new values at runtime using binding

And ^:dynamic is metadata for the var and is shorthand for ^{:dynamic true} which marks the var as dynamically rebindable

(binding [*buffer-size* 2048]
   ... execute this code with *buffer-size* bound to 2048 ...
  ... )
;; and now *buffer-size* is back to 1024

You'll also see

(def ^:private foo 42) ;; make foo private to this namespace
...
;; but it can still be accessed as #'the-ns/foo outside that namespace

@gold88 If you haven't already seen it, this is very helpful for the syntax stuff https://clojure.org/guides/weird_characters

thats helpful, thanks @seancorfield

but i would guess that dynamic variables are frowned upon right?

>This page explains the Clojure syntax for characters that are difficult to "google".

😄

they are more common in older code in my experience, but sometimes they are much nicer than the alternative of a shared mutable value

since binding changes the view of the variable inside a specific scope, but is invisible outside that scope

and some things like *out* for example are always going to be dynamic so it makes sense to alt least know how to use them well

i am grateful for the explainations 🙂 sometimes I feel like im treading on eggshells here