Documentation ¶
Overview ¶
Package starlark provides a Starlark interpreter.
Starlark values are represented by the Value interface. The following built-in Value types are known to the evaluator:
NoneType -- NoneType Bool -- bool Int -- int Float -- float64 String -- string *List -- list Tuple -- tuple *Dict -- dict *Set -- set *Function -- function (implemented in Starlark) *Builtin -- builtin_function_or_method (function or method implemented in Go)
Client applications may define new data types that satisfy at least the Value interface. Such types may provide additional operations by implementing any of these optional interfaces:
Callable -- value is callable like a function Comparable -- value defines its own comparison operations Iterable -- value is iterable using 'for' loops Sequence -- value is iterable sequence of known length Indexable -- value is sequence with efficient random access Mapping -- value maps from keys to values, like a dictionary HasBinary -- value defines binary operations such as * and + HasAttrs -- value has readable fields or methods x.f HasSetField -- value has settable fields x.f HasSetIndex -- value supports element update using x[i]=y HasSetKey -- value supports map update using x[k]=v
Client applications may also define domain-specific functions in Go and make them available to Starlark programs. Use NewBuiltin to construct a built-in value that wraps a Go function. The implementation of the Go function may use UnpackArgs to make sense of the positional and keyword arguments provided by the caller.
Starlark's None value is not equal to Go's nil, but nil may be assigned to a Starlark Value. Be careful to avoid allowing Go nil values to leak into Starlark data structures.
The Compare operation requires two arguments of the same type, but this constraint cannot be expressed in Go's type system. (This is the classic "binary method problem".) So, each Value type's CompareSameType method is a partial function that compares a value only against others of the same type. Use the package's standalone Compare (or Equal) function to compare an arbitrary pair of values.
To parse and evaluate a Starlark source file, use ExecFile. The Eval function evaluates a single expression. All evaluator functions require a Thread parameter which defines the "thread-local storage" of a Starlark thread and may be used to plumb application state through Sklyark code and into callbacks. When evaluation fails it returns an EvalError from which the application may obtain a backtrace of active Starlark calls.
Index ¶
- Constants
- Variables
- func AsFloat(x Value) (f float64, ok bool)
- func AsInt32(x Value) (int, error)
- func AsString(x Value) (string, bool)
- func Compare(op syntax.Token, x, y Value) (bool, error)
- func CompareDepth(op syntax.Token, x, y Value, depth int) (bool, error)
- func Equal(x, y Value) (bool, error)
- func EqualDepth(x, y Value, depth int) (bool, error)
- func GenericAsString(x interface{}) (string, bool)
- func Len(x Value) int
- func UnpackArgs(fnname string, args Tuple, kwargs []Tuple, pairs ...interface{}) error
- func UnpackPositionalArgs(fnname string, args Tuple, kwargs []Tuple, min int, vars ...interface{}) error
- type Bool
- type Builtin
- func (b *Builtin) BindReceiver(recv Value) *Builtin
- func (b *Builtin) CallInternal(thread *Thread, args Tuple, kwargs []Tuple) (Value, error)
- func (b *Builtin) Freeze()
- func (b *Builtin) Hash() (uint32, error)
- func (b *Builtin) Name() string
- func (b *Builtin) Receiver() Value
- func (b *Builtin) String() string
- func (b *Builtin) Truth() Bool
- func (b *Builtin) Type() string
- type Callable
- type Comparable
- type Complex128
- type Dict
- func (d *Dict) Attr(name string) (Value, error)
- func (d *Dict) AttrNames() []string
- func (d *Dict) Clear() error
- func (x *Dict) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (d *Dict) Delete(k Value) (v Value, found bool, err error)
- func (d *Dict) Freeze()
- func (d *Dict) Get(k Value) (v Value, found bool, err error)
- func (d *Dict) Hash() (uint32, error)
- func (d *Dict) Items() []Tuple
- func (d *Dict) Iterate() Iterator
- func (d *Dict) Keys() []Value
- func (d *Dict) Len() int
- func (d *Dict) SetKey(k, v Value) error
- func (d *Dict) String() string
- func (d *Dict) Truth() Bool
- func (d *Dict) Type() string
- type EvalError
- type Float
- type Frame
- type Function
- func (fn *Function) CallInternal(thread *Thread, args Tuple, kwargs []Tuple) (Value, error)
- func (fn *Function) Doc() string
- func (fn *Function) Freeze()
- func (fn *Function) Globals() *StringDict
- func (fn *Function) HasKwargs() bool
- func (fn *Function) HasVarargs() bool
- func (fn *Function) Hash() (uint32, error)
- func (fn *Function) Name() string
- func (fn *Function) NumKwonlyParams() int
- func (fn *Function) NumParams() int
- func (fn *Function) Param(i int) (string, syntax.Position)
- func (fn *Function) Position() syntax.Position
- func (fn *Function) String() string
- func (fn *Function) Truth() Bool
- func (fn *Function) Type() string
- type HasAttrs
- type HasBinary
- type HasSetField
- type HasSetIndex
- type HasSetKey
- type Indexable
- type Int
- func (x Int) Add(y Int) Int
- func (x Int) And(y Int) Int
- func (x Int) CompareSameType(op syntax.Token, y Value, depth int) (bool, error)
- func (x Int) Div(y Int) Int
- func (i Int) Float() Float
- func (i Int) Freeze()
- func (i Int) Hash() (uint32, error)
- func (i Int) Int64() (_ int64, ok bool)
- func (x Int) Lsh(y uint) Int
- func (x Int) Mod(y Int) Int
- func (x Int) Mul(y Int) Int
- func (x Int) Not() Int
- func (x Int) Or(y Int) Int
- func (x Int) Rsh(y uint) Int
- func (x Int) Sign() int
- func (i Int) String() string
- func (x Int) Sub(y Int) Int
- func (i Int) Truth() Bool
- func (i Int) Type() string
- func (i Int) Uint64() (_ uint64, ok bool)
- func (x Int) Xor(y Int) Int
- type Iterable
- type Iterator
- type List
- func (l *List) Append(v Value) error
- func (l *List) Attr(name string) (Value, error)
- func (l *List) AttrNames() []string
- func (l *List) Clear() error
- func (x *List) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (l *List) Freeze()
- func (l *List) Hash() (uint32, error)
- func (l *List) Index(i int) Value
- func (l *List) Iterate() Iterator
- func (l *List) Len() int
- func (l *List) SetIndex(i int, v Value) error
- func (l *List) Slice(start, end, step int) Value
- func (l *List) String() string
- func (l *List) Truth() Bool
- func (l *List) Type() string
- type Mapping
- type NoneType
- type Program
- func (prog *Program) Filename() string
- func (prog *Program) Init(thread *Thread, predeclared *StringDict) (*StringDict, error)
- func (prog *Program) Load(i int) (string, syntax.Position)
- func (prog *Program) NumLoads() int
- func (prog *Program) String() string
- func (prog *Program) Write(out io.Writer) error
- type Sequence
- type Set
- func (s *Set) Attr(name string) (Value, error)
- func (s *Set) AttrNames() []string
- func (s *Set) Clear() error
- func (x *Set) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (s *Set) Delete(k Value) (found bool, err error)
- func (s *Set) Freeze()
- func (s *Set) Has(k Value) (found bool, err error)
- func (s *Set) Hash() (uint32, error)
- func (s *Set) Insert(k Value) error
- func (s *Set) Iterate() Iterator
- func (s *Set) Len() int
- func (s *Set) String() string
- func (s *Set) Truth() Bool
- func (s *Set) Type() string
- func (s *Set) Union(iter Iterator) (Value, error)
- type Side
- type Sliceable
- type String
- func (s String) Attr(name string) (Value, error)
- func (s String) AttrNames() []string
- func (x String) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (s String) Freeze()
- func (s String) GoString() string
- func (s String) Hash() (uint32, error)
- func (s String) Index(i int) Value
- func (s String) Len() int
- func (s String) Slice(start, end, step int) Value
- func (s String) String() string
- func (s String) Truth() Bool
- func (s String) Type() string
- type StringDict
- func (d StringDict) Attr(name string) (Value, error)
- func (d StringDict) AttrNames() []string
- func (d *StringDict) Freeze()
- func (d StringDict) Get(key Value) (v Value, found bool, err error)
- func (d StringDict) Has(key string) bool
- func (d StringDict) Hash() (uint32, error)
- func (d *StringDict) SetField(name string, val Value) error
- func (d *StringDict) String() string
- func (d StringDict) Truth() Bool
- func (d StringDict) Type() string
- type Struct
- func (s *Struct) Attr(name string) (Value, error)
- func (s *Struct) AttrNames() []string
- func (x *Struct) Binary(op syntax.Token, y Value, side Side) (Value, error)
- func (x *Struct) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (s *Struct) Constructor() Value
- func (s *Struct) Freeze()
- func (s *Struct) Hash() (uint32, error)
- func (s *Struct) SetField(name string, val Value) error
- func (s *Struct) String() string
- func (s *Struct) ToStringDict(d StringDict)
- func (s *Struct) Truth() Bool
- func (s *Struct) Type() string
- func (s *Struct) Upsert(key Value, val Value) error
- type Thread
- type ToValueFunc
- type Tuple
- func (x Tuple) CompareSameType(op syntax.Token, y_ Value, depth int) (bool, error)
- func (t Tuple) Freeze()
- func (t Tuple) Hash() (uint32, error)
- func (t Tuple) Index(i int) Value
- func (t Tuple) Iterate() Iterator
- func (t Tuple) Len() int
- func (t Tuple) Slice(start, end, step int) Value
- func (t Tuple) String() string
- func (t Tuple) Truth() Bool
- func (t Tuple) Type() string
- type Value
- func Binary(op syntax.Token, x, y Value) (Value, error)
- func Call(thread *Thread, fn Value, args Tuple, kwargs []Tuple) (Value, error)
- func Eval(thread *Thread, filename string, src interface{}, env *StringDict) (Value, error)
- func EvalExpr(thread *Thread, filename string, expr syntax.Expr, env *StringDict) (Value, error)
- func StructMake(_ *Thread, _ *Builtin, args Tuple, kwargs []Tuple) (Value, error)
- func Unary(op syntax.Token, x Value) (Value, error)
Examples ¶
Constants ¶
const CompilerVersion = compile.Version
CompilerVersion is the version number of the protocol for compiled files. Applications must not run programs compiled by one version with an interpreter at another version, and should thus incorporate the compiler version into the cache key when reusing compiled code.
const Default = "struct"
Default is the default constructor for structs. It is merely the string "struct".
const None = NoneType(0)
Variables ¶
var Natives map[string]func() interface{}
Functions ¶
func AsFloat ¶
AsFloat returns the float64 value closest to x. The f result is undefined if x is not a float or int.
func Compare ¶
Compare compares two Starlark values. The comparison operation must be one of EQL, NEQ, LT, LE, GT, or GE. Compare returns an error if an ordered comparison was requested for a type that does not support it.
Recursive comparisons by implementations of Value.CompareSameType should use CompareDepth to prevent infinite recursion.
func CompareDepth ¶
CompareDepth compares two Starlark values. The comparison operation must be one of EQL, NEQ, LT, LE, GT, or GE. CompareDepth returns an error if an ordered comparison was requested for a pair of values that do not support it.
The depth parameter limits the maximum depth of recursion in cyclic data structures.
func EqualDepth ¶
EqualDepth reports whether two Starlark values are equal.
Recursive comparisons by implementations of Value.CompareSameType should use EqualDepth to prevent infinite recursion.
func GenericAsString ¶
GenericAsString handles converting []byte -> string
func Len ¶
Len returns the length of a string or sequence value, and -1 for all others.
Warning: Len(x) >= 0 does not imply Iterate(x) != nil. A string has a known length but is not directly iterable.
func UnpackArgs ¶
UnpackArgs unpacks the positional and keyword arguments into the supplied parameter variables. pairs is an alternating list of names and pointers to variables.
If the variable is a bool, int, string, *List, *Dict, Callable, Iterable, or user-defined implementation of Value, UnpackArgs performs the appropriate type check. (An int uses the AsInt32 check.) If the parameter name ends with "?", it and all following parameters are optional.
If the variable implements Value, UnpackArgs may call its Type() method while constructing the error message.
Beware: an optional *List, *Dict, Callable, Iterable, or Value variable that is not assigned is not a valid Starlark Value, so the caller must explicitly handle such cases by interpreting nil as None or some computed default.
func UnpackPositionalArgs ¶
func UnpackPositionalArgs(fnname string, args Tuple, kwargs []Tuple, min int, vars ...interface{}) error
UnpackPositionalArgs unpacks the positional arguments into corresponding variables. Each element of vars is a pointer; see UnpackArgs for allowed types and conversions.
UnpackPositionalArgs reports an error if the number of arguments is less than min or greater than len(vars), if kwargs is nonempty, or if any conversion fails.
Types ¶
type Builtin ¶
type Builtin struct {
// contains filtered or unexported fields
}
A Builtin is a function implemented in Go.
func NewBuiltin ¶
func NewBuiltin(name string, fn func(thread *Thread, fn *Builtin, args Tuple, kwargs []Tuple) (Value, error)) *Builtin
NewBuiltin returns a new 'builtin_function_or_method' value with the specified name and implementation. It compares unequal with all other values.
func (*Builtin) BindReceiver ¶
BindReceiver returns a new Builtin value representing a method closure, that is, a built-in function bound to a receiver value.
In the example below, the value of f is the string.index built-in method bound to the receiver value "abc":
f = "abc".index; f("a"); f("b")
In the common case, the receiver is bound only during the call, but this still results in the creation of a temporary method closure:
"abc".index("a")
func (*Builtin) CallInternal ¶
type Callable ¶
type Callable interface { Value Name() string CallInternal(thread *Thread, args Tuple, kwargs []Tuple) (Value, error) }
A Callable value f may be the operand of a function call, f(x).
Clients should use the Call function, never the CallInternal method.
type Comparable ¶
type Comparable interface { Value // CompareSameType compares one value to another of the same Type(). // The comparison operation must be one of EQL, NEQ, LT, LE, GT, or GE. // CompareSameType returns an error if an ordered comparison was // requested for a type that does not support it. // // Implementations that recursively compare subcomponents of // the value should use the CompareDepth function, not Compare, to // avoid infinite recursion on cyclic structures. // // The depth parameter is used to bound comparisons of cyclic // data structures. Implementations should decrement depth // before calling CompareDepth and should return an error if depth // < 1. // // Client code should not call this method. Instead, use the // standalone Compare or Equals functions, which are defined for // all pairs of operands. CompareSameType(op syntax.Token, y Value, depth int) (bool, error) }
A Comparable is a value that defines its own equivalence relation and perhaps ordered comparisons.
type Complex128 ¶
type Complex128 complex128
Complex128 is the type of a Starlark complex number
func (Complex128) Freeze ¶
func (f Complex128) Freeze()
func (Complex128) Hash ¶
func (f Complex128) Hash() (uint32, error)
func (Complex128) String ¶
func (f Complex128) String() string
func (Complex128) Truth ¶
func (f Complex128) Truth() Bool
func (Complex128) Type ¶
func (f Complex128) Type() string
type Dict ¶
type Dict struct { StructName string // contains filtered or unexported fields }
A *Dict represents a Starlark dictionary.
func (*Dict) CompareSameType ¶
type EvalError ¶
An EvalError is a Starlark evaluation error and its associated call stack.
type Float ¶
type Float float64
Float is the type of a Starlark float.
func (Float) CompareSameType ¶
type Frame ¶
type Frame struct {
// contains filtered or unexported fields
}
A Frame records a call to a Starlark function (including module toplevel) or a built-in function or method.
func (*Frame) Local ¶
Local returns the value of the i'th local variable. It may be nil if not yet assigned.
Local may be called only for frames whose Callable is a *Function (a function defined by Starlark source code), and only while the frame is active; it will panic otherwise.
This function is provided only for debugging tools.
THIS API IS EXPERIMENTAL AND MAY CHANGE WITHOUT NOTICE.
func (*Frame) Position ¶
Position returns the source position of the current point of execution in this frame.
func (*Frame) WriteBacktrace ¶
WriteBacktrace writes a user-friendly description of the stack to buf.
type Function ¶
type Function struct {
// contains filtered or unexported fields
}
A Function is a function defined by a Starlark def statement or lambda expression. The initialization behavior of a Starlark module is also represented by a Function.
func ExprFunc ¶
func ExprFunc(filename string, src interface{}, env *StringDict) (*Function, error)
ExprFunc returns a no-argument function that evaluates the expression whose source is src.
func (*Function) CallInternal ¶
func (*Function) Globals ¶
func (fn *Function) Globals() *StringDict
Globals returns a new, unfrozen StringDict containing all global variables so far defined in the function's module.
func (*Function) HasVarargs ¶
func (*Function) NumKwonlyParams ¶
type HasAttrs ¶
type HasAttrs interface { Value Attr(name string) (Value, error) // returns (nil, nil) if attribute not present AttrNames() []string // callers must not modify the result. }
A HasAttrs value has fields or methods that may be read by a dot expression (y = x.f). Attribute names may be listed using the built-in 'dir' function.
For implementation convenience, a result of (nil, nil) from Attr is interpreted as a "no such field or method" error. Implementations are free to return a more precise error.
type HasBinary ¶
A HasBinary value may be used as either operand of these binary operators:
- - * / % in not in | &
The Side argument indicates whether the receiver is the left or right operand.
An implementation may decline to handle an operation by returning (nil, nil). For this reason, clients should always call the standalone Binary(op, x, y) function rather than calling the method directly.
type HasSetField ¶
A HasSetField value has fields that may be written by a dot expression (x.f = y).
type HasSetIndex ¶
A HasSetIndex is an Indexable value whose elements may be assigned (x[i] = y).
The implementation should not add Len to a negative index as the evaluator does this before the call.
type Indexable ¶
An Indexable is a sequence of known length that supports efficient random access. It is not necessarily iterable.
type Int ¶
type Int struct {
// contains filtered or unexported fields
}
Int is the type of a Starlark int.
func MakeUint64 ¶
MakeUint64 returns a Starlark int for the specified uint64.
func NumberToInt ¶
NumberToInt converts a number x to an integer value. An int is returned unchanged, a float is truncated towards zero. NumberToInt reports an error for all other values.
func (Int) CompareSameType ¶
func (Int) Int64 ¶
Int64 returns the value as an int64. If it is not exactly representable the result is undefined and ok is false.
type Iterable ¶
An Iterable abstracts a sequence of values. An iterable value may be iterated over by a 'for' loop or used where any other Starlark iterable is allowed. Unlike a Sequence, the length of an Iterable is not necessarily known in advance of iteration.
type Iterator ¶
type Iterator interface { // If the iterator is exhausted, Next returns false. // Otherwise it sets *p to the current element of the sequence, // advances the iterator, and returns true. Next(p *Value) bool Done() }
An Iterator provides a sequence of values to the caller.
The caller must call Done when the iterator is no longer needed. Operations that modify a sequence will fail if it has active iterators.
Example usage:
iter := iterable.Iterator() defer iter.Done() var x Value for iter.Next(&x) { ... }
type List ¶
type List struct {
// contains filtered or unexported fields
}
A *List represents a Starlark list value.
func NewList ¶
NewList returns a list containing the specified elements. Callers should not subsequently modify elems.
func (*List) CompareSameType ¶
type Mapping ¶
type Mapping interface { Value // Get returns the value corresponding to the specified key, // or !found if the mapping does not contain the key. // // Get also defines the behavior of "v in mapping". // The 'in' operator reports the 'found' component, ignoring errors. Get(Value) (v Value, found bool, err error) }
A Mapping is a mapping from keys to values, such as a dictionary.
type NoneType ¶
type NoneType byte
NoneType is the type of None. Its only legal value is None. (We represent it as a number, not struct{}, so that None may be constant.)
func (NoneType) CompareSameType ¶
type Program ¶
type Program struct {
// contains filtered or unexported fields
}
A Program is a compiled Starlark program.
Programs are immutable, and contain no Values. A Program may be created by parsing a source file (see SourceProgram) or by loading a previously saved compiled program (see CompiledProgram).
func CompiledProgram ¶
CompiledProgram produces a new program from the representation of a compiled program previously saved by Program.Write.
func SourceProgram ¶
func SourceProgram(filename string, src interface{}, isPredeclared func(string) bool) (*syntax.File, *Program, error)
SourceProgram produces a new program by parsing, resolving, and compiling a Starlark source file. On success, it returns the parsed file and the compiled program. The filename and src parameters are as for syntax.Parse.
The isPredeclared predicate reports whether a name is a pre-declared identifier of the current module. Its typical value is predeclared.Has, where predeclared is a StringDict of pre-declared values.
func (*Program) Filename ¶
Filename returns the name of the file from which this program was loaded.
func (*Program) Init ¶
func (prog *Program) Init(thread *Thread, predeclared *StringDict) (*StringDict, error)
Init creates a set of global variables for the program, executes the toplevel code of the specified program, and returns a new, unfrozen dictionary of the globals.
func (*Program) Load ¶
Load(i) returns the name and position of the i'th module directly loaded by this one, where 0 <= i < NumLoads(). The name is unresolved---exactly as it appears in the source.
type Set ¶
type Set struct {
// contains filtered or unexported fields
}
A Set represents a Starlark set value.
func (*Set) CompareSameType ¶
type Sliceable ¶
type Sliceable interface { Indexable // For positive strides (step > 0), 0 <= start <= end <= n. // For negative strides (step < 0), -1 <= end <= start < n. // The caller must ensure that the start and end indices are valid. Slice(start, end, step int) Value }
A Sliceable is a sequence that can be cut into pieces with the slice operator (x[i:j:step]).
All native indexable objects are sliceable. This is a separate interface for backwards-compatibility.
type String ¶
type String string
String is the type of a Starlark string.
A String encapsulates an an immutable sequence of bytes, but strings are not directly iterable. Instead, iterate over the result of calling one of these four methods: codepoints, codepoint_ords, elems, elem_ords.
Warning: the contract of the Value interface's String method is that it returns the value printed in Starlark notation, so s.String() or fmt.Sprintf("%s", s) returns a quoted string. Use string(s) or s.GoString() or fmt.Sprintf("%#v", s) to obtain the raw contents of a Starlark string as a Go string.
func (String) CompareSameType ¶
type StringDict ¶
A StringDict is a mapping from names to values, and represents an environment such as the global variables of a module. It is now also a true starlark.Value. StringDict is currently used to represent packages at the REPL. This may change in the future.
var Universe *StringDict
Universe defines the set of universal built-ins, such as None, True, and len.
The Go application may add or remove items from the universe dictionary before Starlark evaluation begins. All values in the dictionary must be immutable. Starlark programs cannot modify the dictionary.
func ExecFile ¶
func ExecFile(thread *Thread, filename string, src interface{}, predeclared *StringDict) (*StringDict, error)
ExecFile parses, resolves, and executes a Starlark file in the specified global environment, which may be modified during execution.
Thread is the state associated with the Starlark thread.
The filename and src parameters are as for syntax.Parse: filename is the name of the file to execute, and the name that appears in error messages; src is an optional source of bytes to use instead of filename.
predeclared defines the predeclared names specific to this module. Execution does not modify this dictionary, though it may mutate its values.
If ExecFile fails during evaluation, it returns an *EvalError containing a backtrace.
Example ¶
ExampleExecFile demonstrates a simple embedding of the Starlark interpreter into a Go program.
package main import ( "fmt" "log" "sort" "github.com/glycerine/monty/starlark" ) func main() { const data = ` print(greeting + ", world") squares = [x*x for x in range(10)] ` thread := &starlark.Thread{ Name: "example", Print: func(_ *starlark.Thread, msg string) { fmt.Println(msg) }, } predeclared := &starlark.StringDict{ Map: map[string]starlark.Value{ "greeting": starlark.String("hello"), }, Immut: map[string]bool{}, } globals, err := starlark.ExecFile(thread, "apparent/filename.star", data, predeclared) if err != nil { if evalErr, ok := err.(*starlark.EvalError); ok { log.Fatal(evalErr.Backtrace()) } log.Fatal(err) } // Print the global environment. var names []string for name := range globals.Map { names = append(names, name) } sort.Strings(names) fmt.Println("\nGlobals:") for _, name := range names { v := globals.Map[name] fmt.Printf("%s (%s) = %s\n", name, v.Type(), v.String()) } }
Output: hello, world Globals: squares (list) = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
func NewStringDict ¶
func NewStringDict(n int) *StringDict
func NewStringDictWith ¶
func NewStringDictWith(kvpair ...interface{}) *StringDict
func (StringDict) Attr ¶
func (d StringDict) Attr(name string) (Value, error)
Attr looks up name and returns (nil, nil) if the name attribute is not present.
func (StringDict) AttrNames ¶
func (d StringDict) AttrNames() []string
AttrNames returns all keys in d.
func (StringDict) Get ¶
func (d StringDict) Get(key Value) (v Value, found bool, err error)
Get searches d for key.
func (StringDict) Has ¶
func (d StringDict) Has(key string) bool
Has reports whether the dictionary contains the specified key.
func (StringDict) Hash ¶
func (d StringDict) Hash() (uint32, error)
Hash will return an error for StringDict, but is needed to fullfil the Value interface.
func (*StringDict) String ¶
func (d *StringDict) String() string
String packs the keys and stingified values of d in a human readable string.
func (StringDict) Truth ¶
func (d StringDict) Truth() Bool
Truth will return true if and only if d holds at least one key.
func (StringDict) Type ¶
func (d StringDict) Type() string
type Struct ¶
type Struct struct { Ctor string Fields []field // insertion order Map map[string]int // INVAR: fields[Map[field]] == field }
Struct is an immutable Starlark type that maps field names to values. It is not iterable and does not support len.
A struct has a constructor, a distinct value that identifies a class of structs, and which appears in the struct's string representation.
Operations such as x+y fail if the constructors of the two operands are not equal.
The default constructor, Default, is the string "struct", but clients may wish to 'brand' structs for their own purposes. The constructor value appears in the printed form of the value, and is accessible using the Constructor method.
Use Attr to access its fields and AttrNames to enumerate them.
func FromStringDict ¶
func FromStringDict(constructor Value, d *StringDict) *Struct
FromStringDict returns a whose elements are those of d. The constructor parameter specifies the constructor; use Default for an ordinary struct.
func StructFromKeywords ¶
FromKeywords returns a new struct instance whose fields are specified by the key/value pairs in kwargs. (Each kwargs[i][0] must be a starlark.String.)
func (*Struct) Attr ¶
Attr returns the value of the specified field, or deprecated method if the name is "to_json" or "to_proto" and the struct has no field of that name.
func (*Struct) AttrNames ¶
AttrNames returns a new sorted list of the struct fields.
Unlike in the Java implementation, the deprecated struct methods "to_json" and "to_proto" do not appear in AttrNames, and hence dir(struct), since that would force the majority to have to ignore them, but they may nonetheless be called if the struct does not have fields of these names. Ideally these will go away soon. See Google issue b/36412967.
func (*Struct) CompareSameType ¶
func (*Struct) Constructor ¶
Constructor returns the constructor used to create this struct.
func (*Struct) SetField ¶
SetField is required for the HasSetField interface. This means we have fields that may be written by a dot expression such as "x.f = y".
func (*Struct) ToStringDict ¶
func (s *Struct) ToStringDict(d StringDict)
ToStringDict adds a name/value field to d for each field of the struct.
type Thread ¶
type Thread struct { // Name is an optional name that describes the thread, for debugging. Name string // Print is the client-supplied implementation of the Starlark // 'print' function. If nil, fmt.Fprintln(os.Stderr, msg) is // used instead. Print func(thread *Thread, msg string) // Load is the client-supplied implementation of module loading. // Repeated calls with the same module name must return the same // module environment or error. // The error message need not include the module name. // // See example_test.go for some example implementations of Load. Load func(thread *Thread, module string) (*StringDict, error) // contains filtered or unexported fields }
A Thread contains the state of a Starlark thread, such as its call stack and thread-local storage. The Thread is threaded throughout the evaluator.
func (*Thread) Caller ¶
Caller returns the frame of the caller of the current function. It should only be used in built-ins called from Starlark code.
type ToValueFunc ¶
repl will set this to convert.ToValue, to avoid compile time cycle.
var ToValue ToValueFunc
type Tuple ¶
type Tuple []Value
A Tuple represents a Starlark tuple value.
func (Tuple) CompareSameType ¶
type Value ¶
type Value interface { // String returns the string representation of the value. // Starlark string values are quoted as if by Python's repr. String() string // Type returns a short string describing the value's type. Type() string // Freeze causes the value, and all values transitively // reachable from it through collections and closures, to be // marked as frozen. All subsequent mutations to the data // structure through this API will fail dynamically, making the // data structure immutable and safe for publishing to other // Starlark interpreters running concurrently. Freeze() // Truth returns the truth value of an object. Truth() Bool // Hash returns a function of x such that Equals(x, y) => Hash(x) == Hash(y). // Hash may fail if the value's type is not hashable, or if the value // contains a non-hashable value. Hash() (uint32, error) }
Value is a value in the Starlark interpreter.
func Binary ¶
Binary applies a strict binary operator (not AND or OR) to its operands. For equality tests or ordered comparisons, use Compare instead.
func Eval ¶
func Eval(thread *Thread, filename string, src interface{}, env *StringDict) (Value, error)
Eval parses, resolves, and evaluates an expression within the specified (predeclared) environment.
Evaluation cannot mutate the environment dictionary itself, though it may modify variables reachable from the dictionary.
The filename and src parameters are as for syntax.Parse.
If Eval fails during evaluation, it returns an *EvalError containing a backtrace.
func EvalExpr ¶
EvalExpr is like Eval but expr is provided directly, avoiding a second ParseExp() call.
func StructMake ¶
Make is the implementation of a built-in function that instantiates an immutable struct from the specified keyword arguments.
An application can add 'struct' to the Starlark environment like so:
globals := starlark.StringDict{ "struct": starlark.NewBuiltin("struct", starlarkstruct.Make), }