+++
title = "2f: Noun Ordering"
weight = 9
template = "doc.html"
aliases = ["/docs/reference/library/2f"]
+++
### `++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

```hoon
    ++  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

```hoon
    ++  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`](@/docs/hoon/library/1a.md). 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`](@/docs/hoon/library/2e.md) is the the 31-bit nonzero FNV-1a hash algorithm.

#### Accepts

`a` is a noun.

`b` is a noun.

#### Produces

A flag.

#### Source

```hoon
    ++  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

`map`s use `gor` on the key for horizontal ordering and `vor` for
vertical order. `map`s 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

```hoon
    ++  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`](@/docs/hoon/library/2h.md) 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

```hoon
    ++  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`](@/docs/hoon/library/2e.md) is the the 31-bit nonzero FNV-1a hash algorithm.


#### Accepts

`a` is a noun

`b` is a noun

#### Produces

A flag.

#### Source

```hoon
    ++  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-`mug`ging with `vor` removes
correlation  with single-`mug`ged `hor`. Vertical order becomes uncorrelated
with horizontal order.


---