# 2f: Noun Ordering
## `+aor`
Alphabetical order.
Computes whether `.a` and `.b` are in alphabetical order, producing a `$flag`. Orders `$atom`s before cells, and `$atom`s 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')
```
```
> (aor 'b' 'a')
```
```
> (aor 'a' 'a')
%.y
```
```
> (aor 1 2)
%.y
```
```
> (aor 2 1)
%.n
> (aor ['a' ~] 'b')
%.n
```
```
> (aor 'b' ['a' ~])
%.y
```
```
> (aor ['a' ~] ['b' ~])
```
```
> (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 `$atom`s one byte at a time, while `+dor` compares whole `$atom`s 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 `$atom`s before cells, and `$atom`s 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 `$atom`s 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 `$atom`s, `+dor` is equivalent to [`+lte`](/hoon/stdlib/1a.md#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`](/hoon/stdlib/2e.md#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`](/hoon/stdlib/2e.md#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.
***
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.urbit.org/hoon/stdlib/2f.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.