Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

grumpy

package

Go to main page

Versions in this module

v0

v0.3.0

Jul 24, 2018

v0.2.2

Jul 10, 2018

v0.2.1

Jul 7, 2018

v0.2.0

Jun 23, 2018

v0.1.8

May 22, 2018

v0.1.7

May 22, 2018

v0.1.6

May 21, 2018

Changes in this version

+ const EncodeDefault

+ const EncodeIgnore

+ const EncodeReplace

+ const EncodeStrict

+ const MaxInt

+ const MinInt

+ var ArithmeticErrorType = newSimpleType("ArithmeticError", StandardErrorType)

+ var AssertionErrorType = newSimpleType("AssertionError", StandardErrorType)

+ var AttributeErrorType = newSimpleType("AttributeError", StandardErrorType)

+ var BaseExceptionType = newBasisType("BaseException", reflect.TypeOf(BaseException{}), toBaseExceptionUnsafe, ...)

+ var BaseStringType = newSimpleType("basestring", ObjectType)

+ var BoolType = newSimpleType("bool", IntType)

+ var Builtins = NewDict()

+ var ByteArrayType = newBasisType("bytearray", reflect.TypeOf(ByteArray{}), toByteArrayUnsafe, ObjectType)

+ var BytesWarningType = newSimpleType("BytesWarning", WarningType)

+ var ClassMethodType = newBasisType("classmethod", reflect.TypeOf(classMethod{}), toClassMethodUnsafe, ObjectType)

+ var CodeType = newBasisType("code", reflect.TypeOf(Code{}), toCodeUnsafe, ObjectType)

+ var ComplexType = newBasisType("complex", reflect.TypeOf(Complex{}), toComplexUnsafe, ObjectType)

+ var DeprecationWarningType = newSimpleType("DeprecationWarning", WarningType)

+ var DictType = newBasisType("dict", reflect.TypeOf(Dict{}), toDictUnsafe, ObjectType)

+ var EOFErrorType = newSimpleType("EOFError", StandardErrorType)

+ var Ellipsis = &Object

+ var EllipsisType = newSimpleType("ellipsis", ObjectType)

+ var EnvironmentErrorType = newSimpleType("EnvironmentError", StandardErrorType)

+ var ExceptionType = newSimpleType("Exception", BaseExceptionType)

+ var ExceptionTypes []*Type

+ var False = &Int

+ var FileType = newBasisType("file", reflect.TypeOf(File{}), toFileUnsafe, ObjectType)

+ var FloatType = newBasisType("float", reflect.TypeOf(Float{}), toFloatUnsafe, ObjectType)

+ var FrameType = newBasisType("frame", reflect.TypeOf(Frame{}), toFrameUnsafe, ObjectType)

+ var FrozenSetType = newBasisType("frozenset", reflect.TypeOf(FrozenSet{}), toFrozenSetUnsafe, ObjectType)

+ var FunctionType = newBasisType("function", reflect.TypeOf(Function{}), toFunctionUnsafe, ObjectType)

+ var FutureWarningType = newSimpleType("FutureWarning", WarningType)

+ var GeneratorType = newBasisType("generator", reflect.TypeOf(Generator{}), toGeneratorUnsafe, ObjectType)

+ var IOErrorType = newSimpleType("IOError", EnvironmentErrorType)

+ var ImportErrorType = newSimpleType("ImportError", StandardErrorType)

+ var ImportWarningType = newSimpleType("ImportWarning", WarningType)

+ var IndexErrorType = newSimpleType("IndexError", LookupErrorType)

+ var IntType = newBasisType("int", reflect.TypeOf(Int{}), toIntUnsafe, ObjectType)

+ var KeyErrorType = newSimpleType("KeyError", LookupErrorType)

+ var KeyboardInterruptType = newSimpleType("KeyboardInterrupt", BaseExceptionType)

+ var ListType = newBasisType("list", reflect.TypeOf(List{}), toListUnsafe, ObjectType)

+ var LongType = newBasisType("long", reflect.TypeOf(Long{}), toLongUnsafe, ObjectType)

+ var LookupErrorType = newSimpleType("LookupError", StandardErrorType)

+ var MemoryErrorType = newSimpleType("MemoryError", StandardErrorType)

+ var MethodType = newBasisType("instancemethod", reflect.TypeOf(Method{}), toMethodUnsafe, ObjectType)

+ var ModuleType = newBasisType("module", reflect.TypeOf(Module{}), toModuleUnsafe, ObjectType)

+ var NameErrorType = newSimpleType("NameError", StandardErrorType)

+ var None = &Object

+ var NoneType = newSimpleType("NoneType", ObjectType)

+ var NotImplemented = newObject(NotImplementedType)

+ var NotImplementedErrorType = newSimpleType("NotImplementedError", RuntimeErrorType)

+ var NotImplementedType = newSimpleType("NotImplementedType", ObjectType)

+ var OSErrorType = newSimpleType("OSError", EnvironmentErrorType)

+ var ObjectType = &Type

+ var OverflowErrorType = newSimpleType("OverflowError", ArithmeticErrorType)

+ var PendingDeprecationWarningType = newSimpleType("PendingDeprecationWarning", WarningType)

+ var PropertyType = newBasisType("property", reflect.TypeOf(Property{}), toPropertyUnsafe, ObjectType)

+ var ReferenceErrorType = newSimpleType("ReferenceError", StandardErrorType)

+ var RuntimeErrorType = newSimpleType("RuntimeError", StandardErrorType)

+ var RuntimeWarningType = newSimpleType("RuntimeWarning", WarningType)

+ var SetType = newBasisType("set", reflect.TypeOf(Set{}), toSetUnsafe, ObjectType)

+ var SliceType = newBasisType("slice", reflect.TypeOf(Slice{}), toSliceUnsafe, ObjectType)

+ var StandardErrorType = newSimpleType("StandardError", ExceptionType)

+ var StaticMethodType = newBasisType("staticmethod", reflect.TypeOf(staticMethod{}), toStaticMethodUnsafe, ...)

+ var Stderr = NewFileFromFD(os.Stderr.Fd(), nil)

+ var Stdin = NewFileFromFD(os.Stdin.Fd(), nil)

+ var Stdout = NewFileFromFD(os.Stdout.Fd(), nil)

+ var StopIterationType = newSimpleType("StopIteration", ExceptionType)

+ var StrType = newBasisType("str", reflect.TypeOf(Str{}), toStrUnsafe, BaseStringType)

+ var SyntaxErrorType = newSimpleType("SyntaxError", StandardErrorType)

+ var SyntaxWarningType = newSimpleType("SyntaxWarning", WarningType)

+ var SysModules = NewDict()

+ var SystemErrorType = newSimpleType("SystemError", StandardErrorType)

+ var SystemExitType = newSimpleType("SystemExit", BaseExceptionType)

+ var ThreadCount int64

+ var TracebackType = newBasisType("traceback", reflect.TypeOf(Traceback{}), toTracebackUnsafe, ObjectType)

+ var True = &Int

+ var TupleType = newBasisType("tuple", reflect.TypeOf(Tuple{}), toTupleUnsafe, ObjectType)

+ var TypeErrorType = newSimpleType("TypeError", StandardErrorType)

+ var TypeType = &Type

+ var UnboundLocal = newObject(unboundLocalType)

+ var UnboundLocalErrorType = newSimpleType("UnboundLocalError", NameErrorType)

+ var UnicodeDecodeErrorType = newSimpleType("UnicodeDecodeError", ValueErrorType)

+ var UnicodeEncodeErrorType = newSimpleType("UnicodeEncodeError", ValueErrorType)

+ var UnicodeErrorType = newSimpleType("UnicodeError", ValueErrorType)

+ var UnicodeType = newBasisType("unicode", reflect.TypeOf(Unicode{}), toUnicodeUnsafe, BaseStringType)

+ var UnicodeWarningType = newSimpleType("UnicodeWarning", WarningType)

+ var UserWarningType = newSimpleType("UserWarning", WarningType)

+ var ValueErrorType = newSimpleType("ValueError", StandardErrorType)

+ var WarningType = newSimpleType("Warning", ExceptionType)

+ var WeakRefType = newBasisType("weakref", reflect.TypeOf(WeakRef{}), toWeakRefUnsafe, ObjectType)

+ var ZeroDivisionErrorType = newSimpleType("ZeroDivisionError", ArithmeticErrorType)

+ func Abs(f *Frame, o *Object) (*Object, *BaseException)

+ func Add(f *Frame, v, w *Object) (*Object, *BaseException)

+ func And(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Compare(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Div(f *Frame, v, w *Object) (*Object, *BaseException)

+ func DivMod(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Eq(f *Frame, v, w *Object) (*Object, *BaseException)

+ func FloorDiv(f *Frame, v, w *Object) (*Object, *BaseException)

+ func FormatExc(f *Frame) (s string)

+ func GE(f *Frame, v, w *Object) (*Object, *BaseException)

+ func GT(f *Frame, v, w *Object) (*Object, *BaseException)

+ func GetAttr(f *Frame, o *Object, name *Str, def *Object) (*Object, *BaseException)

+ func GetItem(f *Frame, o, key *Object) (*Object, *BaseException)

+ func Hash(f *Frame, o *Object) (*Int, *BaseException)

+ func Hex(f *Frame, o *Object) (*Object, *BaseException)

+ func IAdd(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IAnd(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IDiv(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IFloorDiv(f *Frame, v, w *Object) (*Object, *BaseException)

+ func ILShift(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IMod(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IMul(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IOr(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IPow(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IRShift(f *Frame, v, w *Object) (*Object, *BaseException)

+ func ISub(f *Frame, v, w *Object) (*Object, *BaseException)

+ func IXor(f *Frame, v, w *Object) (*Object, *BaseException)

+ func ImportModule(f *Frame, name string) ([]*Object, *BaseException)

+ func Index(f *Frame, o *Object) (*Object, *BaseException)

+ func Invert(f *Frame, o *Object) (*Object, *BaseException)

+ func Invoke(f *Frame, callable *Object, args Args, varargs *Object, keywords KWArgs, ...) (*Object, *BaseException)

+ func Iter(f *Frame, o *Object) (*Object, *BaseException)

+ func LE(f *Frame, v, w *Object) (*Object, *BaseException)

+ func LShift(f *Frame, v, w *Object) (*Object, *BaseException)

+ func LT(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Len(f *Frame, o *Object) (*Int, *BaseException)

+ func Mod(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Mul(f *Frame, v, w *Object) (*Object, *BaseException)

+ func NE(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Neg(f *Frame, o *Object) (*Object, *BaseException)

+ func Next(f *Frame, iter *Object) (*Object, *BaseException)

+ func Oct(f *Frame, o *Object) (*Object, *BaseException)

+ func Or(f *Frame, v, w *Object) (*Object, *BaseException)

+ func Pos(f *Frame, o *Object) (*Object, *BaseException)

+ func Pow(f *Frame, v, w *Object) (*Object, *BaseException)

+ func RShift(f *Frame, v, w *Object) (*Object, *BaseException)

+ func RegisterModule(name string, c *Code)

+ func Repr(f *Frame, o *Object) (*Str, *BaseException)

+ func ResolveClass(f *Frame, class *Dict, local *Object, name *Str) (*Object, *BaseException)

+ func ResolveGlobal(f *Frame, name *Str) (*Object, *BaseException)

+ func RunMain(code *Code) int

+ func StartThread(callable *Object)

+ func Sub(f *Frame, v, w *Object) (*Object, *BaseException)

+ func ToInt(f *Frame, o *Object) (*Object, *BaseException)

+ func ToStr(f *Frame, o *Object) (*Str, *BaseException)

+ func WrapNative(f *Frame, v reflect.Value) (*Object, *BaseException)

+ func Xor(f *Frame, v, w *Object) (*Object, *BaseException)

+ type Args []*Object

+ type BaseException struct

+ func Assert(f *Frame, cond *Object, msg *Object) *BaseException

+ func CheckLocal(f *Frame, value *Object, name string) *BaseException

+ func Contains(f *Frame, seq, value *Object) (bool, *BaseException)

+ func DelAttr(f *Frame, o *Object, name *Str) *BaseException

+ func DelItem(f *Frame, o, key *Object) *BaseException

+ func DelVar(f *Frame, namespace *Dict, name *Str) *BaseException

+ func IndexInt(f *Frame, o *Object) (i int, raised *BaseException)

+ func IsInstance(f *Frame, o *Object, classinfo *Object) (bool, *BaseException)

+ func IsSubclass(f *Frame, o *Object, classinfo *Object) (bool, *BaseException)

+ func IsTrue(f *Frame, o *Object) (bool, *BaseException)

+ func Print(f *Frame, args Args, nl bool) *BaseException

+ func SetAttr(f *Frame, o *Object, name *Str, value *Object) *BaseException

+ func SetItem(f *Frame, o, key, value *Object) *BaseException

+ func Tie(f *Frame, t TieTarget, o *Object) *BaseException

+ func ToIntValue(f *Frame, o *Object) (int, *BaseException)

+ func ToNative(f *Frame, o *Object) (reflect.Value, *BaseException)

+ func (e *BaseException) ToObject() *Object

+ type ByteArray struct

+ func (a *ByteArray) ToObject() *Object

+ func (a *ByteArray) Value() []byte

+ type Code struct

+ func NewCode(name, filename string, params []Param, flags CodeFlag, ...) *Code

+ func (c *Code) Eval(f *Frame, globals *Dict, args Args, kwargs KWArgs) (*Object, *BaseException)

+ type CodeFlag int

+ const CodeFlagKWArg

+ const CodeFlagVarArg

+ type Complex struct

+ func NewComplex(value complex128) *Complex

+ func (c *Complex) ToObject() *Object

+ func (c *Complex) Value() complex128

+ type Dict struct

+ func NewDict() *Dict

+ func (d *Dict) DelItem(f *Frame, key *Object) (bool, *BaseException)

+ func (d *Dict) DelItemString(f *Frame, key string) (bool, *BaseException)

+ func (d *Dict) GetItem(f *Frame, key *Object) (*Object, *BaseException)

+ func (d *Dict) GetItemString(f *Frame, key string) (*Object, *BaseException)

+ func (d *Dict) Keys(f *Frame) *List

+ func (d *Dict) Len() int

+ func (d *Dict) Pop(f *Frame, key *Object) (*Object, *BaseException)

+ func (d *Dict) SetItem(f *Frame, key, value *Object) *BaseException

+ func (d *Dict) SetItemString(f *Frame, key string, value *Object) *BaseException

+ func (d *Dict) ToObject() *Object

+ func (d *Dict) Update(f *Frame, o *Object) (raised *BaseException)

+ type File struct

+ Softspace int

+ func NewFileFromFD(fd uintptr, close *Object) *File

+ func (f *File) ToObject() *Object

+ type Float struct

+ func NewFloat(value float64) *Float

+ func (f *Float) ToObject() *Object

+ func (f *Float) Value() float64

+ type Frame struct

+ func NewRootFrame() *Frame

+ func (f *Frame) ExcInfo() (*BaseException, *Traceback)

+ func (f *Frame) FreeArgs(args Args)

+ func (f *Frame) Globals() *Dict

+ func (f *Frame) MakeArgs(n int) Args

+ func (f *Frame) PopCheckpoint()

+ func (f *Frame) PushCheckpoint(state RunState)

+ func (f *Frame) Raise(typ *Object, inst *Object, tb *Object) *BaseException

+ func (f *Frame) RaiseType(t *Type, msg string) *BaseException

+ func (f *Frame) RestoreExc(e *BaseException, tb *Traceback) (*BaseException, *Traceback)

+ func (f *Frame) SetLineno(lineno int)

+ func (f *Frame) State() RunState

+ func (f *Frame) ToObject() *Object

+ type FrozenSet setBase

+ func (s *FrozenSet) Contains(f *Frame, key *Object) (bool, *BaseException)

+ func (s *FrozenSet) ToObject() *Object

+ type Func func(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException)

+ type Function struct

+ func NewFunction(c *Code, globals *Dict) *Function

+ func (f *Function) Name() string

+ func (f *Function) ToObject() *Object

+ type Generator struct

+ func NewGenerator(f *Frame, fn func(*Object) (*Object, *BaseException)) *Generator

+ func (g *Generator) ToObject() *Object

+ type Int struct

+ func GetBool(v bool) *Int

+ func NewInt(value int) *Int

+ func (i *Int) IsTrue() bool

+ func (i *Int) ToObject() *Object

+ func (i *Int) Value() int

+ type KWArg struct

+ Name string

+ Value *Object

+ type KWArgs []KWArg

+ func (k KWArgs) String() string

+ type List struct

+ func NewList(elems ...*Object) *List

+ func (l *List) Append(o *Object)

+ func (l *List) DelItem(f *Frame, index int) *BaseException

+ func (l *List) DelSlice(f *Frame, s *Slice) *BaseException

+ func (l *List) SetItem(f *Frame, index int, value *Object) *BaseException

+ func (l *List) SetSlice(f *Frame, s *Slice, value *Object) *BaseException

+ func (l *List) Sort(f *Frame) (raised *BaseException)

+ func (l *List) ToObject() *Object

+ type Long struct

+ func NewLong(x *big.Int) *Long

+ func NewLongFromBytes(b []byte) *Long

+ func (l *Long) IntValue(f *Frame) (int, *BaseException)

+ func (l *Long) IsTrue() bool

+ func (l *Long) Neg() *Long

+ func (l *Long) ToObject() *Object

+ func (l *Long) Value() *big.Int

+ type Method struct

+ func (m *Method) ToObject() *Object

+ type Module struct

+ func (m *Module) GetFilename(f *Frame) (*Str, *BaseException)

+ func (m *Module) GetName(f *Frame) (*Str, *BaseException)

+ func (m *Module) ToObject() *Object

+ type ModuleInit func(f *Frame, m *Module) *BaseException

+ type Object struct

+ func (o *Object) Call(f *Frame, args Args, kwargs KWArgs) (*Object, *BaseException)

+ func (o *Object) Dict() *Dict

+ func (o *Object) String() string

+ func (o *Object) Type() *Type

+ type Param struct

+ Def *Object

+ Name string

+ type ParamSpec struct

+ Count int

+ func NewParamSpec(name string, params []Param, varArg bool, kwArg bool) *ParamSpec

+ func (s *ParamSpec) Validate(f *Frame, validated []*Object, args Args, kwargs KWArgs) *BaseException

+ type Property struct

+ func (p *Property) ToObject() *Object

+ type RunState int

+ type Set setBase

+ func NewSet() *Set

+ func (s *Set) Add(f *Frame, key *Object) (bool, *BaseException)

+ func (s *Set) Contains(f *Frame, key *Object) (bool, *BaseException)

+ func (s *Set) Remove(f *Frame, key *Object) (bool, *BaseException)

+ func (s *Set) ToObject() *Object

+ func (s *Set) Update(f *Frame, o *Object) *BaseException

+ type Slice struct

+ func (s *Slice) ToObject() *Object

+ type Str struct

+ func InternStr(s string) *Str

+ func NewStr(value string) *Str

+ func (s *Str) Decode(f *Frame, encoding, errors string) (*Unicode, *BaseException)

+ func (s *Str) ToObject() *Object

+ func (s *Str) Value() string

+ type TieTarget struct

+ Children []TieTarget

+ Target **Object

+ type Traceback struct

+ func (f *Traceback) ToObject() *Object

+ type TryableMutex struct

+ func NewTryableMutex() *TryableMutex

+ func (m *TryableMutex) Lock()

+ func (m *TryableMutex) TryLock() bool

+ func (m *TryableMutex) Unlock()

+ type Tuple struct

+ func NewTuple(elems ...*Object) *Tuple

+ func NewTuple0() *Tuple

+ func NewTuple1(elem0 *Object) *Tuple

+ func NewTuple2(elem0, elem1 *Object) *Tuple

+ func NewTuple3(elem0, elem1, elem2 *Object) *Tuple

+ func NewTuple4(elem0, elem1, elem2, elem3 *Object) *Tuple

+ func NewTuple5(elem0, elem1, elem2, elem3, elem4 *Object) *Tuple

+ func NewTuple6(elem0, elem1, elem2, elem3, elem4, elem5 *Object) *Tuple

+ func (t *Tuple) GetItem(i int) *Object

+ func (t *Tuple) Len() int

+ func (t *Tuple) ToObject() *Object

+ type Type struct

+ func (t *Type) FullName(f *Frame) (string, *BaseException)

+ func (t *Type) Name() string

+ func (t *Type) ToObject() *Object

+ type Unicode struct

+ func NewUnicode(value string) *Unicode

+ func NewUnicodeFromRunes(value []rune) *Unicode

+ func (s *Unicode) Encode(f *Frame, encoding, errors string) (*Str, *BaseException)

+ func (s *Unicode) ToObject() *Object

+ func (s *Unicode) Value() []rune

+ type WeakRef struct

+ func (r *WeakRef) ToObject() *Object