2f: Noun Ordering

    ++aor

    Alphabetical order

    Computes whether a and b are in alphabetical order, producing a flag.

    Accepts

    a is a noun.

    b is a noun.

    Produces

    A flag.

    Source

        ++  aor
          ~/  %aor
          |=  [a=* b=*]
          ^-  ?
          ?:  =(a b)  &
          ?.  ?=(@ a)
            ?:  ?=(@ b)  |
            ?:  =(-.a -.b)
              $(a +.a, b +.b)
            $(a -.a, b -.b)
          ?.  ?=(@ b)  &
          |-
          =+  [c=(end 3 1 a) d=(end 3 1 b)]
          ?:  =(c d)
            $(a (rsh 3 1 a), b (rsh 3 1 b))
          (lth c d)
    

    Examples

        > (aor 'a' 'b')
        %.y
    
        > (aor 'b' 'a')
        %.n
    
        > (aor 'a' 'a')
        %.y
    
        > (aor "foo" "bar")
        %.n
    
        > (aor "bar" "foo")
        %.y
    
        > (aor "abcdefz" "abcdefa")
        %.n
    
        > (aor "abcdefa" "abcdefz")
        %.y
    
        > (aor 10.000 17.000)
        %.y
    
        > (aor 10 9)
        %.n
    

    ++dor

    Numeric order

    Computes whether a and b are in ascending numeric order, producing a flag.

    Accepts

    a is a noun.

    b is a noun.

    Produces

    A flag.

    Source

        ++  dor
          ~/  %dor
          |=  [a=* b=*]
          ^-  ?
          ?:  =(a b)  &
          ?.  ?=(@ a)
            ?:  ?=(@ b)  |
            ?:  =(-.a -.b)
              $(a +.a, b +.b)
            $(a -.a, b -.b)
          ?.  ?=(@ b)  &
          (lth a b)
    

    Examples

        > (dor 1 2)
        %.y
    
        > (dor 2 1)
        %.n
    
        > (dor ~[1 2 3] ~[1 2 4])
        %.y
    
        > (dor ~[1 2 4] ~[1 2 3])
        %.n
    
        > (dor `(list @)`~[99 100 10.000] ~[99 101 10.000])
        %.y
    
        > (dor ~[99 101 10.999] `(list @)`~[99 100 10.000])
        %.n
    

    Discussion

    If a and b are both atoms, dor is equivalent to lte. If they're cells, dor recurses on the heads, and then if the heads are the same it checks the tails.

    If one sample is a cell and the other is an atom, the cell sample is treated as "greater."


    ++gor

    Hash order

    Computes whether of (mug a) and (mug b) are in ascending numeric order, producing a flag. If the mug hashes are equal, a and b are compared by dor instead.

    mug is the the 31-bit nonzero FNV-1a hash algorithm.

    Accepts

    a is a noun.

    b is a noun.

    Produces

    A flag.

    Source

        ++  gor
          ~/  %gor
          |=  [a=* b=*]
          ^-  ?
          =+  [c=(mug a) d=(mug b)]
          ?:  =(c d)
            (dor a b)
          (lth c d)
    

    Examples

        > (gor 'd' 'c')
        %.y
    
        > 'd'
        'd'
    
        > 'c'
        'c'
    
        > `@ud`'d'
        100
    
        > `@ud`'c'
        99
    
        > (mug 'd')
        1.628.185.714
    
        > (mug 'c')
        1.712.073.811
    
        > (gor 'd' 'c')
        %.y
    
        > (gor 'c' 'd')
        %.n
    
        > (gor "foo" "bar")
        %.n
    
        > (gor (some 10) `(list @)`[1 2 3 ~])
        %.n
    

    Discussion

    maps use gor on the key for horizontal ordering and vor for vertical order. maps only look at the keys (the head of the key-value pair elements) for ordering.


    ++hor

    Horizontal hash order

    If a and b are atoms, they are computed as samples of gor, producing a flag.

    If a and b are cells, hor checks to see if their heads are equal. If their heads are equal, gor is computed on their tails, producing a flag. If their heads are not equal, gor is computed on their heads, producing a flag.

    If a is an atom and b is not, then %.y is produced. If b is an atom and a is not, %.n is produced.

    Accepts

    a is a noun.

    b is a noun.

    Produces

    A flag.

    Source

        ++  hor
          ~/  %hor
          |=  [a=* b=*]
          ^-  ?
          ?:  ?=(@ a)
            ?.  ?=(@ b)  &
            (gor a b)
          ?:  ?=(@ b)  |
          ?:  =(-.a -.b)
            (gor +.a +.b)
          (gor -.a -.b)
    

    Examples

        > (hor . 1)
        %.n
    
        > (hor 1 2)
        %.y
    
        > (hor "abc" "cba")
        %.y
    
        > (hor 'c' 'd')
        %.n
    
        > (hor 100 [1 1])
        %.y
    
        > (hor [1 1] 100)
        %.n
    
        > (hor 500.000.000 "foo")
        %.y
    
        > (hor "foo" 500.000.000)
        %.n
    
        > (hor 0 "foo")
        %.y
    
        > (gor `(list @)`[0 ~] 1)
        %.n
    
        > (hor `(list @)`[50 500 5.000 ~] 1)
        %.n
    

    Discussion

    Sets (+set, +in) use hor for their horizontal order and vor for their vertical order. See apt:in to see how a set verifies its correctness. vor is used to verify.


    ++lor

    Leg order

    Computes whether the corresponding legs of a and b are in ascending numeric order, producing a flag.

    Accepts

    a is a noun.

    b is a noun.

    Accepts

    A flag.

    Source

        ++  lor
          ~/  %lor
          |=  [a=* b=*]
          ^-  ?
          ?:  =(a b)  &
          ?@  a
            ?^  b  &
            (lth a b)
          ?:  =(-.a -.b)
            $(a +.a, b +.b)
          $(a -.a, b -.b)
    

    Examples

        > (lor 1 2)
        %.y
    
        > (lor 2 1)
        %.n
    
        > (lor 9 [1 2])
        %.y
    
        > (lor `(list @)`[1 2 3 ~] `(list @)`[1 2 3 4 ~])
        %.y
    
        > (lor `(list @)`[1 2 3 ~] `(list @)`[1 2 2 ~])
        %.n
    
        > (lor `(list @)`[1 2 3 ~] `(list @)`[2 2 ~])
        %.y
    
        > (lor [2 2 5] [1 5 9 8])
        %.n
    
        > (lor [1 5 8] [1 5 9 8])
        %.y
    
        > (lor [1 2 3] [1 2])
        !! exit
    

    Discussion

    lor is no longer used internally.


    ++vor

    Vertical order

    Computes whether the double-hashes (mug (mug a)) and (mug (mug b)) are in ascending numeric order, producing a flag. If the double-mug hashes are equal, a and b are compared by dor instead.

    mug is the the 31-bit nonzero FNV-1a hash algorithm.

    Accepts

    a is a noun

    b is a noun

    Produces

    A flag.

    Source

        ++  vor
          ~/  %vor
          |=  [a=* b=*]
          ^-  ?
          =+  [c=(mug (mug a)) d=(mug (mug b))]
          ?:  =(c d)
            (dor a b)
          (lth c d)
    

    Examples

        > (vor 'f' 'g')
        %.y
    
        > [(mug 'f') (mug 'g')]
        [1.661.740.952 1.644.963.335]
    
        > [(mug (mug 'f')) (mug (mug 'g'))]
        [261.421.509 1.861.258.547]
    
        > (vor 'a' 'z')
        %.n
    
        > (vor 43.326 41.106)
        %.n
    

    Discussion

    Maps, sets, and queues all use vor to check for vertical ordering. Maps and sets also use gor and hor for horizontal order, respectively, but queues use vertical ordering alone.

    Since hashing removes correlation, double-mugging with vor removes correlation with single-mugged hor. Vertical order becomes uncorrelated with horizontal order.