Source code in the e programming language

pragma.syntax("0.9")

/** Makes leaves of the binary tree */
def leaf(value) { 
    return def leaf { 
        to run(_) { return value }
        to __printOn(out) { out.print("=> ", value) }
    }
}
/** Makes branches of the binary tree */
def split(leastRight, left, right) {
    return def tree {
        to run(specimen) {
            return if (specimen < leastRight) {
                left(specimen)
            } else {
                right(specimen)
            }
        }
        to __printOn(out) {
            out.print("    ")
            out.indent().print(left)
            out.lnPrint("< ")
            out.print(leastRight)
            out.indent().lnPrint(right)
        }
    }
}
def makeIntervalTree(assocs :List[Tuple[any, float64]]) {
    def size :int := assocs.size()
    if (size > 1) {
        def midpoint := size // 2
        return split(assocs[midpoint][1], makeIntervalTree(assocs.run(0, midpoint)),
                                          makeIntervalTree(assocs.run(midpoint)))
    } else {
        def [[value, _]] := assocs
        return leaf(value)
    }
}
def setupProbabilisticChoice(entropy, table :Map[any, float64]) {
    var cumulative := 0.0
    var intervalTable := []
    for value => probability in table {
        intervalTable with= [value, cumulative]
        cumulative += probability
    }
    def total := cumulative
    def selector := makeIntervalTree(intervalTable)
    return def probChoice {
        # Multiplying by the total helps correct for any error in the sum of the inputs
        to run() { return selector(entropy.nextDouble() * total) }
        to __printOn(out) {
            out.print("Probabilistic choice using tree:")
            out.indent().lnPrint(selector)
        }
    }
}

def rosetta := setupProbabilisticChoice(entropy, def probTable := [
    "aleph"  => 1/5,
    "beth"   => 1/6.0,
    "gimel"  => 1/7.0,
    "daleth" => 1/8.0,
    "he"     => 1/9.0,
    "waw"    => 1/10.0,
    "zayin"  => 1/11.0,
    "heth"   => 0.063455988455988432,
])

var trials := 1000000
var timesFound := [].asMap()
for i in 1..trials {
    if (i % 1000 == 0) { print(`${i//1000} `) }
    def value := rosetta()
    timesFound with= (value, timesFound.fetch(value, fn { 0 }) + 1)
}
stdout.println()
for item in probTable.domain() {
    stdout.print(item, "\t", timesFound[item] / trials, "\t", probTable[item], "\n")
}