chirp

type Applier interface {
	Apply(fr *Frame, args []T) T
}

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

type BitsWord uint32 // We cannot fit uint64 into the float -- until we support actual uint64, we must use shorter BitsWords.

type CmdNode struct {
	Fn         Command
	MixinLevel int
	MixinName  string
	Next       *CmdNode
}

type CmdScope map[string]*CmdNode

type Command func(fr *Frame, argv []T) T

type ConstRoot struct{ Const interface{} }

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

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

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

type Either struct {
	Bad  interface{}
	Good T
}

type EnsembleItem struct {
	Name string
	Cmd  Command
	Doc  string
}

type Evaler interface {
	Eval(fr *Frame) T
}

type Frame struct {
	Mu   sync.Mutex
	Vars Scope // local variables
	Cred Hash  // credentials

	Prev *Frame
	G    *Global

	WriterChan chan<- Either // for yproc & yield
	MixinLevel int
	MixinName  string

	Self  *Obj
	Super *Obj
}

type FuncRoot struct{ Func R.Value }

type Global struct {
	Cmds CmdScope
	Fr   Frame // global scope

	MixinSerial         int    // Increment before defining Mixin.
	MixinNumberDefining int    // Set nonzero while defining Mixin.
	MixinNameDefining   string // Set nonempty while defining Mixin.
	IsSafe              bool   // Set true for safe subinterpreter.
	Logger              *log.Logger
	Verbosity           int    // Log if message level <= verbosity.
	LogName             string // for logging

	Mu sync.Mutex
}

type HTML string

type Hash map[string]T

type Jump struct {
	Status StatusCode
	Result T
}

type Lex struct {
	Str  string
	Len  int   // len(s)
	Next int   // next position to scan
	Pos  int   // position of token
	Tok  Token // type of token
}

type Loc interface {
	Has() bool
	Get() T
	Set(T)
}

type Obj struct {
	Class *Obj
	Super *Obj
	Slots Scope
}

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

type PCmd struct {
	Words []*PWord
}

type PExpr struct {
	Op      Token
	A, B, C *PExpr
	Word    *PWord // Op '"': for Primatives: "quoted", [square], 3.14 literal, {literal}, $var, $var(index).
}

type PPart struct {
	Str  string // TODO: make this a T, and use MkMulti.
	Word *PWord // for DOLLAR2
	Seq  *PSeq  // for SQUARE
	Type PartType
}

type PSeq struct {
	Cmds []*PCmd
	Src  string
}

type PWord struct {
	Parts []*PPart
	Multi *terpMulti // If not null, value is fixed and precompiled.
}

type PartType int

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

type Scope map[string]Loc

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

type Shower interface {
	Show() string
}

type Slot struct {
	Elem T
}

type SortListByStringTSlice []T

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

type StatusCode int

type SubstFlags int

type T interface {
	ChirpKind() string
	Raw() interface{}
	String() string
	Float() float64
	Int() int64
	Uint() uint64
	ListElementString() string
	Bool() bool    // Like Python, empty values and 0 values are false.
	IsEmpty() bool // Would String() return ""?
	List() []T
	IsPreservedByList() bool
	IsQuickNumber() bool
	HeadTail() (hd, tl T)
	Hash() Hash
	GetAt(key T) T
	PutAt(value T, key T)
	QuickReflectValue() R.Value
	EvalSeq(fr *Frame) T
	EvalExpr(fr *Frame) T
	Apply(fr *Frame, args []T) T
}

type Token uint8

type TypeRoot struct{ Type R.Type }

type UpSlot struct {
	Fr         *Frame
	RemoteName string
}

type VarRoot struct{ Var R.Value }

type Word interface {
	Subst(fr *Frame) T
}

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

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