+++
title = "2f: Noun Ordering"
weight = 9
template = "doc.html"
+++

## `++aor`

Alphabetical order

Computes whether `a` and `b` are in alphabetical order, producing a flag. Orders atoms before cells, and atoms in ascending LSB order.

#### 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 a) d=(end 3 b)]
  ?:  =(c d)
    $(a (rsh 3 a), b (rsh 3 b))
  (lth c d)
```

#### Examples

```
> (aor 'a' 'b')
%.y
> (aor 'b' 'a')
%.n
> (aor 'a' 'a')
%.y

> (aor 1 2)
%.y
> (aor 2 1)
%.n

> (aor ['a' ~] 'b')
%.n
> (aor 'b' ['a' ~])
%.y

> (aor ['a' ~] ['b' ~])
%.y
> (aor ['b' ~] ['a' ~])
%.n

> (aor "abca" "abcz")
%.y
> (aor "abcz" "abca")
%.n

> (aor 0b1011 0b1010)
%.n
> (aor 0b1010 0b1011)
%.y

> (aor [1 2] [2 1])
%.y
> (aor [2 1] [1 2])
%.n
```

Note the possible differences with `+dor` due to comparing one byte at a time:

```
> (aor 0b1001.0000.0000 0b1000.1000.0000)
%.y
> (dor 0b1001.0000.0000 0b1000.1000.0000)
%.n
```

#### Discussion

This is different than [+dor](#dor) in that it compares atoms one byte at a time, while `+dor` compares whole atoms at once. Note that because it simply compares bytes, it doesn't account for multi-byte UTF-8 characters and the like.

---

## `++dor`

Depth order

Computes whether `a` and `b` are in ascending tree depth order, producing a flag. Orders atoms before cells, and atoms in ascending numerical order.

#### 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
```

Note the possible difference with [+aor](#aor) due to comparing whole atoms rather than one byte at a time:

```
> (aor 0b1001.0000.0000 0b1000.1000.0000)
%.y
> (dor 0b1001.0000.0000 0b1000.1000.0000)
%.n
```

#### Discussion

If `a` and `b` are both atoms, `dor` is equivalent to [`lte`](/docs/hoon/reference/stdlib/1a#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`

Mug 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/reference/stdlib/2e#mug) 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 `mor` for
vertical order. `map`s only look at the keys (the head of the key-value pair
elements) for ordering.

---

## `++mor`

(more) mug 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/reference/stdlib/2e#mug) is the the 31-bit nonzero FNV-1a hash algorithm.

#### Accepts

`a` is a noun

`b` is a noun

#### Produces

A flag.

#### Source

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

#### Examples

```
    > (mor '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]

    > (mor 'a' 'z')
    %.n

    > (mor 43.326 41.106)
    %.n
```

#### Discussion

Maps, sets, and queues all use `mor` to check for vertical ordering. Maps and
sets also use `gor` for horizontal order, but queues use
vertical ordering alone.

Since hashing removes correlation, double-`mug`ging with `mor` removes
correlation with single-`mug`ged `gor`. Vertical order becomes uncorrelated
with horizontal order.

---