Immutable maps

let rows0 : Map<string, string> = Map.empty
let rows1 = rows0 |> Map.add "JOB0a" "payload-a"
let rows2 = rows1 |> Map.add "JOB0b" "payload-b"

Map.tryFind "JOB0a" rows2       // val it : string option = Some "payload-a"
Map.tryFind "JOB0z" rows2       // val it : string option = None
Map.containsKey "JOB0b" rows2   // val it : bool = true
Map.count rows2                // val it : int = 2

Map.empty

the empty map; the seed every map grows from. Its type is inferred from the first add.

Map.add k v

returns a new map with k set to v (overwriting any prior value). O(log n).

Map.tryFind k

returns Some v or None — a miss is a value, not an exception.

Map.containsKey k

a boolean presence test. Map.count gives the size.

A new map every write — and the old one stays

let before = Map.empty |> Map.add "k1" 1
let after  = before |> Map.add "k2" 2

Map.count before    // val it : int = 1   (before is untouched)
Map.count after     // val it : int = 2
// after shares before's nodes; only the root-to-change path is rebuilt — O(log n)

A write is a fork, not a mutation. The new map is the old one plus a rebuilt path; the rest is shared. That is why holding a snapshot, or retrying a transition, is cheap and safe.

let after       = Map.empty |> Map.add "k1" 1 |> Map.add "k2" 2
let afterRemove = after |> Map.remove "k1"

Map.containsKey "k1" afterRemove   // val it : bool = false
Map.containsKey "k1" after         // val it : bool = true   (after intact)

# Elixir — also immutable; put returns a new map
rows = Map.put(rows, "JOB0a", payload)
Map.get(rows, "JOB0a")   # the payload (or nil)

// F# — immutable too; add returns a new map, tryFind is total
let rows = rows |> Map.add "JOB0a" payload
Map.tryFind "JOB0a" rows   // val it : string option = Some "..."

EchoMQ in F#

Status — echo_fs is an in-memory model. The EchoMQ protocol — the Lua transitions executing on a Valkey wire — is not implemented (there is no Lua and no Valkey client in the code); that is the coming-soon transport (EchoMQ.Connector). This block shows how the model uses the structure, not a running bus.

if st.Rows.ContainsKey id then
    st, Admission.Duplicate
else
    let row = Job.create id payload
    { st with
        Rows = st.Rows.Add(id, row)
        Pending = st.Pending.Add id },
    Admission.Enqueued

let rows1 = (Map.empty: Map<string,string>).Add("JOB0a", "payload-a")
let rows2 = rows1.Add("JOB0b", "payload-b")

rows1.ContainsKey "JOB0b"   // val it : bool = false   (rows1 is the prior snapshot)
rows2.ContainsKey "JOB0b"   // val it : bool = true
// each admission forks the rows map; the old one is still valid to query or retry

Where this leads

References