formula

type Abs ¶

type Abs uint8

Abs records which parts of a reference are absolute ($A$1). Copying a formula shifts only the relative parts.

const (
	AbsCol Abs = 1 << iota
	AbsRow
)

type Addr ¶

type Addr struct {
	Col, Row int
}

Addr identifies a cell by zero-based column and row.

func ParseAddr(s string) (Addr, bool)

func (a Addr) String() string

func (a Addr) Valid() bool

type Array ¶ added in v0.2.0

type Array struct{ Rows [][]Node }

Array is an array literal, {1,2;3,4}: rows of elements separated by ";", elements by ",". An element may itself be a range or an array, as {A1:A3,B1:B3} joins two columns.

type Binary ¶

type Binary struct {
	Op   string
	L, R Node
}

type Binding ¶ added in v0.2.0

type Binding uint8

Binding is how a function's arguments bind names (Local).

const (
	BindNone Binding = iota
	// BindLet: LET(name1, value1, [name2, value2, ...], expression),
	// each name bound for the arguments after it.
	BindLet
	// BindLambda: LAMBDA([name, ...], expression), the names bound in
	// the expression.
	BindLambda
)

type Bool ¶

type Bool struct{ V bool }

type Call ¶

type Call struct {
	Fn   Func
	Args []Node
}

type Empty ¶

type Empty struct{} // an omitted argument, as in XLOOKUP(a, b, c, , 1)

type Func ¶

type Func interface {
	Signature() Signature
}

Func is a function a formula can call. The parser checks calls against its signature; what a call computes is up to the engine, which recovers its own type from Call.Fn.

type Funcs ¶

type Funcs func(name string) (Func, bool)

Funcs finds a function by its upper-case name or alias.

type Invoke ¶ added in v0.2.0

type Invoke struct {
	Fn   Node
	Args []Node
}

Invoke calls what Fn computes to, a LAMBDA, with Args: LAMBDA(x, x*2)(3), or f(3) where LET bound f to a LAMBDA.

type Local ¶ added in v0.2.0

type Local struct{ Name string }

Local is a name LET or LAMBDA binds, used within that call, as in LET(total, SUM(A:A), total*2). Named ranges never replace it.

type Name ¶

type Name struct{ Name string } // a named range as spelled in the formula

type Node ¶

type Node any

Node is a parsed formula expression: one of the types below.

func Parse(src string, funcs Funcs) (Node, error)

func Rewrite(n Node, rw Rewriter) (Node, bool)

type Num ¶

type Num struct{ V float64 }

type ParseError ¶

type ParseError struct {
	Pos int
	Msg string
	// contains filtered or unexported fields
}

ParseError describes a formula that could not be parsed. Pos is the byte offset in the entry where the problem was found, used to place the edit cursor.

func (e *ParseError) Error() string

type Range ¶

type Range struct {
	Rect  Rect
	Abs   [2]Abs
	Sheet string
}

Range is kept normalized (Rect.From is the top-left corner); Abs holds the absolute markers of Rect.From and Rect.To.

func NewRange(a, b Addr, aAbs, bAbs Abs) Range

type Rect ¶

type Rect struct {
	From, To Addr
}

Rect is an inclusive rectangular range of cells.

func NewRect(a, b Addr) Rect

func ParseRange(s string) (Rect, bool)

func (r Rect) AllCols() bool

func (r Rect) AllRows() bool

func (r Rect) Contains(a Addr) bool

func (r Rect) String() string

type Ref ¶

type Ref struct {
	Addr  Addr
	Abs   Abs
	Sheet string
}

Ref is a cell reference. Sheet is the sheet name as written before the "!" (Sheet2!A1), or "" for the formula's own sheet.

type RefErr ¶

type RefErr struct{} // a reference to deleted cells: #REF!

type Rewriter ¶

type Rewriter struct {
	Ref   func(Ref) Node
	Range func(Range) Node
	Name  func(Name) Node
	Local func(Local) Node
	Table func(TableRef) Node
}

Rewriter maps the references in a formula. Any function may return RefErr; a nil function leaves those nodes alone.

func Relocate(on func(sheet string) bool, cell func(Addr) (Addr, bool), rng func(Rect) (Rect, bool)) Rewriter

func Shift(dc, dr int) Rewriter

type Signature ¶

type Signature struct {
	Name string // canonical, upper case
	Args string // shown to users, e.g. "value1, [value2, ...]"
	Min  int
	Max  int // -1 for variadic
	// Step > 0 means arguments after Min come in groups of Step, like
	// SUMIFS' (range, criterion) pairs.
	Step int
	// Binds says which arguments name values for the rest of the call,
	// as LET's and LAMBDA's do.
	Binds Binding
}

Signature is how a function is called.

type Span ¶

type Span struct{ At, N, Size int }

Span inserts (N > 0) or deletes (N < 0) lines starting at index At, along an axis with Size lines.

func (sp Span) Interval(lo, hi int) (int, int, bool)

func (sp Span) Point(v int) (int, bool)

type Str ¶

type Str struct{ V string }

type TableItems ¶ added in v0.3.0

type TableItems uint8

TableItems are the rows of a table a structured reference names.

const (
	ItemHeaders TableItems = 1 << iota // the header row: [#Headers]
	ItemData                           // the data rows: [#Data], or nothing
	ItemTotals                         // a totals row: [#Totals]
	ItemThisRow                        // the formula's own row: [#This Row] or @
	// ItemAll is the whole table: [#All].
	ItemAll = ItemHeaders | ItemData | ItemTotals
)

type TableRef ¶ added in v0.3.0

type TableRef struct {
	Table string // the table's name as written
	// Items are the rows named; zero means the data rows, as when no
	// item is written.
	Items TableItems
	// From and To are the first and last column named, as written: ""
	// for every column, To "" for From alone.
	From, To string
}

TableRef is a structured reference: Table[Column], Table[#All], Table[@Column], Table[[#Headers],[First]:[Last]].

func (t TableRef) Cols() (string, string)

func (t TableRef) Excel() string

func (t TableRef) Rows() TableItems

func (t TableRef) String() string

type Unary ¶

type Unary struct {
	Op string // "-", "+", "%" (postfix) or "#NOT#"
	X  Node
}