(.require
 [library
  [lux (.except nat)
   [abstract
    [equivalence (.only Equivalence)]
    [order (.only Order)]]
   [control
    ["[0]" try (.only Try)]
    ["[0]" exception (.only exception)]]
   [data
    [text
     ["%" \\format (.only format)]]
    [binary
     ["[0]" \\format (.only Format)]]]
   [math
    [number
     ["n" nat]
     ["[0]" i64]]]
   [meta
    [macro
     ["[0]" template]]
    [type
     [primitive (.except)]]]]])

(primitive .public (Unsigned brand)
  Nat

  (def .public value
    (-> (Unsigned Any) Nat)
    (|>> representation))

  (def .public equivalence
    (All (_ brand) (Equivalence (Unsigned brand)))
    (implementation
     (def (= reference sample)
       (n.= (representation reference)
            (representation sample)))))

  (def .public order
    (All (_ brand) (Order (Unsigned brand)))
    (implementation
     (def equivalence ..equivalence)
     (def (< reference sample)
       (n.< (representation reference)
            (representation sample)))))

  (exception .public (value_exceeds_the_maximum [type Symbol
                                                 value Nat
                                                 maximum (Unsigned Any)])
    (exception.report
     "Type" (%.symbol type)
     "Value" (%.nat value)
     "Maximum" (%.nat (representation maximum))))

  (exception .public [brand] (subtraction_cannot_yield_negative_value
                              [type Symbol
                               parameter (Unsigned brand)
                               subject (Unsigned brand)])
    (exception.report
     "Type" (%.symbol type)
     "Parameter" (%.nat (representation parameter))
     "Subject" (%.nat (representation subject))))

  (with_template [<bytes> <name> <size> <constructor> <maximum> <+> <-> <max>]
    [(with_expansions [<raw> (template.symbol [<name> "'"])]
       (primitive .public <raw> Any)
       (type .public <name> (Unsigned <raw>)))

     (def .public <size> <bytes>)
     
     (def .public <maximum>
       <name>
       (|> <bytes> (n.* i64.bits_per_byte) i64.mask abstraction))
     
     (def .public (<constructor> value)
       (-> Nat (Try <name>))
       (if (n.> (representation <maximum>) value)
         (exception.except ..value_exceeds_the_maximum [(symbol <name>) value <maximum>])
         {try.#Success (abstraction value)}))

     (def .public (<+> parameter subject)
       (-> <name> <name> (Try <name>))
       (<constructor>
        (n.+ (representation parameter)
             (representation subject))))

     (def .public (<-> parameter subject)
       (-> <name> <name> (Try <name>))
       (let [parameter' (representation parameter)
             subject' (representation subject)]
         (if (n.> subject' parameter')
           (exception.except ..subtraction_cannot_yield_negative_value [(symbol <name>) parameter subject])
           {try.#Success (abstraction (n.- parameter' subject'))})))

     (def .public (<max> left right)
       (-> <name> <name> <name>)
       (abstraction (n.max (representation left)
                           (representation right))))]

    [1 U1 bytes/1 u1 maximum/1 +/1 -/1 max/1]
    [2 U2 bytes/2 u2 maximum/2 +/2 -/2 max/2]
    [4 U4 bytes/4 u4 maximum/4 +/4 -/4 max/4]
    )

  (with_template [<name> <from> <to>]
    [(def .public <name>
       (-> <from> <to>)
       (|>> transmutation))]

    [lifted/2 U1 U2]
    [lifted/4 U2 U4]
    )

  (with_template [<format_name> <type> <format>]
    [(def .public <format_name>
       (Format <type>)
       (|>> representation <format>))]

    [format/1 U1 \\format.bits_8]
    [format/2 U2 \\format.bits_16]
    [format/4 U4 \\format.bits_32]
    )
  )