Design ride hailing like Uber or Ola: matching

Python 3.14 · main.py

class Driver:
    def __init__(self) -> None:
        self.state, self.version = "available", 7


# the driver state store
class Store:
    def __init__(self, conditional: bool) -> None:
        self.conditional = conditional
        self.drivers = {"D": Driver(), "E": Driver()}
        # rides promised, each with its driver
        self.promised: list[str] = []

    def read(self, name: str) -> int:
        return self.drivers[name].version

    def offer(self, matcher: str, ride: str, name: str, seen: int) -> bool:
        driver = self.drivers[name]
        fresh = driver.state == "available" and driver.version == seen
        ok = fresh or not self.conditional  # a plain write checks nothing
        if ok:
            driver.state, driver.version = "offered", driver.version + 1
            self.promised.append(f"{ride} -> {name}")
        # refused: the conditional update changed 0 rows
        outcome = f"{'written' if ok else 'refused'}, version {driver.version}"
        print(f"  {matcher} offers {ride} to {name}, read at version {seen}: {outcome}")
        return ok


for conditional in (False, True):
    print("conditional writes" if conditional else "plain writes")
    store = Store(conditional)
    seen_by_a, seen_by_b = store.read("D"), store.read("D")
    store.offer("A", "r1", "D", seen_by_a)
    if not store.offer("B", "r2", "D", seen_by_b):
        store.offer("B", "r2", "E", store.read("E"))  # the next candidate
    print(f"  riders promised: {', '.join(store.promised)}")

In Python: Driver objects are shared references, so offer() changes the stored driver in place, and fresh is the WHERE clause of the conditional update written as one boolean.

Recorded with CPython 3.14.8 on macOS 26 arm64. It runs in your browser with Pyodide 314.0.7 (CPython 3.14.2). To run it yourself: python3 main.py

JavaScript Node 24 · main.mjs

// the driver state store
class Store {
  constructor(conditional) {
    this.conditional = conditional;
    this.drivers = new Map(["D", "E"].map((name) => [name, { state: "available", version: 7 }]));
    this.promised = []; // rides promised, each with its driver
  }

  read(name) {
    return this.drivers.get(name).version;
  }

  offer(matcher, ride, name, seen) {
    const driver = this.drivers.get(name);
    const fresh = driver.state === "available" && driver.version === seen;
    const ok = fresh || !this.conditional; // a plain write checks nothing
    if (ok) {
      Object.assign(driver, { state: "offered", version: driver.version + 1 });
      this.promised.push(`${ride} -> ${name}`);
    }
    // refused: the conditional update changed 0 rows
    const outcome = `${ok ? "written" : "refused"}, version ${driver.version}`;
    console.log(`  ${matcher} offers ${ride} to ${name}, read at version ${seen}: ${outcome}`);
    return ok;
  }
}

for (const conditional of [false, true]) {
  console.log(conditional ? "conditional writes" : "plain writes");
  const store = new Store(conditional);
  const [seenByA, seenByB] = [store.read("D"), store.read("D")];
  store.offer("A", "r1", "D", seenByA);
  if (!store.offer("B", "r2", "D", seenByB)) {
    store.offer("B", "r2", "E", store.read("E")); // the next candidate
  }
  console.log(`  riders promised: ${store.promised.join(", ")}`);
}

In JavaScript: Object.assign updates the stored driver object in place, the change every later read of the Map then sees.

Recorded with Node.js 24.21.0 LTS (V8 13.6) on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0). To run it yourself: node main.mjs

Java 25 LTS · Main.java

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class Main {
  static final class Driver {
    String state = "available";
    int version = 7;
  }

  // the driver state store
  static final class Store {
    final boolean conditional;
    final Map<String, Driver> drivers = Map.of("D", new Driver(), "E", new Driver());
    final List<String> promised = new ArrayList<>(); // rides promised, each with its driver

    Store(boolean conditional) {
      this.conditional = conditional;
    }

    int read(String name) {
      return drivers.get(name).version;
    }

    boolean offer(String matcher, String ride, String name, int seen) {
      Driver driver = drivers.get(name);
      boolean fresh = driver.state.equals("available") && driver.version == seen;
      boolean ok = fresh || !conditional; // a plain write checks nothing
      if (ok) {
        driver.state = "offered";
        driver.version++;
        promised.add(ride + " -> " + name);
      }
      // refused: the conditional update changed 0 rows
      String outcome = (ok ? "written" : "refused") + ", version " + driver.version;
      String offer = "  " + matcher + " offers " + ride + " to " + name;
      System.out.println(offer + ", read at version " + seen + ": " + outcome);
      return ok;
    }
  }

  public static void main(String[] args) {
    for (boolean conditional : new boolean[] {false, true}) {
      System.out.println(conditional ? "conditional writes" : "plain writes");
      Store store = new Store(conditional);
      int seenByA = store.read("D");
      int seenByB = store.read("D");
      store.offer("A", "r1", "D", seenByA);
      if (!store.offer("B", "r2", "D", seenByB)) {
        store.offer("B", "r2", "E", store.read("E")); // the next candidate
      }
      System.out.println("  riders promised: " + String.join(", ", store.promised));
    }
  }
}

In Java: Map.of is immutable, but the Driver objects it holds are not, so offer() changes a driver in place.

Recorded with OpenJDK 25.0.4.1 LTS (Eclipse Temurin) on macOS 26 arm64. It runs in your browser with a TeaVM 0.16.0 build in QuickJS (quickjs-emscripten 0.32.0). To run it yourself: java Main.java

C++23 · main.cpp

#include <map>
#include <print>
#include <string>
#include <vector>

struct Driver {
  std::string state = "available";
  int version = 7;
};

// the driver state store
struct Store {
  bool conditional;
  std::map<std::string, Driver> drivers = {{"D", {}}, {"E", {}}};
  std::vector<std::string> promised; // rides promised, each with its driver

  explicit Store(bool conditional) : conditional(conditional) {}

  int read(const std::string &name) const { return drivers.at(name).version; }

  bool offer(const std::string &matcher, const std::string &ride,
             const std::string &name, int seen) {
    Driver &driver = drivers.at(name);
    const bool fresh = driver.state == "available" && driver.version == seen;
    const bool ok = fresh || !conditional; // a plain write checks nothing
    if (ok) {
      driver = {"offered", driver.version + 1};
      promised.push_back(ride + " -> " + name);
    }
    // refused: the conditional update changed 0 rows
    std::println("  {} offers {} to {}, read at version {}: {}, version {}",
                 matcher, ride, name, seen, ok ? "written" : "refused",
                 driver.version);
    return ok;
  }
};

int main() {
  for (const bool conditional : {false, true}) {
    std::println("{}", conditional ? "conditional writes" : "plain writes");
    Store store(conditional);
    const int seen_by_a = store.read("D"), seen_by_b = store.read("D");
    store.offer("A", "r1", "D", seen_by_a);
    if (!store.offer("B", "r2", "D", seen_by_b)) {
      store.offer("B", "r2", "E", store.read("E")); // the next candidate
    }
    std::string promised;
    for (const auto &ride : store.promised) {
      promised += (promised.empty() ? "" : ", ") + ride;
    }
    std::println("  riders promised: {}", promised);
  }
}

In C++: drivers.at(name) returns a reference, so assigning a new Driver to it replaces the stored one, and at throws for a name the map does not hold.

Recorded with Apple clang 21.0.0 (C++23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang++ -std=c++23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.cpp -o main && ./main

C# 14 · .NET 10 · app.cs

foreach (bool conditional in new[] { false, true })
{
    Console.WriteLine(conditional ? "conditional writes" : "plain writes");
    var store = new Store(conditional);
    int seenByA = store.Read("D"), seenByB = store.Read("D");
    store.Offer("A", "r1", "D", seenByA);
    if (!store.Offer("B", "r2", "D", seenByB))
    {
        store.Offer("B", "r2", "E", store.Read("E")); // the next candidate
    }
    Console.WriteLine($"  riders promised: {string.Join(", ", store.Promised)}");
}

class Driver
{
    public string State { get; set; } = "available";
    public int Version { get; set; } = 7;
}

// the driver state store
class Store(bool conditional)
{
    readonly Dictionary<string, Driver> drivers = new() { ["D"] = new(), ["E"] = new() };

    public List<string> Promised { get; } = []; // rides promised, each with its driver

    public int Read(string name) => drivers[name].Version;

    public bool Offer(string matcher, string ride, string name, int seen)
    {
        var driver = drivers[name];
        bool fresh = driver.State == "available" && driver.Version == seen;
        bool ok = fresh || !conditional; // a plain write checks nothing
        if (ok)
        {
            (driver.State, driver.Version) = ("offered", driver.Version + 1);
            Promised.Add($"{ride} -> {name}");
        }
        // refused: the conditional update changed 0 rows
        string outcome = $"{(ok ? "written" : "refused")}, version {driver.Version}";
        string offer = $"  {matcher} offers {ride} to {name}";
        Console.WriteLine($"{offer}, read at version {seen}: {outcome}");
        return ok;
    }
}

In C#: Driver is a class, so the dictionary holds references, and the tuple assignment to driver.State and driver.Version changes the stored driver.

Recorded with C# 14 on .NET 10.0.12 (SDK 10.0.401) on macOS 26 arm64. It runs in your browser with the .NET runtime for WebAssembly 10.0.12. To run it yourself: dotnet run app.cs

C23 · main.c

#include <stdio.h>
#include <string.h>

typedef struct {
  const char *name, *state;
  int version;
} Driver;

// the driver state store
typedef struct {
  bool conditional;
  Driver drivers[2];
  const char *promised[2][2]; // rides promised, each with its driver
  int promised_count;
} Store;

static Driver *find(Store *store, const char *name) {
  return &store->drivers[strcmp(name, "D") == 0 ? 0 : 1];
}

static int read_driver(Store *store, const char *name) {
  return find(store, name)->version;
}

static bool offer_ride(Store *store, const char *matcher, const char *ride,
                       const char *name, int seen) {
  Driver *driver = find(store, name);
  const bool fresh =
      strcmp(driver->state, "available") == 0 && driver->version == seen;
  const bool ok = fresh || !store->conditional; // a plain write checks nothing
  if (ok) {
    driver->state = "offered";
    driver->version++;
    store->promised[store->promised_count][0] = ride;
    store->promised[store->promised_count++][1] = name;
  }
  // refused: the conditional update changed 0 rows
  printf("  %s offers %s to %s, read at version %d: %s, version %d\n", matcher,
         ride, name, seen, ok ? "written" : "refused", driver->version);
  return ok;
}

int main(void) {
  for (int conditional = 0; conditional <= 1; conditional++) {
    puts(conditional ? "conditional writes" : "plain writes");
    Store store = {.conditional = conditional,
                   .drivers = {{"D", "available", 7}, {"E", "available", 7}}};
    const int seen_by_a = read_driver(&store, "D");
    const int seen_by_b = read_driver(&store, "D");
    offer_ride(&store, "A", "r1", "D", seen_by_a);
    if (!offer_ride(&store, "B", "r2", "D", seen_by_b)) {
      const int seen = read_driver(&store, "E"); // the next candidate
      offer_ride(&store, "B", "r2", "E", seen);
    }
    printf("  riders promised: ");
    for (int i = 0; i < store.promised_count; i++) {
      printf("%s%s -> %s", i > 0 ? ", " : "", store.promised[i][0],
             store.promised[i][1]);
    }
    printf("\n");
  }
  return 0;
}

In C: The store keeps its two drivers in a fixed array, find returns a pointer into it, and designated initializers set only the fields the run needs, the rest zero.

Recorded with Apple clang 21.0.0 (C23) and GCC 16.2.0 on macOS 26 arm64. It runs in your browser with Clang in WebAssembly (YoWASP) 22.0.0-git20542-10. To run it yourself: clang -std=c23 -O2 -Wall -Wextra -Werror -pedantic -fsanitize=address,undefined main.c -o main && ./main

PHP 8.5 · main.php

<?php

declare(strict_types=1);

// the driver state store
final class Store
{
    /** @var array<string, array{state: string, version: int}> */
    private array $drivers = [
        'D' => ['state' => 'available', 'version' => 7],
        'E' => ['state' => 'available', 'version' => 7],
    ];
    /** @var list<string> rides promised, each with its driver */
    public array $promised = [];

    public function __construct(private readonly bool $conditional) {}

    public function read(string $name): int
    {
        return $this->drivers[$name]['version'];
    }

    public function offer(string $matcher, string $ride, string $name, int $seen): bool
    {
        $driver = &$this->drivers[$name];
        $fresh = $driver['state'] === 'available' && $driver['version'] === $seen;
        $ok = $fresh || !$this->conditional; // a plain write checks nothing
        if ($ok) {
            $driver = ['state' => 'offered', 'version' => $driver['version'] + 1];
            $this->promised[] = "{$ride} -> {$name}";
        }
        // refused: the conditional update changed 0 rows
        $outcome = ($ok ? 'written' : 'refused') . ", version {$driver['version']}";
        echo "  {$matcher} offers {$ride} to {$name}, read at version {$seen}: {$outcome}\n";
        return $ok;
    }
}

foreach ([false, true] as $conditional) {
    echo ($conditional ? 'conditional writes' : 'plain writes') . "\n";
    $store = new Store($conditional);
    [$seenByA, $seenByB] = [$store->read('D'), $store->read('D')];
    $store->offer('A', 'r1', 'D', $seenByA);
    if (!$store->offer('B', 'r2', 'D', $seenByB)) {
        $store->offer('B', 'r2', 'E', $store->read('E')); // the next candidate
    }
    echo '  riders promised: ' . implode(', ', $store->promised) . "\n";
}

In PHP: PHP arrays are values, so offer() takes a reference, &$this->drivers[$name], to change the stored driver rather than a copy.

Recorded with PHP 8.5.11 (CLI) on macOS 26 arm64. It runs in your browser with php-wasm 0.2.0 (PHP 8.5.2). To run it yourself: php main.php

Rust 1.99 · main.rs

use std::collections::BTreeMap;

struct Driver {
    state: &'static str,
    version: u32,
}

/// The driver state store.
struct Store {
    conditional: bool,
    drivers: BTreeMap<&'static str, Driver>,
    promised: Vec<String>, // rides promised, each with its driver
}

impl Store {
    fn new(conditional: bool) -> Self {
        let available = || Driver {
            state: "available",
            version: 7,
        };
        let drivers = BTreeMap::from([("D", available()), ("E", available())]);
        Store {
            conditional,
            drivers,
            promised: Vec::new(),
        }
    }

    fn read(&self, name: &str) -> u32 {
        self.drivers[name].version
    }

    fn offer(&mut self, matcher: &str, ride: &str, name: &str, seen: u32) -> bool {
        let Some(driver) = self.drivers.get_mut(name) else {
            return false;
        };
        let fresh = driver.state == "available" && driver.version == seen;
        let ok = fresh || !self.conditional; // a plain write checks nothing
        if ok {
            (driver.state, driver.version) = ("offered", driver.version + 1);
            self.promised.push(format!("{ride} -> {name}"));
        }
        // refused: the conditional update changed 0 rows
        let outcome = if ok { "written" } else { "refused" };
        let version = driver.version;
        let offer = format!("  {matcher} offers {ride} to {name}");
        println!("{offer}, read at version {seen}: {outcome}, version {version}");
        ok
    }
}

fn main() {
    for conditional in [false, true] {
        let title = if conditional {
            "conditional writes"
        } else {
            "plain writes"
        };
        println!("{title}");
        let mut store = Store::new(conditional);
        let (seen_by_a, seen_by_b) = (store.read("D"), store.read("D"));
        store.offer("A", "r1", "D", seen_by_a);
        if !store.offer("B", "r2", "D", seen_by_b) {
            let seen = store.read("E"); // the next candidate
            store.offer("B", "r2", "E", seen);
        }
        println!("  riders promised: {}", store.promised.join(", "));
    }
}

In Rust: get_mut borrows the stored driver mutably, and since that borrows only the drivers field, self.promised can still change in the same block.

Recorded with rustc 1.99.0 (edition 2024) on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: rustc --edition 2024 -O main.rs && ./main

TypeScript 6.0 · main.ts

interface Driver {
  state: string;
  version: number;
}

// the driver state store
class Store {
  readonly conditional: boolean;
  drivers = new Map<string, Driver>(
    ["D", "E"].map((name) => [name, { state: "available", version: 7 }]),
  );
  promised: string[] = []; // rides promised, each with its driver

  constructor(conditional: boolean) {
    this.conditional = conditional;
  }

  driver(name: string): Driver {
    const driver = this.drivers.get(name);
    if (driver === undefined) throw new Error(`no driver ${name}`);
    return driver;
  }

  read(name: string): number {
    return this.driver(name).version;
  }

  offer(matcher: string, ride: string, name: string, seen: number): boolean {
    const driver = this.driver(name);
    const fresh = driver.state === "available" && driver.version === seen;
    const ok = fresh || !this.conditional; // a plain write checks nothing
    if (ok) {
      Object.assign(driver, { state: "offered", version: driver.version + 1 });
      this.promised.push(`${ride} -> ${name}`);
    }
    // refused: the conditional update changed 0 rows
    const outcome = `${ok ? "written" : "refused"}, version ${driver.version}`;
    console.log(`  ${matcher} offers ${ride} to ${name}, read at version ${seen}: ${outcome}`);
    return ok;
  }
}

for (const conditional of [false, true]) {
  console.log(conditional ? "conditional writes" : "plain writes");
  const store = new Store(conditional);
  const [seenByA, seenByB] = [store.read("D"), store.read("D")];
  store.offer("A", "r1", "D", seenByA);
  if (!store.offer("B", "r2", "D", seenByB)) {
    store.offer("B", "r2", "E", store.read("E")); // the next candidate
  }
  console.log(`  riders promised: ${store.promised.join(", ")}`);
}

In TypeScript: Map.get may return undefined, so driver() checks it once and throws for a missing name, which narrows every later use to Driver.

Recorded with TypeScript 6.0.3 (strict), run by Node.js 24.21.0 on macOS 26 arm64. It runs in your browser with QuickJS (quickjs-emscripten 0.32.0) after Sucrase 3.35.1. To run it yourself: npx -p typescript@6.0.3 tsc --noEmit --strict main.ts && node main.ts

Go 1.27 · main.go

package main

import (
	"fmt"
	"strings"
)

type driver struct {
	state   string
	version int
}

// store is the driver state store.
type store struct {
	conditional bool
	drivers     map[string]*driver
	promised    []string // rides promised, each with its driver
}

func (s *store) read(name string) int {
	return s.drivers[name].version
}

func (s *store) offer(matcher, ride, name string, seen int) bool {
	d := s.drivers[name]
	fresh := d.state == "available" && d.version == seen
	ok := fresh || !s.conditional // a plain write checks nothing
	outcome := "refused"          // refused: the conditional update changed 0 rows
	if ok {
		d.state, d.version = "offered", d.version+1
		s.promised = append(s.promised, ride+" -> "+name)
		outcome = "written"
	}
	fmt.Printf("  %s offers %s to %s, read at version %d: %s, version %d\n",
		matcher, ride, name, seen, outcome, d.version)
	return ok
}

func main() {
	for _, conditional := range []bool{false, true} {
		if conditional {
			fmt.Println("conditional writes")
		} else {
			fmt.Println("plain writes")
		}
		drivers := map[string]*driver{"D": {"available", 7}, "E": {"available", 7}}
		s := &store{conditional: conditional, drivers: drivers}
		seenByA, seenByB := s.read("D"), s.read("D")
		s.offer("A", "r1", "D", seenByA)
		if !s.offer("B", "r2", "D", seenByB) {
			s.offer("B", "r2", "E", s.read("E")) // the next candidate
		}
		fmt.Printf("  riders promised: %s\n", strings.Join(s.promised, ", "))
	}
}

In Go: The map holds *driver pointers, so changing d.state changes the stored driver; a map of driver values would hand back copies.

Recorded with Go 1.27.1 on macOS 26 arm64. It runs in your browser with the Go compiler in WebAssembly 1.27.1. To run it yourself: go run main.go

Swift 6.4 · main.swift

struct Driver {
  var state = "available"
  var version = 7
}

/// The driver state store.
struct Store {
  let conditional: Bool
  var drivers = ["D": Driver(), "E": Driver()]
  var promised: [String] = []  // rides promised, each with its driver

  func read(_ name: String) -> Int {
    drivers[name, default: Driver()].version
  }

  mutating func offer(_ matcher: String, _ ride: String, to name: String, seen: Int) -> Bool {
    var driver = drivers[name, default: Driver()]
    let fresh = driver.state == "available" && driver.version == seen
    let ok = fresh || !conditional  // a plain write checks nothing
    if ok {
      driver = Driver(state: "offered", version: driver.version + 1)
      drivers[name] = driver
      promised.append("\(ride) -> \(name)")
    }
    // refused: the conditional update changed 0 rows
    let outcome = "\(ok ? "written" : "refused"), version \(driver.version)"
    print("  \(matcher) offers \(ride) to \(name), read at version \(seen): \(outcome)")
    return ok
  }
}

for conditional in [false, true] {
  print(conditional ? "conditional writes" : "plain writes")
  var store = Store(conditional: conditional)
  let (seenByA, seenByB) = (store.read("D"), store.read("D"))
  _ = store.offer("A", "r1", to: "D", seen: seenByA)
  if !store.offer("B", "r2", to: "D", seen: seenByB) {
    _ = store.offer("B", "r2", to: "E", seen: store.read("E"))  // the next candidate
  }
  print("  riders promised: \(store.promised.joined(separator: ", "))")
}

In Swift: Driver is a struct, a value type, so offer() changes a copy and writes it back with drivers[name] = driver.

Recorded with Apple Swift 6.4 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: swiftc -O main.swift -o main && ./main

Ruby 4.0 · main.rb

# frozen_string_literal: true

Driver = Struct.new(:state, :version)

# the driver state store
class Store
  attr_reader :promised

  def initialize(conditional)
    @conditional = conditional
    @drivers = %w[D E].to_h { |name| [name, Driver.new('available', 7)] }
    @promised = [] # rides promised, each with its driver
  end

  def read(name)
    @drivers[name].version
  end

  def offer(matcher, ride, name, seen)
    driver = @drivers[name]
    fresh = driver.state == 'available' && driver.version == seen
    written = fresh || !@conditional # a plain write checks nothing
    write(driver, ride, name) if written
    # refused: the conditional update changed 0 rows
    outcome = "#{written ? 'written' : 'refused'}, version #{driver.version}"
    puts "  #{matcher} offers #{ride} to #{name}, read at version #{seen}: #{outcome}"
    written
  end

  private

  def write(driver, ride, name)
    driver.state = 'offered'
    driver.version += 1
    @promised << "#{ride} -> #{name}"
  end
end

[false, true].each do |conditional|
  puts conditional ? 'conditional writes' : 'plain writes'
  store = Store.new(conditional)
  seen_by_a = store.read('D')
  seen_by_b = store.read('D')
  store.offer('A', 'r1', 'D', seen_by_a)
  store.offer('B', 'r2', 'E', store.read('E')) unless store.offer('B', 'r2', 'D', seen_by_b)
  puts "  riders promised: #{store.promised.join(', ')}"
end

In Ruby: Struct.new builds Driver with its accessors, and RuboCop allows methods of ten lines at most, so the write is a private method of its own.

Recorded with CRuby 4.0.7 on macOS 26 arm64. It runs in your browser with ruby.wasm 2.10.1 (Ruby 4.0.0). To run it yourself: ruby main.rb

Kotlin 2.4 · Main.kt

data class Driver(
    val state: String = "available",
    val version: Int = 7,
)

// the driver state store
class Store(
    private val conditional: Boolean,
) {
    private val drivers = mutableMapOf("D" to Driver(), "E" to Driver())
    val promised = mutableListOf<String>() // rides promised, each with its driver

    fun read(name: String): Int = drivers.getValue(name).version

    fun offer(
        matcher: String,
        ride: String,
        name: String,
        seen: Int,
    ): Boolean {
        var driver = drivers.getValue(name)
        val fresh = driver.state == "available" && driver.version == seen
        val ok = fresh || !conditional // a plain write checks nothing
        if (ok) {
            driver = Driver("offered", driver.version + 1)
            drivers[name] = driver
            promised.add("$ride -> $name")
        }
        // refused: the conditional update changed 0 rows
        val outcome = if (ok) "written" else "refused"
        val offer = "  $matcher offers $ride to $name"
        println("$offer, read at version $seen: $outcome, version ${driver.version}")
        return ok
    }
}

fun main() {
    for (conditional in listOf(false, true)) {
        println(if (conditional) "conditional writes" else "plain writes")
        val store = Store(conditional)
        val (seenByA, seenByB) = store.read("D") to store.read("D")
        store.offer("A", "r1", "D", seenByA)
        if (!store.offer("B", "r2", "D", seenByB)) {
            store.offer("B", "r2", "E", store.read("E")) // the next candidate
        }
        println("  riders promised: ${store.promised.joinToString(", ")}")
    }
}

In Kotlin: Driver is an immutable data class, so an offer stores a new Driver in the map instead of changing the old one.

Recorded with Kotlin 2.4.20 on Java 25.0.4.1 on macOS 26 arm64. It runs in your browser with a WebAssembly build on the WASI runner (browser_wasi_shim 0.4.2). To run it yourself: kotlinc Main.kt -include-runtime -d main.jar && java -jar main.jar

Dart 3.13 · main.dart

class Driver {
  var state = 'available';
  var version = 7;
}

/// The driver state store.
class Store {
  Store(this.conditional);
  final bool conditional;
  final drivers = {'D': Driver(), 'E': Driver()};
  final promised = <String>[]; // rides promised, each with its driver

  int read(String name) => drivers[name]!.version;

  bool offer(String matcher, String ride, String name, int seen) {
    final driver = drivers[name]!;
    final fresh = driver.state == 'available' && driver.version == seen;
    final ok = fresh || !conditional; // a plain write checks nothing
    if (ok) {
      driver
        ..state = 'offered'
        ..version += 1;
      promised.add('$ride -> $name');
    }
    // refused: the conditional update changed 0 rows
    final outcome = ok ? 'written' : 'refused';
    print(
      '  $matcher offers $ride to $name, read at version $seen: $outcome, '
      'version ${driver.version}',
    );
    return ok;
  }
}

void main() {
  for (final conditional in [false, true]) {
    print(conditional ? 'conditional writes' : 'plain writes');
    final store = Store(conditional);
    final (seenByA, seenByB) = (store.read('D'), store.read('D'));
    store.offer('A', 'r1', 'D', seenByA);
    if (!store.offer('B', 'r2', 'D', seenByB)) {
      store.offer('B', 'r2', 'E', store.read('E')); // the next candidate
    }
    print('  riders promised: ${store.promised.join(', ')}');
  }
}

In Dart: The cascade driver..state = ... ..version += 1 changes two fields of the stored object in one expression.

Recorded with Dart 3.13.5 on macOS 26 arm64. It runs in your browser with a WebAssembly build by dart2wasm 3.13.5. To run it yourself: dart run main.dart