functions

type Addr = formula.Addr

type Agg struct {
	// contains filtered or unexported fields
}

type Array struct {
	Rows, Cols   int
	DRows, DCols int
	V            []Value
	Fill         Value
}

type Book interface {
	// Cell is the current value of a cell, evaluated first if it's
	// dirty; #REF! on a sheet that doesn't exist.
	Cell(sheet string, a Addr) Value
	// Scan reads the cells of r that hold something, row by row, from
	// the cell from on (those before it in that order are skipped): their
	// addresses into addrs and, unless vals is nil, their values into
	// vals, evaluating them as Cell does. It stops when addrs is full or
	// just after a value that is an error, so no cell past the first
	// error is evaluated, and returns how many it read: -1 when the sheet
	// doesn't exist.
	Scan(sheet string, r Rect, from Addr, addrs []Addr, vals []Value) int
	// Bounds is the smallest range holding every stored cell of r, with
	// false if r holds none; exists is false when the sheet doesn't.
	Bounds(sheet string, r Rect) (b Rect, any, exists bool)
	// RangeAgg is the aggregate of r that SUM-like functions share within
	// a recalculation (see Agg), with the first error in it, or false
	// when r should be read directly.
	RangeAgg(sheet string, r Rect) (Agg, *Value, bool)
	// Fold adds the cells of r that hold something to s, row by row, as
	// SUM-like functions read a range (Agg.Add), evaluating them as Cell
	// does and stopping at the first error, which it returns. On a sheet
	// that doesn't exist the range is one #REF!.
	Fold(sheet string, r Rect, s Agg) (Agg, *Value)
	// Ask looks up the answer to a remote question (JEV functions). The
	// value is an error when there is none to give: Pending while it is
	// on its way, ErrNoRemote when nothing answers them.
	Ask(call RemoteCall) (RemoteAnswer, Value)
	// Paged reports whether the sheet is a paged source (stream.go),
	// whose ranges a function is given through Stream.
	Paged(sheet string) bool
	// Stream answers a call over paged sources, with an array when it
	// computes several values: Pending while the answer is on its way.
	Stream(call StreamCall) (Value, *Array)
}

type Format = value.Format

type FuncDef struct {
	Name string
	Args string // signature shown to users, e.g. "value1, [value2, ...]"
	Desc string
	Min  int
	Max  int // -1 for variadic

	// Volatile functions (TODAY, NOW, RAND) change without their inputs
	// changing, so every recalculation recomputes them.
	Volatile bool
	// contains filtered or unexported fields
}

type Node = formula.Node

type Part struct {
	Value Value
	// Array holds the first rows and columns of an array the part
	// computed, with Rows and Cols its whole size; nil otherwise.
	Array *Array
	// Lambda is set when the part computed a LAMBDA.
	Lambda bool
	// Reached is false for a part the formula never computed.
	Reached bool
}

type Reader struct {
	// contains filtered or unexported fields
}

type Rect = formula.Rect

type RemoteAnswer struct {
	Noul       float64 // probability of yes
	Choice     string
	Score      float64
	Confidence float64 // in Choice or Score, not a probability of truth
	Failed     string
}

type RemoteCall struct {
	Kind         string `json:"kind"` // "noul", "choice" or "score"
	State        any    `json:"state"`
	Instructions string `json:"instructions"`
	// Criteria depends on Kind: noul is [2]string{yes, no} (either may be
	// empty), choice is map[label]description, score is []string levels.
	Criteria any `json:"criteria"`
}

type RemoteSource interface {
	Lookup(RemoteCall) (RemoteAnswer, bool)
}

type StreamAnswer struct {
	V   Value
	A   *Array
	Why string
}

type StreamArg struct {
	Sheet string
	R     Rect
	V     Value
}

type StreamCall struct {
	Fn string
	// Dec is set when the call is computed in decimal (decimal.go).
	Dec  bool
	Args []StreamArg
}

type Value = value.Value