Collections

(count [10 20 30]) ; => 3
(first [10 20 30]) ; => 10
(rest [10 20 30])  ; => [20 30]
(get [10 20 30] 1) ; => 20

first gives the first item, rest gives everything after it. get with index 1 gives the second item, because indexes start at 0.

(conj [:a :b] :c)         ; => [:a :b :c]
(get [:a :b :c] 2)        ; => :c
(get [:a :b :c] 10 :none) ; => :none

A missing index is not an error: get returns nil, or your default if you give one.

(get {:name "Ada" :age 36} :age)             ; => 36
(get {:name "Ada" :age 36} :email)           ; => nil
(get {:name "Ada" :age 36} :email "unknown") ; => "unknown"
(count {:name "Ada" :age 36})                ; => 2

A missing key gives nil, not an error. PHP would warn about an undefined array key. count counts key-value pairs.

(assoc {:name "Ada"} :age 36)       ; => {:name "Ada", :age 36}
(assoc {:name "Ada"} :name "Grace") ; => {:name "Grace"}
(dissoc {:name "Ada" :age 36} :age) ; => {:name "Ada"}

When the key already exists, assoc replaces its value. The REPL prints commas between pairs to help you read; in your code they are optional.

(keys {:name "Ada" :age 36})             ; => [:name :age]
(vals {:name "Ada" :age 36})             ; => ["Ada" 36]
(contains? {:name "Ada" :age 36} :age)   ; => true
(contains? {:name "Ada" :age 36} :email) ; => false

keys and vals split a map into its two sides. contains? asks about the key, not the value. It is PHP's array_key_exists.

(conj [1 2] 3)   ; => [1 2 3]
(conj '(1 2) 3)  ; => (3 1 2)
(conj #{1 2} 2)  ; => #{1 2}
(conj #{1 2} 3)  ; => #{1 2 3}

Each collection adds where it is fastest. If you need order and want to add at the end, use a vector.

Learn more: Adding with conj

(dissoc (assoc {:name "Ada" :role :guest} :role :admin) :name)
; => {:role :admin}

assoc builds a new map, then dissoc builds another one from it. The first map is never changed. In the Sequences module you will learn ->, which lets you write this top to bottom.

(:age {:name "Ada" :age 36}) ; => 36
(:email {:name "Ada"})       ; => nil
(:role {:name "Ada"} :guest) ; => :guest
({:name "Ada"} :name)        ; => "Ada"
(#{:red :green} :blue)       ; => nil

Calling a set asks "is this value in you?": you get the value back, or nil.

Learn more: Data structures as functions

(get-in {:description "dark cave"
         :rooms [{:contents :monster}
                 nil
                 {:contents [:trinket :treasure]}]}
        [:rooms 2 :contents 1])
; => :treasure

Keys and indexes mix freely in one path. If any step is missing, get-in returns nil instead of failing.

(update {:visits 1} :visits inc)                         ; => {:visits 2}
(update {:visits 1} :visits dec)                         ; => {:visits 0}
(update [1 2 3] 0 inc)                                   ; => [2 2 3]
(get-in {:user {:city "Berlin"}} [:user :phone :number]) ; => nil

update reads the old value, calls the function on it, and puts the result back. You write "what to do", not "read, change, write".

(update-in {:items [{:name "apple" :qty 2}
                    {:name "pear" :qty 1}]}
           [:items 1 :qty]
           inc)
; => {:items [{:name "apple", :qty 2} {:name "pear", :qty 2}]}

The path goes into :items, then index 1, then :qty, and inc does the change. A common mistake is (assoc-in ... [:items 1 :qty] 2): it works here, but it hardcodes the new number instead of adding one.

(assoc-in {:user {:name "Ada" :settings {:theme "dark"}}}
          [:user :settings :theme]
          "light")
; => {:user {:name "Ada", :settings {:theme "light"}}}

assoc only works on the top level, so the broken form added a new :theme key next to :user and left the real one unchanged. For nested data, use assoc-in with the full path.