memoire

@@ -1,23 +0,0 @@

---[[

-    clears the terminal

-    implementation may be platform-specific

-]]

-function clear()

-    -- ANSI

-    io.write("\x1b[H\x1b[J")

-end

-

---[[

-    check if standard input is a terminal

-]]

-function isatty()

-    local succ = os.execute("tty >/dev/null")

-    return succ

-end

-

-local actions = {}

-for _, fname in ipairs({"addcards", "correction", "help", "leeches", "query", "reviewtty", "statistics", "toggle", "vocalreview"}) do

-    actions[fname:sub(1, 1)] = dofile(SRC_DIR .. fname .. ".lua")

-end

-

-return actions

@@ -1,44 +0,0 @@

---[[

-    returns a not-necessarily-meaningful number

-    iff `s` has mismathched curly-brackets

-]]

-local function mismatched(s)

-    return ("}" .. s):find("}[^{]+}") or (s .. "{"):find("{[^}]+{")

-end

-

-local function fn(config, deck)

-    if isatty() then

-        io.write("Reading prompts; press Ctrl-D to stop\n")

-    end

-    local rt = io.read("a")

-    local cardctr = 0

-    local prctr = 0

-    for pt in rt:gmatch("(..-)\n\n") do

-        local nc = {}

-        -- these Prompts will just be converted to Rec, so we don't need to exclude answers from prompt-text

-        for _re in pt:gmatch("%{[^%}]+%}") do

-            table.insert(nc, Prompt:new(pt, "", os.time(), 30, 0, 0, os.time(), config:get("StartingEase") or 2.5))

-            prctr = prctr + 1

-        end

-        if mismatched(pt) then

-            io.write(string.format("Prompt %d:1 (\"%s\") contains mismatched braces\n", #deck + 1, pt))

-        end

-        if #nc >= 1 then

-            table.insert(deck, nc)

-            cardctr = cardctr + 1

-        else

-            io.write(string.format("Prompt \"%s\" contains no answers (check braces)\n", pt))

-        end

-    end

-    io.write(string.format(

-        "Added %d cards (%d prompts)\n",

-        cardctr,

-        prctr

-    ))

-    if cardctr > 0 then

-        return deck

-    end

-end

-

-return { desc = "(a)dd card (from stdin)", nd = true, fn = fn }

-

@@ -1,25 +0,0 @@

-local function fn(config, deck, _, ip)

-    local sp = deck[ip[1]][ip[2]]

-    local rt = sp:spt()

-    local fname = "memoire_cc.tmp"

-    local fh = io.open(fname, "w")

-    fh:write(rt)

-    fh:close()

-    os.execute(string.format(

-        "%s %q",

-        os.getenv("EDITOR") or "vi",

-        fname

-    ))

-    fh = io.open(fname, "r")

-    local nt = fh:read("a"):gsub("%s+$", ""):gsub("^%s+", "")

-    fh:close()

-    os.remove(fname)

-    if nt ~= sp:spt() and nt ~= "" then

-        local cardrec = Prompt:torec(deck[ip[1]])

-        cardrec.PromptText = { nt }

-        deck[ip[1]] = Prompt:fromrecs({ cardrec }, config)[1]

-        return deck

-    end

-end

-

-return { desc = "(c)orrect card (with card:prompt index)", nd = true, ni = true, fn = fn }

@@ -1,13 +0,0 @@

-local function fn()

-    io.write(string.format("Usage: %s ACTION\n\nACTION may be one of\n", arg[0]))

-    local sal = {}

-    for _, v in pairs(ACTIONS) do

-        table.insert(sal, v.desc)

-    end

-    table.sort(sal)

-    for _, v in ipairs(sal) do

-        io.write(string.format("\t%s\n", v))

-    end

-end

-

-return { desc = "(h)elp", nd = false, fn = fn } 

@@ -1,26 +0,0 @@

---[[

-    return number indicating how much of a leech the prompt is

-]]

-local function badness(pr)

-    return pr.fail / (pr.fail + pr.succ) * math.log(pr.fail)

-end

-

-local function fn(config, deck)

-    local leechqueue = {}

-    for i, cg in ipairs(deck) do

-        for j, pr in ipairs(cg) do

-            if pr.ease < 2 and pr.delay >= 0 then

-                table.insert(leechqueue, { i, j })

-            end

-        end

-    end

-    table.sort(leechqueue, function(a, b)

-        return badness(deck[a[1]][a[2]]) > badness(deck[b[1]][b[2]])

-    end)

-    io.write(string.format("Detected %d leeches:\n", #leechqueue))

-    for _, ij in ipairs(leechqueue) do

-        io.write(string.format("%d:%d %s\n", ij[1], ij[2], deck[ij[1]][ij[2]]))

-    end

-end

-

-return { desc = "(l)eech search", nd = true, fn = fn } 

@@ -1,39 +0,0 @@

---[[

-    deck loading and saving functions (working with Recfiles)

-]]

-

-local Prompt = dofile(SRC_DIR .. "prompt.lua")

-local recrw = dofile(SRC_DIR .. "recrw.lua")

-

---[[

-    load a deck (a table of tables of `Prompt`s) from a Recfile

-]]

-local function loaddeck(fname, conf)

-    local fh = io.open(fname)

-    if not fh then return nil end

-    local rt = fh:read "a"

-    if not rt then return nil end

-    fh:close()

-    local pr = recrw.read(rt)

-    if not pr then return nil end

-    local ep = Prompt:fromrecs(pr, conf)

-    return ep

-end

-

---[[

-    save a deck (a table of tables of `Prompt`s) to a Recfile

-]]

-local function savedeck(fname, deck)

-    local rrf = {}

-    for i, cg in ipairs(deck) do

-        rrf[i] = Prompt:torec(cg)

-    end

-    local wot = recrw.write(rrf)

-    local fh = io.open(fname, "w")

-    if not fh then io.write("couldn't open output\n") end

-    local wr, err = fh:write(wot)

-    if not wr then io.write("couldn't write to output\n") end

-    fh:close()

-end

-

-return { load = loaddeck, save = savedeck }

@@ -1,136 +0,0 @@

-#!/usr/bin/env lua

---[[

-    the main user interface for memoire

-]]

-

-SRC_DIR = arg[0]:match("^.*/") or ""

-

-Prompt = dofile(SRC_DIR .. "prompt.lua")

-review = dofile(SRC_DIR .. "review.lua")

-loader = dofile(SRC_DIR .. "loader.lua")

-recrw = dofile(SRC_DIR .. "recrw.lua")

-ACTIONS = dofile(SRC_DIR .. "actions.lua")

-

---[[

-    check action based on first command-line argument;

-    if nothing valid given, default to help

-]]

-local action = nil

-if arg[1] then

-    local fc = arg[1]:sub(1, 1)

-    action = ACTIONS[fc] or ACTIONS.h

-else

-    action = ACTIONS.h

-end

-

-local confdir = os.getenv("HOME") .. "/.config/memoire/"

-local config = { DeckFile = { "" } }

-

-do

-local fh = io.open(confdir .. "config.rec")

-if fh then

-    local ft = fh:read("a")

-    local ct = recrw.read(ft)

-    if ct and ct[1] then config = ct[1]

-    else io.write("Erroneous configuration file\n") end

-else

-    io.write("Could not open configuration file in " .. confdir .. "\n")

-end

-end

-

---[[

-    gets config option `name`; if multiple values were given,

-    provide the `ind`th one (or the first, if `ind` is not given)

-    return `nil` if no such option available

-]]

-function config:get(name, ind)

-    return (self[name] or {})[ind or 1]

-end

-

-if not config.DeckFile then

-    io.write("No deck files specified; aborting\n")

-    os.exit(true, true)

-end

-

-if #config.DeckFile > 1 then

-    io.write("Select deck to use (by number):\n")

-    for i, n in ipairs(config.DeckFile) do

-       io.write(string.format("\t%d. %s\n", i, n))

-    end

-    local rl = io.read("l")

-    local si = tonumber(rl)

-    if si and si <= #config.DeckFile and si >= 1 then

-        deckfname = config.DeckFile[si]

-    elseif si then

-        io.write("Selected deck out of range; aborting\n")

-        os.exit(true, true)

-    else

-        io.write("Input not a number; aborting")

-        os.exit(true, true)

-    end

-else

-    deckfname = config.DeckFile[1]

-end

-

---[[

-    returns four tables:

-    question-text, question-lang, answer-text, answer-lang

-]]

-defaultprspeak = function(pr)

-    return {(pr.text:gsub("%{([^{}]+)%}", "%1"):gsub("%%A", "WHAT"))}, {false}, {"ANSWER: " .. pr.ans}, {false}

-end

-prspeak = defaultprspeak

-do

-local fh = io.open(confdir .. "prspeak.lua")

-if fh then

-    fh:close()

-    prspeak = dofile(confdir .. "prspeak.lua")

-end

-end

-

-deckfname = os.getenv("HOME") .. "/" .. deckfname

-

-math.randomseed(os.time())

-

-if action.nd then

-    local deck = loader.load(deckfname, config)

-    if deck then

-        if action.ni then

-            local ip

-            if arg[2] then

-                local a, b = arg[2]:match("(%d+):(%d+)")

-                if a and b then

-                    -- a and b are valid numbers because they came from a match

-                    ip = { tonumber(a), tonumber(b) }

-                else

-                    ip = tonumber(arg[2])

-                    if ip then

-                        ip = { ip, 1 }

-                    end

-                end

-            end

-            if ip then

-                deck = action.fn(config, deck, deckfname, ip)

-            else

-                io.write("Bad prompt index (must be cardnum:promptnum)\n")

-            end

-        elseif action.nq then

-            local qs

-            if arg[2] then

-                qs = arg[2]

-            end

-            deck = action.fn(config, deck, deckfname, qs)

-        else

-            deck = action.fn(config, deck, deckfname)

-        end

-        if deck then

-            loader.save(deckfname, deck)

-        end

-    else

-        io.write("Failed to load deck\n")

-    end

-else

-    action.fn(config)

-end

@@ -1,112 +0,0 @@

---[[

-    a prompt consists of prompt text (with an answer-insertion point),

-    a correct answer, the review timestamp, the review delay,

-    counts of successful and failed reviews,

-    a creation timestamp, and an ease measurement

-

-    timestamps are seconds from the Unix epoch

-    review delay is in seconds

-]]

-

-local Prompt = {}

-Prompt.__index = Prompt

-

---[[

-    the answer-insertion point is indicated with a "%A" in the prompt text

-]]

-function Prompt:new(pt, ca, rts, rd, sc, fc, ct, ez)

-    local o = {}

-    setmetatable(o, self)

-    o.text = pt

-    o.ans = ca

-    o.time = tonumber(rts)

-    o.delay = tonumber(rd)

-    o.succ = tonumber(sc)

-    o.fail = tonumber(fc)

-    o.created = tonumber(ct)

-    o.ease = tonumber(ez)

-    return o

-end

-

-function Prompt:__tostring()

-    return string.format(

-        "\"%s\" (\"%s\") %d -> %d+%d*%f %d/%d",

-        self.text, self.ans, self.created or 0,

-        self.time, math.floor(self.delay), self.ease,

-        self.succ, self.fail

-    )

-end

-

-function Prompt:retention()

-    return self.succ / (self.succ + self.fail)

-end

-

---[[

-    derive the `PromptText` used to create this `Prompt`

-]]

-function Prompt:spt()

-    return self.text:gsub("%%A", "{" .. self.ans:gsub("%%", "%%%%") .. "}")

-end

-

---[[

-    extracts `Prompt`s from a record-based deck

-    returns a table of tables of `Prompt`s

-]]

-function Prompt:fromrecs(recs, conf)

-    local ret = {}

-    for i, rec in ipairs(recs) do

-        -- only bother with records with `PromptText`

-        if rec.PromptText then

-            ret[i] = {}

-            local opt = rec.PromptText[1]

-            local m, n = opt:find "%{[^%}]+%}"

-            local ctr = 1

-            while m do

-                local mpt = opt:sub(1, m - 1) .. "%A" .. opt:sub(n + 1)

-                table.insert(ret[i], Prompt:new(

-                    mpt,

-                    opt:sub(m + 1, n - 1),

-                    (rec.LastReview or {})[ctr] or (rec.LastReview or {})[1],

-                    (rec.LastDelay or {})[ctr] or 15,

-                    (rec.Successes or {})[ctr] or 0,

-                    (rec.Failures or {})[ctr] or 0,

-                    (rec.Created or {})[1],

-                    (rec.Ease or {})[ctr] or conf:get("StartingEase") or "2.5"

-                ))

-                m, n = opt:find("%{[^%}]+%}", n)

-                ctr = ctr + 1

-            end

-        end

-    end

-    return ret

-end

-

---[[

-    serialises an ordered table of `Prompt`s derived from the same `PromptText` to a record

-    returns (on success) a table mapping labels to value-lists

-    returns (on failure) nil

-]]

-function Prompt:torec(prompts)

-    if prompts[1].deleted then

-        return {}

-    end

-    local fspt = prompts[1]:spt()

-    local ret = { PromptText = { fspt }, LastReview = {}, LastDelay = {}, Successes = {}, Failures = {}, Ease = {} }

-    if prompts[1].created then

-        ret.Created = { prompts[1].created }

-    end

-    for i, pr in ipairs(prompts) do

-        if pr:spt() ~= fspt then

-            -- not from the same `PromptText`

-            return nil

-        end

-        ret.LastReview[i] = pr.time

-        ret.LastDelay[i] = pr.delay

-        ret.Successes[i] = pr.succ

-        ret.Failures[i] = pr.fail

-        ret.Ease[i] = pr.ease

-    end

-    return ret

-end

-

-return Prompt

@@ -1,18 +0,0 @@

-local function fn(config, deck, deckfname, qs)

-    local mcl = {}

-    for i, card in ipairs(deck) do

-        if card[1]:spt():find(qs) then

-            table.insert(mcl, i)

-        end

-    end

-    if #mcl >= 1 then

-        io.write(string.format("Found %d match%s for %q:\n", #mcl, #mcl == 1 and "" or "es", qs))

-    else

-        io.write(string.format("No matches for %q\n", qs))

-    end

-    for _, i in ipairs(mcl) do

-        io.write(string.format("%d %s\n", i, deck[i][1]:spt()))

-    end

-end

-

-return { desc = "(q)uery deck for cards (case-sensitive)", nd = true, nq = true, fn = fn }

@@ -1,106 +0,0 @@

---[[

-    a Recfile is (to simplify) a sequence of records

-    a record is a sequence of fields

-    a field is a label-value pair

-    a label is an identifier

-    a value is a string

-]]

-

---[[

-    converts text from a Recfile into a sequence of records

-    returns (on success) a table of tables of pairs of labels and value-lists

-    returns (on failure) nil

-]]

-local function text2recs(str)

-    local ret = {}

-    local cr = {}

-    local cl = nil

-    local cv = nil

-    -- Rec is line-based

-    for line in str:gmatch "([^\n]*)\n" do

-        -- continuation lines

-        if cv and cv:sub(-1) == "\\" then

-            cv = cv:sub(1, -2) .. line

-        elseif line:sub(1, 1) == "+" then

-            cv = cv .. "\n" .. line:gsub("^%+ ?", "")

-        -- blank lines separate records

-        elseif line:match "^%s*$" then

-            -- add field to record if non-empty

-            if cl then

-                if cr[cl] then

-                    table.insert(cr[cl], cv)

-                else

-                    cr[cl] = { cv }

-                end

-            end

-            cl = nil

-            cv = nil

-            -- add record to return value if non-empty

-            if next(cr) then

-                table.insert(ret, cr)

-            end

-            cr = {}

-        -- lines starting with # are comments

-        elseif line:sub(1, 1) == "#" then

-            if cl then

-                if cr[cl] then

-                    table.insert(cr[cl], cv)

-                else

-                    cr[cl] = { cv }

-                end

-            end

-            cl = nil

-            cv = nil

-        -- new field

-        else

-            if cl then

-                if cr[cl] then

-                    table.insert(cr[cl], cv)

-                else

-                    cr[cl] = { cv }

-                end

-            end

-            cl, cv = line:match "^([%a%%][%w_]*):%s(.*)"

-            -- no match? bad field

-            if not cl then return nil end

-        end

-    end

-    if cl then

-        if cr[cl] then

-            table.insert(cr[cl], cv)

-        else

-            cr[cl] = { cv }

-        end

-    end

-    if next(cr) then

-        table.insert(ret, cr)

-    end

-    return ret

-end

-

---[[

-    converts a sequence of records into text for a Recfile

-    returns (on success) a string

-    returns (on failure) nil

-]]

-local function recs2text(recs, si, ei)

-    local ret = ""

-    si = si or 1

-    ei = ei or #recs

-    --[[

-        use recursive (binary-splitting) string building

-        this makes stuff way more efficient

-    ]]

-    if si == ei then

-        for label, vl in pairs(recs[si]) do

-            for j, value in ipairs(vl) do

-                ret = ret .. string.format("\n%s: %s", label, tostring(value):gsub("\n", "\n+ "))

-            end

-        end

-        return ret .. "\n"

-    else

-        return recs2text(recs, si, (si + ei) // 2) .. recs2text(recs, (si + ei) // 2 + 1, ei)

-    end

-end

-

-return { read = text2recs, write = recs2text }

@@ -1,120 +0,0 @@

---[[

-    stuff to help with the review mechanics

-]]

-

---[[

-    determines the delay until next review (in seconds)

-    when `Prompt` `prompt` is reviewed at timestamp `revtime`

-    with review success `revsucc`

-]]

-local function schedule(prompt, revtime, revsucc, conf)

-    if revsucc and revsucc > 0 then

-        local ad = revtime - (prompt.time or revtime)

-        local adm = ad + math.max(40000 - 0.5 * ad, 0)

-        -- SM2, as explained by Bjornstad

-        -- https://controlaltbackspace.org/memory/spaced-repetition-from-the-ground-up/

-        if revsucc < 0.8 then

-            return (conf:get("HardRatio") or 1.2) * revsucc * 2 * adm

-        else

-            return prompt.ease * (1 + 2 * ((conf:get("EasyRatio") or 1.3) - 1) * (revsucc - 1)) * adm

-        end

-    else

-        return 15

-    end

-end

-

---[[

-    manipulates `Prompt` `prompt` in-place as it should be

-    when reviewed at timestamp `revtime` with review success `revsucc`

-]]

-local function update(prompt, revtime, revsucc, conf)

-    if revsucc and revsucc > 0 then

-        prompt.succ = (prompt.succ or 0) + 1

-    else

-        prompt.fail = (prompt.fail or 0) + 1

-    end

-    -- allowed random variation, as a fraction of the "optimal" duration

-    local ARV = conf:get("AllowedRandomVariation") or 0.1

-    prompt.delay = schedule(prompt, revtime, revsucc, conf) * ((1 - ARV) + 2 * ARV * math.random())

-    prompt.ease = prompt.ease + ({ -0.2, -0.15, 0, 0.15 })[2 * revsucc + 1]

-    prompt.time = revtime

-end

-

---[[

-    rates the importance of `Prompt` `prompt` as an additive bias

-    based on the rules given in `conf`

-]]

-local function importance(prompt, conf)

-    pt = conf["PriorityText"] or {}

-    pb = conf["PriorityBias"] or {}

-    s = 0

-    for i, t in ipairs(pt) do

-        if prompt:spt():find(t) then

-            s = s + pb[i]

-        end

-    end

-    return s

-end

-

---[[

-    checks if `Prompt` `prompt` should be reviewed now,

-    returning `false` if not and a number to indicate urgency if it should

-]]

-local function should(prompt, conf)

-    local ct = os.time()

-    if not prompt.delay then return -1 end

-    if prompt.delay >= 0 and ct - (prompt.time or 0) >= (prompt.delay or 0) then

-        return (ct - (prompt.time or 0)) / prompt.delay / prompt.ease / (prompt.succ + 1) + importance(prompt, conf) + 0.1 * math.random()

-    end

-    return false

-end

-

-local function alwaystrue(x)

-    return true

-end

-

---[[

-    returns a table of pairs of integers to index the deck

-    to get prompts to be reviewed now;

-    prompts are shuffled in order

-    if a filter function is provided, filters the list accordingly,

-    calling the filter function on each `Prompt`

-]]

-local function toreviewlist(deck, conf, filter)

-    local ctrt = {}

-    local ff = filter or alwaystrue

-    for i, cg in ipairs(deck) do

-        for j, pr in ipairs(cg) do

-            local sc = should(pr, conf)

-            if sc and ff(pr) then

-                table.insert(ctrt, { i, j, sc or 0 })

-            end

-        end

-    end

-    table.sort(ctrt, function(a, b)

-        return a[3] > b[3]

-    end)

-    return ctrt

-end

-

---[[

-    gets the score (again/hard/good/easy/correction) from a string by first character

-    scores are numbers, higher is easier, -1 is correction

-]]

-local function succfromstr(s)

-    local f = s:sub(1, 1):lower()

-    if f == "0" or f == "a" then

-        return 0

-    elseif f == "1" or f == "h" then

-        return 0.5

-    elseif f == "2" or f == "g" then

-        return 1

-    elseif f == "3" or f == "e" then

-        return 1.5

-    elseif f == "-" or f == "c" then

-        return -1

-    end

-    return 1

-end

-

-return { schedule = schedule, update = update, should = should, list = toreviewlist, succfromstr = succfromstr }

@@ -1,187 +0,0 @@

---[[

-    show progress thru a review session, conditioned on the user

-    configuring that to happen

-]]

-local function showprogress(k, n, conf)

-    if conf:get("ShowProgress") then

-        io.write(string.format("(%d/%d) ", k, n))

-    end

-end

-

---[[

-    display text with images, inserted with `IMG[path]`

-    implementation may be platform-specific

-    `basepath` points to the base directory of the images

-]]

-local function imgify(text, basepath, ind, climn, conf)

-    local fh = io.popen("tput lines")

-    local tl = tonumber(fh:read("a"))

-    io.write(("\n"):rep(math.floor(0.4 * tl)))

-    showprogress(ind, climn, conf)

-    if conf:get("BoldContext") then

-        local csi, cei = text:find("^[^:]+:")

-        if csi then

-            local cpt = text:sub(csi, cei)

-            io.write("\x1b[1m")

-            io.write(cpt)

-            io.write("\x1b[0m")

-            text = text:sub(cei + 1)

-        end

-    end

-    -- adapted from https://stackoverflow.com/a/1579673

-    local IMG_PATTERN = "IMG%[([^%]]+)%]"

-    local PATTERN = "(.-)" .. IMG_PATTERN

-    -- Linux/dwm

-    local DISPIMG = function(path, st)

-        if path and #path > 0 then

-            os.execute(string.format(

-                "/usr/local/bin/iv -t '%s' %s%s &",

-                st:gsub("'", "\""):gsub(IMG_PATTERN, ""), basepath, path

-            ))

-        end

-    end

-    local lastend = 1

-    local mstart, mend, prevtext, imgpath = text:find(PATTERN)

-    io.write(prevtext or "")

-    DISPIMG(imgpath, text)

-    while mstart do

-        lastend = mend + 1

-        mstart, mend, prevtext, imgpath = text:find(PATTERN, lastend)

-        io.write(prevtext or "")

-        DISPIMG(imgpath, text)

-    end

-    if lastend <= #text then

-        io.write(text:sub(lastend))

-    end

-end

-

---[[

-    rounds `x` to `n` places (default 0) after the radix point

-    in base `b` (default 10)

-]]

-local function round(x, n, b)

-    local b = b or 10

-    local n = n or 0

-    if n == 0 then

-        return math.tointeger(math.floor(x * b ^ n) / b ^ n)

-    else

-        return math.floor(x * b ^ n) / b ^ n

-    end

-end

-

---[[

-    return human-friendly string to present a duration (input in seconds),

-    e.g. "44:37", "4.8h", "11d", "8.3m", "17.4y"

-]]

-local function disptime(ts)

-    local YDAY = 365.24

-    local MDAY = YDAY / 12

-    local DSEC = 86400

-    local HSEC = 3600

-    if ts >= 3 * YDAY * DSEC then

-        return round(ts / (YDAY * DSEC), 1) .. "y"

-    elseif ts >= 4 * MDAY * DSEC then

-        return round(ts / (MDAY * DSEC), 1) .. "m"

-    elseif ts >= 10 * DSEC then

-        return round(ts / DSEC) .. "d"

-    elseif ts >= 1.5 * DSEC then

-        return round(ts / DSEC, 1) .. "d"

-    elseif ts >= 8 * HSEC then

-        return round(ts / HSEC) .. "h"

-    elseif ts >= HSEC then

-        return round(ts / HSEC, 1) .. "h"

-    else

-        return string.format("%d:%02d", round(ts / 60), round(ts % 60))

-    end

-end

-

-local function fn(config, deck, deckfname)

-    if not isatty() then

-        io.write("Review should be done in the terminal\n")

-        return nil

-    end

-    -- collect list of index-pairs for prompts to be reviewed this session

-    local ctrt = review.list(deck, config)

-    io.write(string.format(

-        "%d prompts are ready for review.\nHow many to review in this session? ", #ctrt

-    ))

-    io.flush()

-    local climt = io.read("l")

-    local climn = tonumber(climt)

-    if not climn then

-        io.write("Input not a number; aborting\n")

-        return nil

-    end

-    climn = math.min(climn, #ctrt)

-    local lrc = 0

-    local editqueue = {}

-    local start = os.time()

-    -- review prompts in this session's set

-    for ind, ip in ipairs(ctrt) do

-        if ind > climn then

-            break

-        end

-        local pr = deck[ip[1]][ip[2]]

-        -- remove braces for display

-        local pst = pr.text:gsub("%{([^{}]+)%}", "%1")

-        local st = os.time()

-        imgify(pst:gsub("%%A", "___"), deckfname:match(".*/") or "", ind, climn, config)

-        io.write("\n")

-        io.read("l")

-        clear()

-        imgify(

-            pst:gsub("%%A", "\x1b[1m" .. (pr.ans:gsub("%%", "%%%%")) .. "\x1b[0m"),

-            deckfname:match(".*/") or "",

-            ind,

-            climn,

-            config

-        )

-        io.write(string.format(

-            "\nAgain / Hard (%s) / Good (%s) / Easy (%s) / Correction ",

-            disptime(review.schedule(pr, st, 0.5, config)),

-            disptime(review.schedule(pr, st, 1, config)),

-            disptime(review.schedule(pr, st, 1.5, config))

-        ))

-        io.flush()

-        local resp = io.read("l")

-        local sc = review.succfromstr(resp)

-        if sc == -1 then

-            table.insert(editqueue, ip)

-        else

-            if sc == 0 then

-                lrc = lrc + 1

-            end

-            review.update(deck[ip[1]][ip[2]], st, sc, config)

-        end

-        clear()

-        if resp:sub(#resp):lower() == "q" then

-            climn = ind

-            break

-        end

-    end

-    if #ctrt > 0 then

-        local endt = os.time()

-        io.write(string.format(

-            "Reviewed %d prompts in %d seconds\n",

-            math.min(#ctrt, climn),

-            endt - start

-        ))

-        local s

-        if lrc == 1 then s = "" else s = "s" end

-        io.write(string.format(

-            "(%d lapse%s, %f seconds per card)\n",

-            lrc, s, (endt - start) / math.min(#ctrt, climn)

-        ))

-    end

-    if #editqueue > 0 then

-        io.write(string.format("The following cards are marked for correction:\n"))

-        for _, ip in ipairs(editqueue) do

-            io.write(string.format("%d:%d %s\n", ip[1], ip[2], deck[ip[1]][ip[2]]))

-        end

-    end

-    if climn > 0 then

-        return deck

-    end

-end

-

-return { desc = "(r)eview sesion", nd = true, fn = fn }

@@ -1,115 +0,0 @@

---[[

-    generate and return text-based vertical histogram,

-    with bins of given width across interval from max to min,

-    transforming values to numbers via func,

-    scaling bar-length by scale

-]]

-local function histogram(list, min, max, width, func, scale)

-    local bins = {}

-    local oorc = 0

-    local prc = 0

-    for _, v in ipairs(list) do

-        local n = func(v)

-        if n == n and n >= min and n < max + width then

-            local k = math.floor((n - min) / width) + 1

-            bins[k] = (bins[k] or 0) + 1

-        else

-            oorc = oorc + 1

-        end

-        prc = prc + 1

-    end

-    local s = ""

-    for n = min, max, width do

-        local k = math.floor((n - min) / width) + 1

-        s = string.format("%s%.2f\t%s %d\n", s, n, ("\u{2588}"):rep(math.ceil(scale * (bins[k] or 0))), bins[k] or 0)

-    end

-    return s .. string.format("(%d out of range)\n", oorc)

-end

-

-local function fn(config, deck, deckfname, qs)

-    local tcc = 0

-    local tsc = 0

-    local tfc = 0

-    local spc = 0

-    local expdeck = {}

-    for _, card in ipairs(deck) do

-        local rtc

-        for _, pr in ipairs(card) do

-            if not qs or (pr.text:find(qs) or pr.ans:find(qs)) then

-                rtc = true

-                tsc = tsc + pr.succ

-                tfc = tfc + pr.fail

-                if pr.delay < 0 then

-                    spc = spc + 1

-                else

-                    table.insert(expdeck, pr)

-                end

-            end

-        end

-        if rtc then

-            tcc = tcc + 1

-        end

-    end

-    local qfn

-    if qs then

-        qfn = string.format(" (filtered with query %q)", qs)

-    else

-        qfn = ""

-    end

-    io.write(string.format(

-        "%s%s has %d cards and %d total prompts\n",

-        deckfname, qfn, tcc, #expdeck + spc

-    ))

-    io.write(string.format(

-        "(average %.2f prompts per card, %d/%.1f%% prompts suspended).\n",

-        (#expdeck + spc) / tcc, spc, 100 * spc / (#expdeck + spc)

-    ))

-    io.write(string.format(

-        "The deck's prompts have been reviewed a total of %d times\n",

-        tsc + tfc

-    ))

-    io.write(string.format(

-        "(average %.2f reviews per prompt), overall retention %.2f%%.\n",

-        (tsc + tfc) / (#expdeck + spc), 100 * tsc / (tsc + tfc)

-    ))

-    io.write("All further data excludes suspended prompts.\n")

-    io.write("\nEase\n" .. histogram(expdeck, 1.0, 3.3, 0.1, function(pr) return pr.ease end, 0.03))

-    io.write("\nLog2-delay (seconds)\n" .. histogram(expdeck, 15, 28, 0.5, function(pr) return math.log(pr.delay, 2) end, 0.1))

-    io.write("\nDelay-last review ratio\n" .. histogram(expdeck, 0, 2, 0.1, function(pr) return (os.time() - pr.time) / pr.delay end, 0.1))

-    io.write("\nRetention (%)\n" .. histogram(expdeck, 30, 100, 10, function(pr) return 100 * pr:retention() end, 0.02))

-    io.write("\nReview counts\n" .. histogram(expdeck, 0, 20, 2, function(pr) return pr.succ + pr.fail end, 0.03))

-    io.write("\nLog2-age (seconds)\n" .. histogram(expdeck, 18, 28, 0.5, function(pr) return math.log(os.time() - (pr.created or 2 * os.time()), 2) end, 0.05))

-    io.write("\nPrompt-count\n" .. histogram(deck, 1, 10, 1, function(card) return #card end, 0.03))

-    local cpcs = {}

-    for _, card in ipairs(deck) do

-        local cp = card[1].text:match("([^:]+):") or ""

-        cpcs[cp] = (cpcs[cp] or 0) + 1

-    end

-    local scl = {}

-    for l, c in pairs(cpcs) do

-        table.insert(scl, { l = l, c = c })

-    end

-    table.sort(scl, function(a, b) return a.c > b.c end)

-    for k, lc in ipairs(scl) do

-        scl[k] = string.format("%s (%d)", lc.l ~= "" and lc.l or "(none)", lc.c)

-    end

-    io.write("\nMost common contexts: " .. table.concat(scl, ", ", 1, math.min(20, #scl)) .. "\n")

-    table.sort(expdeck, function(a, b) return a.time + a.delay < b.time + b.delay end)

-    io.write("\nUpcoming due prompts wrt days from now:\n")

-    local ppi = 1

-    local mpi = 1

-    for dc = 1,100 do

-        for uc = ppi,#expdeck do

-            if expdeck[uc].time + expdeck[uc].delay - os.time() > dc * 86400 then

-                mpi = uc

-                break

-            end

-        end

-        if dc <= 10 or dc % 10 == 0 then

-            io.write(string.format("%d\t%s %d\n", dc, ("\u{2588}"):rep(math.ceil((mpi - ppi) / 10)), mpi - ppi))

-        end

-        ppi = mpi

-    end

-end

-

-return { desc = "(s)tatistics (with optional query)", nd = true, nq = true, fn = fn }

@@ -1,14 +0,0 @@

-local function fn(config, deck, _, ip)

-    local sp = deck[ip[1]][ip[2]]

-    local dir

-    if sp.delay < 0 then

-        dir = "Restoring"

-    else

-        dir = "Suspending"

-    end

-    io.write(string.format("%s %s\n", dir, sp))

-    sp.delay = -sp.delay

-    return deck

-end

-

-return { desc = "(t)oggle suspension of prompt (with card:prompt index)", nd = true, ni = true, fn = fn }

@@ -1,101 +0,0 @@

---[[

-    presents `text` thru text-to-speech,

-    with language/voice code `lang` (`false` or `nil` for default)

-    `text` and `lang` may also both be parallel tables

-    implementation may be platform-specific

-]]

-local function speak(text, conf, lang)

-    if type(text) == "string" and (type(lang) == "string" or type(lang) == "nil") then

-        text = {text}

-        lang = {lang}

-    end

-    for i, t in ipairs(text) do

-        os.execute(string.format(

-            "espeak %s %s %q",

-            conf:get("EspeakFlags") or "",

-            lang[i] and ("-v " .. lang[i]) or "",

-            t

-        ))

-    end

-end

-

-local function fn(config, deck, deckfname)

-    if not isatty() then

-        io.write("Review should be done in the terminal\n")

-        return nil

-    end

-    -- collect list of index-pairs for prompts to be reviewed this session

-    local ctrt = review.list(deck, config, function(pr) return not pr:spt():find("IMG%[") end)

-    speak(string.format(

-        "%d prompts to review; how many in this session? ", #ctrt

-    ), config)

-    local climt = io.read("l")

-    local climn = tonumber(climt)

-    if not climn then

-        speak("Input not a number; aborting", conf)

-        return nil

-    end

-    climn = math.min(climn, #ctrt)

-    local lrc = 0

-    local editqueue = {}

-    local start = os.time()

-    -- review prompts in this session's set

-    for ind, ip in ipairs(ctrt) do

-        if ind > climn then

-            break

-        end

-        local pr = deck[ip[1]][ip[2]]

-        -- remove braces for display

-        local pst = pr.text:gsub("%{([^{}]+)%}", "%1")

-        local st = os.time()

-        io.write(pst .. "\n" .. ind .. "/" .. climn .. "\n")

-        local qt, ql, at, al = prspeak(pr)

-        local heard = false

-        while not heard do

-            speak(qt, config, ql)

-            if io.read("l") ~= "r" then heard = true end

-        end

-        speak(at, config, al)

-        speak("hard, good, easy?", config)

-        local resp = io.read("l")

-        local sc = review.succfromstr(resp)

-        if sc == -1 then

-            table.insert(editqueue, ip)

-        else

-            if sc == 0 then

-                lrc = lrc + 1

-            end

-            review.update(deck[ip[1]][ip[2]], st, sc, config)

-        end

-        clear()

-        if resp:sub(#resp):lower() == "q" then

-            climn = ind

-            break

-        end

-    end

-    if #ctrt > 0 then

-        local endt = os.time()

-        io.write(string.format(

-            "Reviewed %d prompts in %d seconds\n",

-            math.min(#ctrt, climn),

-            endt - start

-        ))

-        local s

-        if lrc == 1 then s = "" else s = "s" end

-        io.write(string.format(

-            "(%d lapse%s, %f seconds per card)\n",

-            lrc, s, (endt - start) / math.min(#ctrt, climn)

-        ))

-    end

-    if #editqueue > 0 then

-        io.write(string.format("The following cards are marked for correction:\n"))

-        for _, ip in ipairs(editqueue) do

-            io.write(string.format("%d:%d %s\n", ip[1], ip[2], deck[ip[1]][ip[2]]))

-        end

-    end

-    if climn > 0 then

-        return deck

-    end

-end

-

-return { desc = "(v)ocal review session", nd = true, fn = fn }