function
boot.janet on line 863 , column 1
(compare x y )
Polymorphic compare. Returns -1 , 0 , 1 for x y , x y , x y
respectively. Differs from the primitive comparators in that it
first checks to see whether either x or y implement a `compare`
method which can compare x and y. If so , it uses that method. If
not , it delegates to the primitive comparators.
(def error-levels {:red 3 :orange 2 :yellow 1 })
# Create a new prototype object called ErrorProto with one method, :compare
(def ErrorProto
@{:level nil
# Returns -1, 0, 1 for x < y, x = y, x > y respectively.
:compare (fn [self other ]
(let [lx (error-levels (self :level ))
ly (error-levels (other :level ))]
(cond
( lx ly ) -1
( lx ly ) 1
:else 0 )))})
# Factory function to create new Error objects
(defn make-error
[level ]
(table/setproto @{:level level } ErrorProto ))
(def err-red (make-error :red ))
(def err-yell (make-error :yellow ))
(def err-orange (make-error :orange ))
# calls of the polymorphic compare function
(compare err-red err-orange ) # 1
(compare err-orange err-red ) # -1
(compare err-red err-red ) # 0
# These following functions call internally
# the polymorphic compare function, but return a boolean value
(compare> err-red err-orange ) # true
(compare> err-yell err-orange ) # false
(compare= err-yell err-yell ) # true
#-------------------------------------------------------------------------------
# sort the objects with compare> and compare<
(def errors-unsorted @[err-red err-yell err-orange ])
# ascending order
(sort errors-unsorted compare< )
# => @[@{:level :yellow} @{:level :orange} @{:level :red}]
# descending order
(sort errors-unsorted compare> )
# => @[@{:level :red} @{:level :orange} @{:level :yellow}]
# without compare
(sort-by |(error-levels ($ :level )) errors-unsorted )
# => @[@{:level :yellow} @{:level :orange} @{:level :red}]
# Note!!!, the following does not work as expected.
# sort alone does not automatically use the compare function (the comparator)
(sort errors-unsorted ) # result is not sorted!