Is there any difference between using partial and an anonymous function? Anonymous functions seem more readable and flexible to me at least.

hey all, i have a map that maps an id to a map that represents a player, i have a list of maps that represent a collection of stats, those maps contain the player’s id, which is the key to the first map

i’d like to make each map in the list a member of the map that id points to

in the first map

in a more imperative language i’d write a loop on the second one and update the first one

any pointers for the clojure take?

is it appropriate to use map just to loop over each value?

feels .. wrong

for also seems like it’s more for building a list

oo maybe doseq

(reduce (fn [player-info {:keys [id] :as stats}]
          (update player-info id update :stats (fnil conj []) (dissoc stats :id)))  ;; fnil conj because i don't know how many maps will be there so just keep a list of them
        {1 {:name "bob"}  ;; id -> map that represents a player
         2 {:name "sue"}}
        [{:id 1 :strength 8} -> sequence of maps with an id and other keys
         {:id 2 :strength 12}])
->
{1 {:name "bob", :stats [{:strength 8}]}
 2 {:name "sue", :stats [{:strength 12}]}}

reduce eh

what’s fnil?

😄

check out (doc fnil)

oh that’s cool

i hadn’t thought about making a whole new thing, i was thinking about “updating” the original map

but that’s probably the wrong idea

but it's how to wrap a function and give it a substitute value for nils.`(+ nil 1) #_vs ((fnil + 0) nil 1)`. I used (fnil conj []) so that when it update's the :stats key on a player map, if there's nothing there it will "substitute" an empty vector and use that. its a common idiom

these are immutable data structures so i have made new things but they efficiently share structure with the old things

and in that sense you can't update the original

right, right

and to be a bit more precise its because they are immutable and persistent data structures. (if you find yourself looking them up at some point)

ok thanks!

a bit to chew on here

@cschep The biggest mental shift, coming to Clojure -- depending on your background, is effectively the removal of the assignment operator, and with that the whole idea of a traditional "loop" (because in most languages those are inherently based on side-effects and, of course, the loop condition inherently assumes that you're assigning new values to something).

yeah, totally

;create league out of players
(def league (atom (into {} (map (juxt :id identity)) sb-players)))

(defn get-player
  [id]
  (get @league id))

(defn update-player
  [id key value]
  (swap! league
         (fn [current-state]
           (assoc-in current-state [id key] value)))
  nil)

;import stats
(doseq [stats hitting-stats]
  (update-player (stats :id) :stats stats))

it does feel like i essentially wrenched the language into a mutable class

ha ha ha

but it does “work”

For some context:

Clojure source 348 files 88298 total loc,
    3554 fns, 898 of which are private,
    571 vars, 29 macros, 91 atoms,
    849 specs, 33 function specs.
Clojure tests 378 files 23437 total loc,
    4 specs, 1 function specs.

yeah so the context of this is i’m using this atom instead of talking to a database

When you are using immutable data, you are always building new things from things you have (or things you are reading in from outside).

so there should just be the one

make json out of it and return it from web routes

and update it by getting posts

is that a sane way to do this? I’m so burned out of writing database migrations and the scale of this is 1

If you just have a single process, in memory, with no persistence, an atom makes a fine "database" 🙂

spitting it to a flat file

voila, persistence!

Yup. And the Agile crowd advocate for that quite strongly -- several of the original signatories to the Agile Manifesto are proud of how many projects they've built that don't use a database 🙂

ha ha, ok awesome

i suppose when i’m updating based on id’s and joining maps together based on keys it leaks out that i’m already in the database mindset

but it’s fun to poke around in your own little world

check out clojure.set/index to solve your above problem in a different way. you could keep them as separate collections and just "join" when you need to

wow

how do you learn about this stuff and then go write javascript

for 8 hours a day

not gonna work

🙂

Easy: I never write JS 🙂

ha, bingo

I started learning Clojure in 2010 and started using it in production in 2011 -- and I pretty much never write any other code now.

what were you writing before?

A long arc: C, assembler, COBOL, C++, Java, ColdFusion, Groovy, Scala... then Clojure.

(there have been other languages in there, but those are the main ones)

sounds like you landed in a good spot

🙂

i’m gonna keep firing noob questions but i hope no one feels too obligated to keep up

That's what we're all here for in this channel!

i’m trying to pass the function java.lang.String.contains to a function

.contains doesn’t seem to work

You have to wrap Java methods in a Clojure function -- Java methods are not "first class functions".

ahh ok i’m glad i’m not crazy

#(.contains % %1) like that?

But look at the clojure.string namespace. It has an index-of function that returns nil for no match else the index of the match.

ohhh that will probably work

https://clojure.github.io/clojure/clojure.string-api.html has a lot of nice wrappers for the underlying Java (or JavaScript) functionality that lets you avoid interop syntax and reflection.

There's also re-find (in clojure.core) for doing regex pattern matching.

oh yes, how to programmatically construct a regex?

finding a string that contains a string would be like #“.thestring.” or something?

can you string interpolate into them?

oh.. re-pattern

i think

normal regex's are fairly simple and for the most part universal, so it's useful just to learn the syntax

but if you want to have programmatic capabilities or have something really complicated, you can check out https://github.com/lambdaisland/regal

in this case i’m passing in a search string

from a user

so if the user types “mike” i want to list all the names that contain “mike”

ended up with

(defn search-players [search]
  (filter #(re-find (re-pattern (str "(?i)" search)) (% :name)) (vals @league)))

yeah that'd work, but definitely consider not closing over mutable state and keeping that function pure

it doesn't need to know about league

one reason being testing, as you'd need to setup your state as well to test the function, whereas what the function is actually doing is just search, which can be pure

I have a property file >as below which is located in the my deployed server, How can I read the property file and fetch the data from :prod in key

{
	:dev  "id=dev;host="
	:prod "id=prod;host="
}