Standard library · Databases

db/oxirec

Imported as import "db/oxirec" as oxirec, its names are then oxirec.…. Every signature below is the one the checker infers.

Functions

fn rec_now() -> Int

import "db/oxirec"
rec_now() > 1700000000   # => true

fn rec_connect(host: Str, port: Int) -> Result(Int, Str)

# not run
import "db/oxirec"
fd = rec_connect("127.0.0.1", 7411)?

fn rec_hang_up(fd: Int) -> Unit

# not run
import "db/oxirec"
rec_hang_up(fd)

fn rec_request(op: Str, fields: List(Field)) -> Json

import "db/oxirec"
rec_request("stats", Nil)   # => JObj(Cons(Field(engine, JStr(rec)), Cons(Field(cmd, JStr(rec)), Cons(Field(op, JStr(stats)), Nil))))

fn rec_call(fd: Int, op: Str, fields: List(Field)) -> Result(Json, Str)

# not run
import "db/oxirec"
rec_call(fd, "stats", Nil)

fn rec_track(fd: Int, model: Str, basket_id: Int, item_names: List(Str), at: Int) -> Result(Json, Str)

One basket: who it was, what was in it, and when. at is epoch seconds; the server's own clock is used when it is left out, which rec_track_now does.

# not run
import "db/oxirec"
rec_track(fd, "shop", 42, Cons("bread", Cons("butter", Nil)), 1700000000)   # a basket, at a moment in seconds

fn rec_track_now(fd: Int, model: Str, basket_id: Int, item_names: List(Str)) -> Result(Json, Str)

# not run
import "db/oxirec"
rec_track_now(fd, "shop", 43, Cons("tea", Cons("milk", Nil)))

fn rec_related(fd: Int, model: Str, item_name: Str, spec: List(Field)) -> Result(Json, Str)

What turns up beside one item. spec is built with the options below, or Nil for the engine's own defaults.

# not run
import "db/oxirec"
rec_names(rec_related(fd, "shop", "bread", rec_limit(3, rec_scoring("llr", Nil)))?)

fn rec_for_basket(fd: Int, model: Str, item_names: List(Str), spec: List(Field)) -> Result(Json, Str)

What to put beside a basket somebody already has. rec_without keeps what is already in it out of the answer.

# not run
import "db/oxirec"
rec_names(rec_for_basket(fd, "shop", Cons("bread", Cons("tea", Nil)), rec_without(Cons("milk", Nil), Nil))?)

fn rec_stats(fd: Int) -> Result(Json, Str)

# not run
import "db/oxirec"
st = rec_stats(fd)?
rec_baskets(rec_model_stats(st, "shop"))

fn rec_checkpoint(fd: Int) -> Result(Json, Str)

# not run
import "db/oxirec"
rec_checkpoint(fd)

fn rec_limit(n: Int, rest: List(Field)) -> List(Field)

import "db/oxirec"
rec_limit(5, Nil)   # => Cons(Field(limit, JInt(5)), Nil)

fn rec_scoring(name: Str, rest: List(Field)) -> List(Field)

llr — the log-likelihood ratio — asks whether two things turn up together more than chance would have it, rather than merely often.

import "db/oxirec"
rec_scoring("llr", Nil)   # => Cons(Field(scoring, JStr(llr)), Nil)

fn rec_half_life(days: Float, rest: List(Field)) -> List(Field)

import "db/oxirec"
rec_half_life(30.0, Nil)   # => Cons(Field(half_life, JNum(30)), Nil)

fn rec_min_support(n: Float, rest: List(Field)) -> List(Field)

import "db/oxirec"
rec_min_support(2.0, Nil)   # => Cons(Field(min_support, JNum(2)), Nil)

fn rec_without(item_names: List(Str), rest: List(Field)) -> List(Field)

import "db/oxirec"
rec_without(Cons("milk", Nil), Nil)   # => Cons(Field(exclude, JArr(Cons(JStr(milk), Nil))), Nil)

fn rec_at(seconds: Int, rest: List(Field)) -> List(Field)

The moment to score against, in epoch seconds. Without it the server's clock is used, which is what makes old test data answer with nothing.

import "db/oxirec"
rec_at(1700000000, Nil)   # => Cons(Field(ts, JInt(1700000000)), Nil)

fn rec_suggestions(answer: Json) -> List(Json)

import "db/oxirec"
answer = JObj(Cons(Field("recommendations", JArr(Cons(JObj(Cons(Field("item", JStr("butter")), Cons(Field("score", JNum(0.9)), Nil))), Nil))), Nil))
len(rec_suggestions(answer))   # => 1
rec_names(answer)              # => Cons(butter, Nil)

fn rec_item(suggestion: Json) -> Str

import "db/oxirec"
rec_item(JObj(Cons(Field("item", JStr("butter")), Nil)))   # => butter

fn rec_score(suggestion: Json) -> Float

import "db/oxirec"
rec_score(JObj(Cons(Field("score", JNum(0.9)), Nil)))   # => 0.9

fn rec_names(answer: Json) -> List(Str)

import "db/oxirec"
rec_names(JObj(Cons(Field("recommendations", JArr(Nil)), Nil)))   # => Nil

fn rec_counted(answer: Json) -> Bool

import "db/oxirec"
rec_counted(JObj(Cons(Field("counted", JBool(true)), Nil)))   # => true

fn rec_catalogue(answer: Json) -> Int

stats answers about the store as a whole and about each model in it.

import "db/oxirec"
rec_catalogue(JObj(Cons(Field("catalogue_items", JInt(120)), Nil)))   # => 120

fn rec_model_stats(answer: Json, model: Str) -> Json

import "db/oxirec"
st = JObj(Cons(Field("models", JObj(Cons(Field("shop", JObj(Cons(Field("baskets", JInt(10)), Cons(Field("pairs", JInt(40)), Nil)))), Nil))), Nil))
rec_baskets(rec_model_stats(st, "shop"))   # => 10
rec_pairs(rec_model_stats(st, "shop"))     # => 40

fn rec_baskets(model_stats: Json) -> Int

import "db/oxirec"
rec_baskets(JObj(Cons(Field("baskets", JInt(10)), Nil)))   # => 10

fn rec_pairs(model_stats: Json) -> Int

import "db/oxirec"
rec_pairs(JObj(Cons(Field("pairs", JInt(40)), Nil)))   # => 40