Clojure Programming/Examples/API Examples/Data Structures

Numbers

Computation

+

Returns the sum of nums. (+) returns 0.

(+ [] [x] [x y] [x y & more])

user=> (+ 1 2 3)
6
user=> (map + [1 2 3] [1 1 2])
(2 3 5)

-

If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result.

(- [x] [x y] [x y & more])

user=> (- 1 2 3)
-4
user=> (- -1)
1

*

Returns the product of nums. (*) returns 1.

(* [] [x] [x y] [x y & more])

user=> (* 1 2 3 4)
24

/

If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators.

(/ [x] [x y] [x y & more])

user=> (/ 1 4)
1/4

inc

Returns a number one greater than num.

(inc [x])

user=> (inc 41) 
42
user=> (inc 1/4)
5/4

dec

Returns a number one less than num.

(dec [x])

user=> (dec 99)
98
user=> (map dec [2 3 4])
(1 2 3)

min

Returns the least of the nums.

(min [x] [x y] [x y & more])

user=> (min 2 -1 3)
-1

max

Returns the greatest of the nums.

(max [x] [x y] [x y & more])

user=> (max 2 -1 3)
3

quot

Quotient of dividing numerator by denominator.

(quot [num div])

user=> (quot 4 2)
2
user=> (quot 5 2)
2
user=> (quot 6 2)
3

rem

Remainder of dividing numerator by denominator.

(rem [num div])

user=> (rem 5 2) 
1
user=> (rem 4 2)
0

rationalize

Returns the rational value of num.

(rationalize [num])

user=> (rationalize 1.33)      
133/100
user=> (rationalize 3.14159265)
62831853/20000000
user=> (rationalize (Math/sqrt 2))        
14142135623730951/10000000000000000

Comparison

==

Returns non-nil if nums all have the same value, otherwise false.

(== [x] [x y] [x y & more])

user=> (== (+ 1 2) 3)
true
user=> (== (+ 1 2) 3 2.999)
false
user=> (if (== 2 (+ 1 1)) (println "So easy!"))
So easy!
user=> (== true true) ;Be careful! Works only for nums. 
false
user=> (= true true) ;= works like Java x.equals(y)
true

<

Returns non-nil if nums are in monotonically increasing order, otherwise false.

(< [x] [x y] [x y & more])

user=> (< 1 (Math/sqrt 2) (+ 1 1))
true
user=> (< 5 5)                      
false
user=> (< 5)
true

>

Returns non-nil if nums are in monotonically decreasing order, otherwise false.

(> [x] [x y] [x y & more])

user=> (> 7 6 4 2)
true
user=> (> 2 4)    
false

<=

Returns non-nil if nums are in monotonically non-decreasing order, otherwise false.

(<= [x] [x y] [x y & more])

user=> (<= 0 1 1)
true

>=

Returns non-nil if nums are in monotonically non-increasing order, otherwise false.

(>= [x] [x y] [x y & more])

user=> (>= 3 2 1)
true

Predicates

zero?

Returns true if num is zero, else false.

(zero? [x])

user=> (zero? 0.01) 
false
user=> (zero? 0)   
true

pos?

Returns true if num is greater than zero, else false.

(pos? [x])

user=> (pos? 0)        
false
user=> (pos? (Math/PI))
true
user=> (filter pos? [-1 1 0 -1 5 2])
(1 5 2)

neg?

Returns true if num is less than zero, else false.

(neg? [x])

user=> (neg? -1)       
true
user=> (neg? 0) 
false

Strings

str

user=> (str "a" :b \c 3 4.5 6/7)
"a:bc34.56/7"
user=> (str [1 2])
"[1 2]"
user=> (str 1 2)
"12"
user=> (str #(1))
"user$eval__1289$fn__1291@4f53dd"

Characters

user=> \a
\a
user=> (seq "a")
\a
user=> (seq " ")
(\space)
user=> (char 13)
\return
user=> (str \a \b \c)
"abc"
user=> (char? \z)
true