stepF_set.mal

;; Testing sequential? function

(sequential? #{})
;=>false
(sequential? #{:a :b :c})
;=>false

;;
;; Testing sets
(set ["a"])
;=>#{"a"}

(set '("a"))
;=>#{"a"}

(set nil)
;=>#{}

#{"a"}
;=>#{"a"}

(assoc #{} "a")
;=>#{"a"}

(get (assoc (assoc #{"a"} "b") "c") "a")
;=>"a"

(def s1 (set '()))
;=>#{}

(set? #{})
;=>true
(set? s1)
;=>true
(set? 1)
;=>false
(set? "abc")
;=>false

(get nil "a")
;=>nil

(get s1 "a")
;=>nil

(contains? s1 "a")
;=>false

(def s2 (assoc s1 "a"))
;=>#{"a"}

(get s1 "a")
;=>nil

(contains? s1 "a")
;=>false

(get s2 "a")
;=>"a"

(contains? s2 "a")
;=>true

(seq s1)
;=>()
(= () (seq s1))
;=>true

(seq s2)
;=>("a")

(seq #{"1"})
;=>("1")

(count (seq (assoc s2 "b" "c")))
;=>3
(count (assoc s2 "b" "c"))
;=>3

;; Testing keywords as set keys
(get #{:abc} :abc)
;=>:abc
(contains? #{:abc} :abc)
;=>true
(contains? #{:abcd} :abc)
;=>false
(assoc #{} :bcd)
;=>#{:bcd}
(keyword? (nth (seq #{:abc :def}) 0))
;=>true

;; Testing whether assoc updates properly
(def s4 (assoc #{:a :b} :a :c))
(get s4 :a)
;=>:a
(get s4 :b)
;=>:b
(get s4 :c)
;=>:c
(get s4 :d)
;=>nil

;; Testing nil as set values
(contains? #{:abc} :abc)
;=>true
(assoc #{} :bcd)
;=>#{:bcd}

;;
;; Additional str and pr-str tests

(str "A" #{:abc} "Z")
;=>"A#{:abc}Z"

(str true "." false "." nil "." :keyw "." 'symb)
;=>"true.false.nil.:keyw.symb"

(pr-str "A" #{:abc} "Z")
;=>"\"A\" #{:abc} \"Z\""

(pr-str true "." false "." nil "." :keyw "." 'symb)
;=>"true \".\" false \".\" nil \".\" :keyw \".\" symb"

(def s (str #{:abc :def}))
(cond (= s "#{:abc :def}") true (= s "#{:def :abc}") true)
;=>true

(def p (pr-str #{:abc :def}))
(cond (= p "#{:abc :def}") true (= p "#{:def :abc}") true)
;=>true

;;
;; Testing dissoc
(def s3 (assoc s2 "b"))
(count (seq s3))
;=>2
(count s3)
;=>2
(dissoc s3 "a")
;=>#{"b"}
(dissoc s3 "a" "b")
;=>#{}
(dissoc s3 "a" "b" "c")
;=>#{}
(count (seq s3))
;=>2
(count s3)
;=>2

;; Testing empty?
(empty? #{})
;=>true
(empty? s3)
;=>false
(empty? #{"aa"})
;=>false

(dissoc #{:cde :fgh} :cde)
;=>#{:fgh}

;;
;; Testing equality of sets
(= #{} #{})
;=>true
(= #{} (set '()))
;=>true
(= #{} (set []))
;=>true
(= #{:a :b} (set [:b :a]))
;=>true
(= #{:a :b} (set [:a :b]))
;=>true
(= #{:a :c} (set [:a :b]))
;=>false
(= #{:b :c} (set [:a :b]))
;=>false
(= #{:b :a} (set [:a :b]))
;=>true
(= #{:b} (set [:a]))
;=>false
(= #{:a :b "c" "d"} (set [:a "c" :b "d"]))
;=>true
(= #{:a :b} (set [:a]))
;=>false
(= #{} [])
;=>false
(= [] #{})
;=>false
;=>false
(= #{} ())
;=>false
(= () #{})
;=>false
(= #{} {})
;=>false
(= {} #{})
;=>false

;; ;; Testing that set don't alter function ast
;; (def bar (fn [a] {:foo (get a :foo)}))
;; (bar {:foo (fn [x] x)})
;; (bar {:foo 3})
;; ;; shouldn't give an error

(meta (with-meta #{"abc"} #{"a"}))
;=>#{"a"}

(set? (with-meta #{"abc"} #{"a"}))
;=>true

(with-meta #{} #{"a"})
;=>#{}

(def l-wm (with-meta [4 5 6] #{"b"}))
;=>[4 5 6]
(meta l-wm)
;=>#{"b"}

(meta (with-meta l-wm #{"new_meta"}))
;=>#{"new_meta"}
(meta l-wm)
;=>#{"b"}

;;
;; Testing metadata on builtin functions
(meta +)
;=>nil
(def f-wm3 ^#{"def"} +)
(meta f-wm3)
;=>#{"def"}
(meta +)
;=>nil

(contains? (hash-set :a :b :c) :a)
;=>true
(contains? (hash-set :a :b :c) :b)
;=>true
(contains? (hash-set :a :b :c) :c)
;=>true
(contains? (hash-set :a :b :c) :z)
;=>false