Back
compare (clj)
(source)function
(compare x y)
Comparator. Returns a negative number, zero, or a positive number
when x is logically 'less than', 'equal to', or 'greater than'
y. Same as Java x.compareTo(y) except it also works for nil, and
compares numbers and collections in a type-independent manner. x
must implement Comparable
Examples
clojure
(deftest division
(is (= clojure.core// /))
(binding [*ns* *ns*]
(eval '(do (ns foo
(:require [clojure.core :as bar])
(:use [clojure.test]))
(is (= clojure.core// bar//))))))
(deftest Instants
(testing "Instants are read as java.util.Date by default"
(is (= java.util.Date (class #inst "2010-11-12T13:14:15.666"))))
(let [s "#inst \"2010-11-12T13:14:15.666-06:00\""]
(binding [*data-readers* {'inst read-instant-date}]
(testing "read-instant-date produces java.util.Date"
(is (= java.util.Date (class (read-string s)))))
(testing "java.util.Date instants round-trips"
(is (= (-> s read-string)
(-> s read-string pr-str read-string))))
(testing "java.util.Date instants round-trip throughout the year"
(doseq [month (range 1 13) day (range 1 29) hour (range 1 23)]
(let [s (format "#inst \"2010-%02d-%02dT%02d:14:15.666-06:00\"" month day hour)]
(is (= (-> s read-string)
(-> s read-string pr-str read-string))))))
(testing "java.util.Date handling DST in time zones"
(let [dtz (TimeZone/getDefault)]
(try
;; A timezone with DST in effect during 2010-11-12
(TimeZone/setDefault (TimeZone/getTimeZone "Australia/Sydney"))
(is (= (-> s read-string)
(-> s read-string pr-str read-string)))
(finally (TimeZone/setDefault dtz)))))
(testing "java.util.Date should always print in UTC"
(let [d (read-string s)
pstr (print-str d)
len (.length pstr)]
(is (= (subs pstr (- len 7)) "-00:00\"")))))
(binding [*data-readers* {'inst read-instant-calendar}]
(testing "read-instant-calendar produces java.util.Calendar"
(is (instance? java.util.Calendar (read-string s))))
(testing "java.util.Calendar round-trips"
(is (= (-> s read-string)
(-> s read-string pr-str read-string))))
(testing "java.util.Calendar remembers timezone in literal"
(is (= "#inst \"2010-11-12T13:14:15.666-06:00\""
(-> s read-string pr-str)))
(is (= (-> s read-string)
(-> s read-string pr-str read-string))))
(testing "java.util.Calendar preserves milliseconds"
(is (= 666 (-> s read-string
(.get java.util.Calendar/MILLISECOND)))))))
(let [s "#inst \"2010-11-12T13:14:15.123456789\""
s2 "#inst \"2010-11-12T13:14:15.123\""
s3 "#inst \"2010-11-12T13:14:15.123456789123\""]
(binding [*data-readers* {'inst read-instant-timestamp}]
(testing "read-instant-timestamp produces java.sql.Timestamp"
(is (= java.sql.Timestamp (class (read-string s)))))
(testing "java.sql.Timestamp preserves nanoseconds"
(is (= 123456789 (-> s read-string .getNanos)))
(is (= 123456789 (-> s read-string pr-str read-string .getNanos)))
;; truncate at nanos for s3
(is (= 123456789 (-> s3 read-string pr-str read-string .getNanos))))
(testing "java.sql.Timestamp should compare nanos"
(is (= (read-string s) (read-string s3)))
(is (not= (read-string s) (read-string s2)))))
(binding [*data-readers* {'inst read-instant-date}]
(testing "read-instant-date should truncate at milliseconds"
(is (= (read-string s) (read-string s2) (read-string s3))))))
(let [s "#inst \"2010-11-12T03:14:15.123+05:00\""
s2 "#inst \"2010-11-11T22:14:15.123Z\""]
(binding [*data-readers* {'inst read-instant-date}]
(testing "read-instant-date should convert to UTC"
(is (= (read-string s) (read-string s2)))))
(binding [*data-readers* {'inst read-instant-timestamp}]
(testing "read-instant-timestamp should convert to UTC"
(is (= (read-string s) (read-string s2)))))
(binding [*data-readers* {'inst read-instant-calendar}]
(testing "read-instant-calendar should preserve timezone"
(is (not= (read-string s) (read-string s2)))))))
typedclojure/typedclojure
(ns ^:no-doc typed.ann.clojure
"Type annotations for the base Clojure distribution."
#?(:cljs (:require-macros [typed.ann-macros.clojure :as macros]))
(:require [clojure.core :as cc]
[typed.clojure :as t]
#?(:clj [typed.ann-macros.clojure :as macros])
#?(:clj typed.ann.clojure.jvm) ;; jvm annotations
#?(:clj clojure.core.typed))
#?(:clj
(:import (clojure.lang PersistentHashSet PersistentList
APersistentMap #_IPersistentCollection
#_ITransientSet
IRef)
(java.util Comparator Collection))))
cc/reset! (t/All [x] [(t/Atom x) x :-> x])
cc/swap! (t/All [x b :..] [(t/Atom x) [x b :.. b :-> x] b :.. b :-> x])
#?@(:cljs [] :default [
cc/reset-vals! (t/All [x] [(t/Atom x) x :-> '[x x]])
cc/swap-vals! (t/All [x b :..] [(t/Atom x) [x b :.. b :-> x] b :.. b :-> '[x x]])
])
cc/vreset! (t/All [x] [(t/Volatile x) x :-> x])
cc/volatile? (t/Pred t/AnyVolatile)
cc/compare-and-set! (t/All [x] [(t/Atom x) t/Any x :-> t/Bool])
;; already defined in clj base-env
#?@(:cljs [
cc/compare (t/All [x]
[(t/alt (t/cat (t/Option t/Num) (t/Option t/Num))
(t/cat (t/Option (t/Comparable x)) (t/Option (t/Comparable x))))
:-> t/Num])
])
dco-dev/interval-tree
(ns com.dean.interval-tree.tree.ordered-map
(:require [clojure.core.reducers :as r :refer [coll-fold]]
[com.dean.interval-tree.tree.node :as node]
[com.dean.interval-tree.tree.protocol :as proto]
[com.dean.interval-tree.tree.root]
[com.dean.interval-tree.tree.tree :as tree]
[com.dean.interval-tree.tree.order :as order])
(:import [clojure.lang RT]
[com.dean.interval_tree.tree.root INodeCollection
IBalancedCollection
IOrderedCollection]))
(defmacro with-ordered-map [x & body]
`(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))]
~@body))
java.lang.Comparable
(compareTo [this o]
(with-ordered-map this
(cond
(identical? this o) 0
(.isCompatible this o) (tree/node-map-compare root (.getRoot o))
(.isSimilar this o) (.compareTo (into (empty o) this) o)
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
clojure.lang.IPersistentCollection
(equiv [this o]
(with-ordered-map this
(cond
(identical? this o) 0
(.isCompatible this o) (and (= (.count this) (.count o))
(zero? (tree/node-map-compare root (.getRoot o))))
(map? o) (.equiv (into (empty o) (tree/node-vec root :accessor :kv)) o)
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
dco-dev/interval-tree
(ns com.dean.interval-tree.tree.interval-map
(:require [clojure.core.reducers :as r :refer [coll-fold]]
[com.dean.interval-tree.tree.interval :as interval]
[com.dean.interval-tree.tree.node :as node]
[com.dean.interval-tree.tree.root]
[com.dean.interval-tree.tree.order :as order]
[com.dean.interval-tree.tree.tree :as tree])
(:import [clojure.lang RT]
[com.dean.interval_tree.tree.root INodeCollection
IBalancedCollection
IOrderedCollection
IIntervalCollection]))
(defmacro with-interval-map [x & body]
`(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))
tree/*t-join* (.getAllocator ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.INodeCollection}))]
~@body))
java.lang.Comparable
(compareTo [this o]
(with-interval-map this
(cond
(identical? this o) 0
(.isCompatible this o) (tree/node-map-compare root (.getRoot o))
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
clojure.lang.IPersistentCollection
(equiv [this o]
(with-interval-map this
(cond
(identical? this o) 0
(.isCompatible this o) (and (= (.count this) (.count o))
(zero? (tree/node-map-compare root (.getRoot o))))
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
dco-dev/interval-tree
(ns com.dean.interval-tree.tree.interval-set
(:require [clojure.core.reducers :as r :refer [coll-fold]]
[clojure.set]
[com.dean.interval-tree.tree.interval :as interval]
[com.dean.interval-tree.tree.node :as node]
[com.dean.interval-tree.tree.order :as order]
[com.dean.interval-tree.tree.protocol :as proto]
[com.dean.interval-tree.tree.root]
[com.dean.interval-tree.tree.tree :as tree])
(:import [clojure.lang RT]
[com.dean.interval_tree.tree.protocol PExtensibleSet]
[com.dean.interval_tree.tree.root INodeCollection
IBalancedCollection
IOrderedCollection
IIntervalCollection]))
(defmacro with-interval-set [x & body]
`(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))
tree/*t-join* (.getAllocator ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.INodeCollection}))]
~@body))
java.lang.Comparable
(compareTo [this o]
(with-interval-set this
(cond
(identical? this o) 0
(.isCompatible this o) (tree/node-set-compare root (.getRoot o))
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
clojure.lang.IPersistentSet
(equiv [this o]
(with-interval-set this
(cond
(identical? this o) true
(.isCompatible this o) (and (= (.count this) (.count o))
(zero? (tree/node-set-compare root (.getRoot o))))
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
(count [_]
(tree/node-size root))
(empty [_]
(IntervalSet. (node/leaf) cmp alloc stitch {}))
(contains [this k]
(with-interval-set this
(some? (seq (tree/node-find-intervals this (interval/ordered-pair k))))))
(disjoin [this k]
(with-interval-set this
(IntervalSet. (tree/node-remove root (interval/ordered-pair k)) cmp alloc stitch _meta)))
(cons [this k]
(with-interval-set this
(IntervalSet. (tree/node-add root (interval/ordered-pair k)) cmp alloc stitch _meta)))
dco-dev/interval-tree
(ns com.dean.interval-tree.tree.ordered-set
(:require [clojure.core.reducers :as r :refer [coll-fold]]
[clojure.set]
[com.dean.interval-tree.tree.node :as node]
[com.dean.interval-tree.tree.order :as order]
[com.dean.interval-tree.tree.protocol :as proto]
[com.dean.interval-tree.tree.root]
[com.dean.interval-tree.tree.tree :as tree])
(:import [clojure.lang RT]
[com.dean.interval_tree.tree.protocol PExtensibleSet]
[com.dean.interval_tree.tree.root INodeCollection
IBalancedCollection
IOrderedCollection]))
(defmacro with-ordered-set [x & body]
`(binding [order/*compare* (.getCmp ~(with-meta x {:tag 'com.dean.interval_tree.tree.root.IOrderedCollection}))]
~@body))
java.lang.Comparable
(compareTo [this o]
(with-ordered-set this
(cond
(identical? this o) 0
(.isCompatible this o) (tree/node-set-compare root (.getRoot ^OrderedSet o))
(.isSimilar this o) (.compareTo ^Comparable (into (empty o) this) o)
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
clojure.lang.IPersistentSet
(equiv [this o]
(with-ordered-set this
(cond
(identical? this o) true
(not= (tree/node-size root) (.count ^clojure.lang.Counted o)) false
(.isCompatible this o) (zero? (tree/node-set-compare root (.getRoot ^OrderedSet o)))
(.isSimilar this o) (.equiv ^clojure.lang.IPersistentSet (into (empty o) this) o)
true (throw (ex-info "unsupported comparison: " {:this this :o o})))))
(count [_]
(tree/node-size root))
(empty [_]
(new OrderedSet (node/leaf) cmp alloc stitch {}))
(contains [this k]
(with-ordered-set this
(if (tree/node-find root k) true false)))
(disjoin [this k]
(with-ordered-set this
(new OrderedSet (tree/node-remove root k) cmp alloc stitch _meta)))
(cons [this k]
(with-ordered-set this
(new OrderedSet (tree/node-add root k) cmp alloc stitch _meta)))