(.using
 [library
  [lux (.except)
   [control
    ["[0]" function]]]]
 [//
  ["[0]" equivalence (.only Equivalence)]
  [functor
   ["[0]" contravariant]]])

(type: .public (Order a)
  (Interface
   (is (Equivalence a)
       equivalence)

   (is (-> a a Bit)
       <)))

(type: .public (Comparison a)
  (-> (Order a) a a Bit))

(def: .public (<= order parameter subject)
  Comparison
  (or (at order < parameter subject)
      (at order = parameter subject)))

(def: .public (> order parameter subject)
  Comparison
  (at order < subject parameter))

(def: .public (>= order parameter subject)
  Comparison
  (or (at order < subject parameter)
      (at order = subject parameter)))

(type: .public (Choice a)
  (-> (Order a) a a a))

(def: .public (min order x y)
  Choice
  (if (at order < y x) x y))

(def: .public (max order x y)
  Choice
  (if (at order < y x) y x))

(def: .public functor
  (contravariant.Functor Order)
  (implementation
   (def: (each f order)
     (implementation
      (def: equivalence
        (at equivalence.functor each f (at order equivalence)))
      
      (def: (< reference sample)
        (at order < (f reference) (f sample)))))))