Sets

let s0 = Set.empty<string>
let s1 = s0 |> Set.add "JOB0a" |> Set.add "JOB0b"
Set.contains "JOB0a" s1   // val it : bool = true
Set.contains "JOB0z" s1   // val it : bool = false
Set.count s1              // val it : int = 2

let s2 = s1 |> Set.add "JOB0a"   // already present
Set.count s2              // val it : int = 2   (no duplicate — the set is the dedup)

Set.empty

the empty set; the seed every set grows from.

Set.add x

returns a new set with x present; a no-op if it already is. O(log n).

Set.contains x

a boolean membership test in O(log n) — the typed MapSet.member?.

Set.count

the number of distinct elements; equal values are held once.

Test an id against the pending set

Membership is a yes/no, answered in a few comparisons down the tree. Adding what is already there is a no-op — the set keeps each id once, which is exactly the dedup a queue needs.

let pend = Set.empty |> Set.add "JOB0c" |> Set.add "JOB0a" |> Set.add "JOB0b"
Set.minElement pend       // val it : string = "JOB0a"
Set.toList pend           // val it : string list = ["JOB0a"; "JOB0b"; "JOB0c"]

let built   = set [ "/lists"; "/trees"; "/maps" ]
let planned = set [ "/maps"; "/hamt" ]
Set.intersect built planned    // val it : Set<string> = set ["/maps"]
Set.difference built planned   // val it : Set<string> = set ["/lists"; "/trees"]

# Elixir — MapSet membership, the link checker
MapSet.member?(built, route)   # true / false

// F# — the typed equivalent, O(log n), ordered
Set.contains route built       // val it : bool = true

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.

/// One queue's state.
type QueueState =
    { // … Rows: Map<string, Job>
      Pending: Set<string>
      // … Schedule, Active, Dead: Set<string>, Paused, Completed, Failed }

// claim the oldest pending job — the set minimum (mint order)
let id = Set.minElement st.Pending

/// Pending depth.
let pendingSize (st: QueueState) : int = Set.count st.Pending

let pending = Set.empty |> Set.add "JOB07" |> Set.add "JOB02" |> Set.add "JOB05"
Set.minElement pending       // val it : string = "JOB02"   (oldest = next to serve)
Set.count pending            // val it : int = 3
(pending |> Set.add "JOB02") |> Set.count   // val it : int = 3   (dedup)

Where this leads

References