A dict iterates in insertion order

# Self-authored for the EML case corpus (no external origin). A small stock
# ledger, written to lean on the one guarantee that makes dicts pleasant to
# report from: since Python 3.7, a dict iterates in INSERTION order.
#
# That is a language promise, not an implementation accident, which is why a
# report built by walking a dict comes out in the order the entries were
# added rather than in some hash order that changes between runs. (Sets make
# the opposite choice - see examples/unique-tag-collector.)
#
# `for key in <dict>` did not work here until this case was written. The
# interpreter's for-loop accepted only list, tuple and str and raised
# TypeError on a dict, where Python iterates the keys. It went unnoticed
# because every corpus program that used a dict subscripted it rather than
# iterating it.

def restock_needed(level, floor):
    if level < floor:
        return floor - level
    return 0

{"bolts": 120, "washers": 8, "nuts": 64, "screws": 3} => stock
{"bolts": 50, "washers": 25, "nuts": 40, "screws": 30} => floors

("Line items: " + str(len(stock)))^0
""^0

"item      level  floor  action" => header
header^0
"--------- -----  -----  ------------------" => rule
rule^0

0 => short_count
0 => total_to_order
# Walking the dict gives the keys in the order they were written above.
for item in stock:
    stock[item] => level
    floors[item] => floor
    restock_needed(level, floor) => need
    if need > 0:
        "ORDER " + str(need) => action
        short_count + 1 => short_count
        total_to_order + need => total_to_order
    else:
        "ok" => action
    10 - len(item) => pad
    if pad < 1:
        1 => pad
    (item + " " * pad + str(level) + "      " + str(floor) + "     " + action)^0

""^0
("Below floor: " + str(short_count) + " of " + str(len(stock)))^0
("Units to order: " + str(total_to_order))^0
""^0

# Order-free questions do not care how the dict is walked.
[120, 8, 64, 3] => levels
("Total units held: " + str(sum(levels)))^0
("Largest line: " + str(max(levels)) + ", smallest: " + str(min(levels)))^0
""^0

# Insertion order is observable, and it is the order above - not alphabetical,
# and not sorted by level.
"Report order is insertion order:" => n1
n1^0
"" => joined
for item in stock:
    joined + item + " " => joined
("  " + joined)^0

def restock_needed(level, floor):
    if level < floor:
        return floor - level
    return 0

stock = {"bolts": 120, "washers": 8, "nuts": 64, "screws": 3}
floors = {"bolts": 50, "washers": 25, "nuts": 40, "screws": 30}
print("Line items: " + str(len(stock)))
print("")
header = "item      level  floor  action"
print(header)
rule = "--------- -----  -----  ------------------"
print(rule)
short_count = 0
total_to_order = 0
for item in stock:
    level = stock[item]
    floor = floors[item]
    need = restock_needed(level, floor)
    if need > 0:
        action = "ORDER " + str(need)
        short_count = short_count + 1
        total_to_order = total_to_order + need
    else:
        action = "ok"
    pad = 10 - len(item)
    if pad < 1:
        pad = 1
    print(item + " " * pad + str(level) + "      " + str(floor) + "     " + action)
print("")
print("Below floor: " + str(short_count) + " of " + str(len(stock)))
print("Units to order: " + str(total_to_order))
print("")
levels = [120, 8, 64, 3]
print("Total units held: " + str(sum(levels)))
print("Largest line: " + str(max(levels)) + ", smallest: " + str(min(levels)))
print("")
n1 = "Report order is insertion order:"
print(n1)
joined = ""
for item in stock:
    joined = joined + item + " "
print("  " + joined)

Line items: 4

item      level  floor  action
--------- -----  -----  ------------------
bolts     120      50     ok
washers   8      25     ORDER 17
nuts      64      40     ok
screws    3      30     ORDER 27

Below floor: 2 of 4
Units to order: 44

Total units held: 195
Largest line: 120, smallest: 3

Report order is insertion order:
  bolts washers nuts screws

Trace event types