Documentation ¶
Overview ¶
builtins.go
builtins.go
Index ¶
- Variables
- func AddIndexes(ps *env.ProgramState, s *env.Spreadsheet, columns []env.Word) env.Object
- func ArrayFloat32FromSeries(block env.TSeries) []float32
- func AutoType(ps *env.ProgramState, s *env.Spreadsheet, percent float64) env.Object
- func BuiConvert(ps *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object
- func BuiValidate(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object
- func CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool, ...) *env.ProgramState
- func CallFunction(fn env.Function, ps *env.ProgramState, arg0 env.Object, toLeft bool, ...) *env.ProgramState
- func CallFunctionArgs2(fn env.Function, ps *env.ProgramState, arg0 env.Object, arg1 env.Object, ...) *env.ProgramState
- func CallFunctionArgs4(fn env.Function, ps *env.ProgramState, arg0 env.Object, arg1 env.Object, ...) *env.ProgramState
- func Clear()
- func Conversion_EvalBlockCtx(ps *env.ProgramState, vals env.RyeCtx) env.Object
- func Conversion_EvalBlockDict(ps *env.ProgramState, vals env.Dict) env.Object
- func CopyMap(m map[string]any) map[string]any
- func DialectMath(env1 *env.ProgramState, arg0 env.Object) env.Object
- func DirectlyCallBuiltin(ps *env.ProgramState, bi env.Builtin, a0 env.Object, a1 env.Object) env.Object
- func DoRyeRepl(es *env.ProgramState, showResults bool)
- func EvalBlock(ps *env.ProgramState) *env.ProgramState
- func EvalBlockInCtx(ps *env.ProgramState, ctx *env.RyeCtx) *env.ProgramState
- func EvalBlockInCtxInj(ps *env.ProgramState, ctx *env.RyeCtx, inj env.Object, injnow bool) *env.ProgramState
- func EvalBlockInj(ps *env.ProgramState, inj env.Object, injnow bool) *env.ProgramState
- func EvalExpression2(ps *env.ProgramState, limited bool) *env.ProgramState
- func EvalExpressionConcrete(ps *env.ProgramState) *env.ProgramState
- func EvalExpressionInj(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
- func EvalExpressionInjLimited(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
- func EvalGenword(ps *env.ProgramState, word env.Genword, leftVal env.Object, toLeft bool) *env.ProgramState
- func EvalGetword(ps *env.ProgramState, word env.Getword, leftVal env.Object, toLeft bool) *env.ProgramState
- func EvalObject(ps *env.ProgramState, object env.Object, leftVal env.Object, toLeft bool, ...) *env.ProgramState
- func EvalSetword(ps *env.ProgramState, word env.Setword) *env.ProgramState
- func EvalWord(ps *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool, ...) *env.ProgramState
- func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool, ...) *env.ProgramState
- func Eyr_EvalBlock(es *env.ProgramState, stack *EyrStack) *env.ProgramState
- func Eyr_EvalExpression(es *env.ProgramState, stack *EyrStack) *env.ProgramState
- func Eyr_EvalObject(es *env.ProgramState, object env.Object, leftVal env.Object, toLeft bool, ...) *env.ProgramState
- func Eyr_EvalWord(es *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool, ...) *env.ProgramState
- func GenerateColumn(ps *env.ProgramState, s env.Spreadsheet, name env.Word, extractCols env.Block, ...) env.Object
- func GenerateColumnRegexReplace(ps *env.ProgramState, s *env.Spreadsheet, name env.Word, fromColName env.Word, ...) env.Object
- func GroupBy(ps *env.ProgramState, s env.Spreadsheet, col string, ...) env.Object
- func LeftJoin(ps *env.ProgramState, s1 env.Spreadsheet, s2 env.Spreadsheet, col1 string, ...) env.Object
- func Limit(ps *env.ProgramState, s env.Spreadsheet, n int) env.Object
- func MakeArgError(env1 *env.ProgramState, N int, typ []env.Type, fn string) *env.Error
- func MakeBuiltinError(env1 *env.ProgramState, msg string, fn string) *env.Error
- func MakeError(env1 *env.ProgramState, msg string) *env.Error
- func MakeRyeError(env1 *env.ProgramState, val env.Object, er *env.Error) *env.Error
- func Math_EvalBlock(es *env.ProgramState) []env.Object
- func MaybeAcceptComma(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
- func MaybeDisplayFailureOrError(es *env.ProgramState, genv *env.Idxs)
- func MaybeDisplayFailureOrErrorWASM(es *env.ProgramState, genv *env.Idxs, printfn func(string))
- func MaybeEvalOpwordOnRight(nextObj env.Object, ps *env.ProgramState, limited bool) *env.ProgramState
- func MoveCursor(x int, y int)
- func MoveCursorBackward(bias int)
- func MoveCursorDown(bias int)
- func MoveCursorForward(bias int)
- func MoveCursorUp(bias int)
- func PopOutBuffer() string
- func RegisterBuiltins(ps *env.ProgramState)
- func RegisterBuiltins2(builtins map[string]*env.Builtin, ps *env.ProgramState, name string)
- func RegisterBuiltinsInContext(builtins map[string]*env.Builtin, ps *env.ProgramState, name string)
- func RyeToJSON(res any) string
- func SortByColumn(ps *env.ProgramState, s *env.Spreadsheet, name string)
- func SortByColumnDesc(ps *env.ProgramState, s *env.Spreadsheet, name string)
- func SpreadsheetToJSON(s env.Spreadsheet) string
- func Stck_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool) *env.ProgramState
- func Stck_EvalBlock(ps *env.ProgramState) *env.ProgramState
- func Stck_EvalExpression(ps *env.ProgramState) *env.ProgramState
- func Stck_EvalObject(ps *env.ProgramState, object env.Object, leftVal env.Object, toLeft bool, ...) *env.ProgramState
- func Stck_EvalWord(ps *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool) *env.ProgramState
- func Validation_EvalBlock(es *env.ProgramState, vals env.Dict) (env.Dict, map[string]env.Object)
- func Validation_EvalBlock_List(es *env.ProgramState, vals env.List) (env.Object, []env.Object)
- func WhereBetween(ps *env.ProgramState, s env.Spreadsheet, name string, val1 env.Object, ...) env.Object
- func WhereContains(ps *env.ProgramState, s env.Spreadsheet, name string, val string, not bool) env.Object
- func WhereEquals(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
- func WhereGreater(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
- func WhereIn(ps *env.ProgramState, s env.Spreadsheet, name string, b []env.Object) env.Object
- func WhereLesser(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
- func WhereMatch(ps *env.ProgramState, s env.Spreadsheet, name string, r *regexp.Regexp) env.Object
- type ConversionError
- type EyrStack
- type RyeBlockSort
- type RyeListSort
- type ShellEd
- type ValidationError
Constants ¶
This section is empty.
Variables ¶
var BuiltinNames map[string]int // TODO --- this looks like some hanging global ... it should move to ProgramState, it doesn't even really work with contrib and external probably
var Builtins_bcrypt = map[string]*env.Builtin{}
var Builtins_bson = map[string]*env.Builtin{}
var Builtins_conversion = map[string]*env.Builtin{ "convert": { Argsn: 2, Doc: "Converts value from one kind to another.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return BuiConvert(ps, arg0, arg1) }, }, "converter": { Argsn: 3, Doc: "Sets a converter between two kinds of objects.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch obj1 := arg0.(type) { case env.Kind: switch obj2 := arg1.(type) { case env.Kind: switch spec := arg2.(type) { case env.Block: obj2.SetConverter(obj1.Kind.Index, spec) return obj2 default: return MakeArgError(ps, 3, []env.Type{env.BlockType}, "converter") } default: return MakeArgError(ps, 2, []env.Type{env.KindType, env.BlockType}, "converter") } default: return MakeArgError(ps, 1, []env.Type{env.KindType}, "converter") } }, }, }
var Builtins_crypto = map[string]*env.Builtin{}
var Builtins_email = map[string]*env.Builtin{}
var Builtins_eyr = map[string]*env.Builtin{ "eyr": { Argsn: 1, Doc: "Evaluates Rye block as Eyr (postfix) stack based code.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch bloc := arg0.(type) { case env.Block: stack := NewEyrStack() ser := ps.Ser ps.Ser = bloc.Series Eyr_EvalBlock(ps, stack) ps.Ser = ser return ps.Res default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "eyr") } }, }, "eyr-loop": { Argsn: 2, Doc: "Evaluates Rye block in loop as Eyr code (postfix stack based) N times.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch cond := arg0.(type) { case env.Integer: switch bloc := arg1.(type) { case env.Block: ser := ps.Ser ps.Ser = bloc.Series stack := NewEyrStack() for i := 0; int64(i) < cond.Value; i++ { ps = Eyr_EvalBlock(ps, stack) ps.Ser.Reset() } ps.Ser = ser return ps.Res default: return MakeArgError(ps, 2, []env.Type{env.BlockType}, "eyr-loop") } default: return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "eyr-loop") } }, }, }
var Builtins_goroutines = map[string]*env.Builtin{ "sleep": { Argsn: 1, Doc: "Accepts an integer and Sleeps for given number of miliseconds.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch arg := arg0.(type) { case env.Integer: time.Sleep(time.Duration(int(arg.Value)) * time.Millisecond) return arg default: return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "sleep") } }, }, "go-with": { Argsn: 2, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch arg := arg0.(type) { case env.Object: switch handler := arg1.(type) { case env.Function: errC := make(chan error) go func() { ps.FailureFlag = false ps.ErrorFlag = false ps.ReturnFlag = false psTemp := env.ProgramState{} err := copier.Copy(&psTemp, &ps) if err != nil { ps.FailureFlag = true ps.ErrorFlag = true ps.ReturnFlag = true errC <- fmt.Errorf("failed to copy ps: %w", err) } close(errC) CallFunction(handler, &psTemp, arg, false, nil) }() if err := <-errC; err != nil { return MakeBuiltinError(ps, err.Error(), "go-with") } return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 2, []env.Type{env.FunctionType}, "go-with") } default: ps.FailureFlag = true return MakeBuiltinError(ps, "First argument should be object type.", "go-with") } }, }, "go": { Argsn: 1, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch handler := arg0.(type) { case env.Function: errC := make(chan error) go func() { ps.FailureFlag = false ps.ErrorFlag = false ps.ReturnFlag = false psTemp := env.ProgramState{} err := copier.Copy(&psTemp, &ps) if err != nil { ps.FailureFlag = true ps.ErrorFlag = true ps.ReturnFlag = true errC <- fmt.Errorf("failed to copy ps: %w", err) } close(errC) CallFunction(handler, &psTemp, nil, false, nil) }() if err := <-errC; err != nil { return MakeBuiltinError(ps, err.Error(), "go") } return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.FunctionType}, "go") } }, }, "channel": { Argsn: 1, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch buflen := arg0.(type) { case env.Integer: ch := make(chan *env.Object, int(buflen.Value)) return *env.NewNative(ps.Idx, ch, "Rye-channel") default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "new-channel") } }, }, "Rye-channel//read": { Argsn: 1, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch chn := arg0.(type) { case env.Native: msg, ok := <-chn.Value.(chan *env.Object) if ok { return *msg } else { return *env.NewError("channel closed") } default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//read") } }, }, "Rye-channel//send": { Argsn: 2, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch chn := arg0.(type) { case env.Native: chn.Value.(chan *env.Object) <- &arg1 return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//send") } }, }, "Rye-channel//close": { Argsn: 1, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch chn := arg0.(type) { case env.Native: close(chn.Value.(chan *env.Object)) return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-channel//close") } }, }, "waitgroup": { Argsn: 0, Doc: "Create a waitgroup.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { var wg sync.WaitGroup return *env.NewNative(ps.Idx, &wg, "Rye-waitgroup") }, }, "Rye-waitgroup//add": { Argsn: 2, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch wg := arg0.(type) { case env.Native: switch count := arg1.(type) { case env.Integer: wg.Value.(*sync.WaitGroup).Add(int(count.Value)) return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 2, []env.Type{env.IntegerType}, "Rye-waitgroup//add") } default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//add") } }, }, "Rye-waitgroup//done": { Argsn: 1, Doc: "TODODOC.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch wg := arg0.(type) { case env.Native: wg.Value.(*sync.WaitGroup).Done() return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//done") } }, }, "Rye-waitgroup//wait": { Argsn: 1, Doc: "Wait on a waitgroup.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch wg := arg0.(type) { case env.Native: wg.Value.(*sync.WaitGroup).Wait() return arg0 default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.NativeType}, "Rye-waitgroup//wait") } }, }, "select\\fn": { Argsn: 1, Doc: "Select on a message on multiple channels or default.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch block := arg0.(type) { case env.Block: ser := ps.Ser ps.Ser = block.Series var hasDeafult bool var cases []reflect.SelectCase var funcs []env.Function for ps.Ser.Pos() < ps.Ser.Len() { EvalExpression2(ps, false) defaultFn, ok := ps.Res.(env.Function) if ok { if hasDeafult { ps.FailureFlag = true return MakeBuiltinError(ps, "select can only have one default case", "select") } if defaultFn.Argsn != 0 { ps.FailureFlag = true return MakeBuiltinError(ps, "function with 0 args required", "select") } defaultCase := make(chan struct{}) close(defaultCase) cases = append(cases, reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(defaultCase), }) funcs = append(funcs, defaultFn) hasDeafult = true continue } native, ok := ps.Res.(env.Native) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "first argument of a case must be a channel", "select") } ch, ok := native.Value.(chan *env.Object) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "first argument of a case must be a channel", "select") } cases = append(cases, reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}) EvalExpression2(ps, false) fn, ok := ps.Res.(env.Function) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "second argument of a case must be a function", "select") } if fn.Argsn > 1 { ps.FailureFlag = true return MakeBuiltinError(ps, "function with 0 or 1 arg required", "select") } funcs = append(funcs, fn) } ps.Ser = ser chosen, value, recvOK := reflect.Select(cases) fn := funcs[chosen] psTemp := env.ProgramState{} err := copier.Copy(&psTemp, &ps) if err != nil { ps.FailureFlag = true return MakeBuiltinError(ps, fmt.Sprintf("failed to copy ps: %s", err), "select") } var arg env.Object = nil if recvOK { val, ok := value.Interface().(*env.Object) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "value from channel is not an object", "select") } arg = *val } if fn.Argsn == 0 { arg = nil } CallFunction(fn, &psTemp, arg, false, nil) default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.BlockType}, "select") } return arg0 }, }, "select": { Argsn: 1, Doc: "Select on a message on multiple channels or default.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch block := arg0.(type) { case env.Block: ser := ps.Ser ps.Ser = block.Series var hasDeafult bool var cases []reflect.SelectCase var funcs []env.Block for ps.Ser.Pos() < ps.Ser.Len() { EvalExpression2(ps, false) switch maybeChan := ps.Res.(type) { case env.Native: ch, ok := maybeChan.Value.(chan *env.Object) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "first argument of a case must be a channel", "select") } cases = append(cases, reflect.SelectCase{Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ch)}) EvalExpression2(ps, false) fn, ok := ps.Res.(env.Block) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "second argument of a case must be a block", "select") } funcs = append(funcs, fn) case env.Void: if hasDeafult { ps.FailureFlag = true return MakeBuiltinError(ps, "select can only have one default case", "select") } defaultCase := make(chan struct{}) close(defaultCase) cases = append(cases, reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(defaultCase), }) EvalExpression2(ps, false) fn, ok := ps.Res.(env.Block) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "second argument of a case must be a block", "select") } funcs = append(funcs, fn) hasDeafult = true } } ps.Ser = ser chosen, value, recvOK := reflect.Select(cases) fn := funcs[chosen] psTemp := env.ProgramState{} err := copier.Copy(&psTemp, &ps) if err != nil { ps.FailureFlag = true return MakeBuiltinError(ps, fmt.Sprintf("failed to copy ps: %s", err), "select") } var arg env.Object = nil if recvOK { val, ok := value.Interface().(*env.Object) if !ok { ps.FailureFlag = true return MakeBuiltinError(ps, "value from channel is not an object", "select") } arg = *val } psTemp.Ser = fn.Series EvalBlockInj(&psTemp, arg, true) default: ps.FailureFlag = true return MakeArgError(ps, 1, []env.Type{env.BlockType}, "select") } return arg0 }, }, }
var Builtins_html = map[string]*env.Builtin{}
var Builtins_http = map[string]*env.Builtin{}
var Builtins_io = map[string]*env.Builtin{ "input": { Argsn: 1, Doc: "Take input from a user.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __input(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//open": { Argsn: 1, Doc: "Open file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __open(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//create": { Argsn: 1, Doc: "Create file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __create(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-ext?": { Argsn: 1, Doc: "Get file extension.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch s := arg0.(type) { case env.Uri: path := strings.Split(s.Path, "://") ext := filepath.Ext(path[1]) return *env.NewString(ext) case env.String: ext := filepath.Ext(s.Value) return *env.NewString(ext) default: return MakeArgError(ps, 1, []env.Type{env.UriType, env.StringType}, "file-ext?") } }, }, "reader": { Argsn: 1, Doc: "Open new reader.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __open_reader(ps, arg0, arg1, arg2, arg3, arg4) }, }, "stdin": { Argsn: 0, Doc: "Standard input.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return *env.NewNative(ps.Idx, os.Stdin, "rye-reader") }, }, "stdout": { Argsn: 0, Doc: "Standard output.", Fn: func(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return *env.NewNative(env1.Idx, os.Stdout, "rye-writer") }, }, "rye-reader//copy": { Argsn: 2, Doc: "Copy from a reader to a writer.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __copy(ps, arg0, arg1, arg2, arg3, arg4) }, }, "rye-file//copy": { Argsn: 2, Doc: "Copy Rye file to ouptut.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __copy(ps, arg0, arg1, arg2, arg3, arg4) }, }, "rye-file//stat": { Argsn: 1, Doc: "Get stat of a file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __stat(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-info//size?": { Argsn: 1, Doc: "Get size of a file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch s := arg0.(type) { case env.Native: size := s.Value.(os.FileInfo).Size() return *env.NewInteger(size) default: return MakeArgError(ps, 1, []env.Type{env.NativeType}, "file-info//size?") } }, }, "rye-file//read-all": { Argsn: 1, Doc: "Read all file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __read_all(ps, arg0, arg1, arg2, arg3, arg4) }, }, "rye-file//write": { Argsn: 2, Doc: "Write to a file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __write(ps, arg0, arg1, arg2, arg3, arg4) }, }, "rye-file//close": { Argsn: 1, Doc: "Closes an open file or reader or writer.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __close(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//read": { Argsn: 1, Doc: "Read a file given the path.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __fs_read(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//read\\bytes": { Argsn: 1, Doc: "Read a specific number of bytes from a file path.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __fs_read_bytes(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//read\\lines": { Argsn: 1, Doc: "Read files into the block of lines.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __fs_read_lines(ps, arg0, arg1, arg2, arg3, arg4) }, }, "file-schema//write": { Argsn: 2, Doc: "Write to a file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __fs_write(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-schema//get": { Argsn: 1, Doc: "Make a HTTPS GET request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_s_get(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-schema//post": { Argsn: 3, Doc: "Make a HTTPS POST request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __http_s_post(ps, arg0, arg1, arg2, arg3, arg4) }, }, "http-schema//get": { Argsn: 1, Doc: "Make a HTTP GET request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_s_get(ps, arg0, arg1, arg2, arg3, arg4) }, }, "http-schema//post": { Argsn: 3, Doc: "Make a HTTP POST request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __http_s_post(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-schema//new-request": { Argsn: 3, Doc: "Create a new HTTPS Request object.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_s__new_request(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-request//set-header": { Argsn: 3, Doc: "Set header to the HTTPS Request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_request__set_header(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-request//set-basic-auth": { Argsn: 3, Doc: "Set Basic Auth to the HTTPS Request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_request__set_basic_auth(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-request//call": { Argsn: 1, Doc: "Call a HTTPS Request.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_request__do(ps, arg0, arg1, arg2, arg3, arg4) }, }, "https-response//read-body": { Argsn: 1, Doc: "Read body of HTTPS response.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __https_response__read_body(ps, arg0, arg1, arg2, arg3, arg4) }, }, "email//send": { Argsn: 2, Doc: "Send email.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return __email_send(ps, arg0, arg1, arg2, arg3, arg4) }, }, "serve-cgi": { Argsn: 3, Doc: "Serve CGI.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch rword := arg0.(type) { case env.Word: switch wword := arg1.(type) { case env.Word: switch bloc := arg2.(type) { case env.Block: var rctx *env.RyeCtx if err := cgi.Serve(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { ser := ps.Ser ctx := ps.Ctx ps.Ser = bloc.Series ps.Ctx = env.NewEnv(ps.Ctx) ps.Ctx.Set(rword.Index, *env.NewNative(ps.Idx, w, "Go-server-response-writer")) ps.Ctx.Set(wword.Index, *env.NewNative(ps.Idx, r, "Go-server-request")) EvalBlock(ps) rctx = ps.Ctx ps.Ctx = ctx ps.Ser = ser })); err != nil { return MakeBuiltinError(ps, err.Error(), "serve-cgi") } return *rctx default: return MakeArgError(ps, 3, []env.Type{env.BlockType}, "serve-cgi") } default: return MakeArgError(ps, 2, []env.Type{env.WordType}, "serve-cgi") } default: return MakeArgError(ps, 1, []env.Type{env.WordType}, "serve-cgi") } }, }, }
var Builtins_json = map[string]*env.Builtin{ "parse-json": { Argsn: 1, Doc: "Parsing JSON values.", Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return _parse_json(es, arg0, arg1, arg2, arg3, arg4) }, }, "to-json": { Argsn: 1, Doc: "Takes a Rye value and returns it encoded into JSON.", Fn: func(es *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return *env.NewString(RyeToJSON(arg0)) }, }, }
var Builtins_mail = map[string]*env.Builtin{}
var Builtins_math = map[string]*env.Builtin{ "mod": { Argsn: 2, Doc: "Return a decimal remainder", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { fa, fb, errPos := assureFloats(arg0, arg1) if errPos > 0 { return MakeArgError(ps, errPos, []env.Type{env.IntegerType, env.BlockType}, "mod") } return *env.NewDecimal(math.Mod(fa, fb)) }, }, "log2": { Argsn: 1, Doc: "Return binary logarithm of x", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Integer: return *env.NewDecimal(math.Log2(float64(val.Value))) case env.Decimal: return *env.NewDecimal(math.Log2(val.Value)) default: return MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "mod") } }, }, "sin": { Argsn: 1, Doc: "Return the sine of the radian argument.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Integer: return *env.NewDecimal(math.Sin(float64(val.Value))) case env.Decimal: return *env.NewDecimal(math.Sin(val.Value)) default: return MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "mod") } }, }, "cos": { Argsn: 1, Doc: "Return the cosine of the radian argument.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Integer: return *env.NewDecimal(math.Cos(float64(val.Value))) case env.Decimal: return *env.NewDecimal(math.Cos(val.Value)) default: return MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "mod") } }, }, "sqrt": { Argsn: 1, Doc: "Return the square root of x.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Integer: return *env.NewDecimal(math.Sqrt(float64(val.Value))) case env.Decimal: return *env.NewDecimal(math.Sqrt(val.Value)) default: return MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "mod") } }, }, "abs": { Argsn: 1, Doc: "Return absolute value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Integer: return *env.NewDecimal(math.Abs(float64(val.Value))) case env.Decimal: return *env.NewDecimal(math.Abs(val.Value)) default: return MakeArgError(ps, 2, []env.Type{env.IntegerType, env.BlockType}, "mod") } }, }, "pi": { Argsn: 0, Doc: "Return Pi constant.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return *env.NewDecimal(float64(math.Pi)) }, }, "is-near": { Argsn: 2, Doc: "Returns true if two decimals are close.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { fa, fb, errPos := assureFloats(arg0, arg1) if errPos > 0 { return MakeArgError(ps, errPos, []env.Type{env.IntegerType, env.BlockType}, "equals") } const epsilon = 0.0000000000001 // math.SmallestNonzeroFloat64 if math.Abs(fa-fb) <= (epsilon) { return env.NewInteger(1) } else { return env.NewInteger(0) } }, }, "near-zero": { Argsn: 1, Doc: "Returns true if two decimals are close.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { var fa float64 switch a := arg0.(type) { case env.Decimal: fa = a.Value case env.Integer: fa = float64(a.Value) default: return MakeArgError(ps, 1, []env.Type{env.IntegerType, env.BlockType}, "is-zero") } // const epsilon = math.SmallestNonzeroFloat64 const epsilon = 0.0000000000001 // math.SmallestNonzeroFloat64 if math.Abs(fa) <= epsilon { return env.NewInteger(1) } else { return env.NewInteger(0) } }, }, "to-eyr": { Argsn: 1, Doc: "Math dialect to Eyr dialect", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return DialectMath(ps, arg0) }, }, "math": { Argsn: 1, Doc: "Do math dialect", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { res := DialectMath(ps, arg0) switch block := res.(type) { case env.Block: stack := NewEyrStack() ser := ps.Ser ps.Ser = block.Series Eyr_EvalBlock(ps, stack) ps.Ser = ser return ps.Res default: return res } }, }, }
var Builtins_mysql = map[string]*env.Builtin{}
var Builtins_ps = map[string]*env.Builtin{}
var Builtins_psql = map[string]*env.Builtin{}
var Builtins_regexp = map[string]*env.Builtin{ "regexp": { Argsn: 1, Doc: "Creates a Regular expression object.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch s := arg0.(type) { case env.String: val, err := regexp.Compile(s.Value) if err != nil { return MakeError(ps, err.Error()) } return *env.NewNative(ps.Idx, val, "regexp") default: return MakeArgError(ps, 1, []env.Type{env.StringType}, "regexp") } }, }, "regexp//is-match": { Argsn: 2, Doc: "Check if string matches the given regular epression.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg1.(type) { case env.String: switch s := arg0.(type) { case env.Native: res := s.Value.(*regexp.Regexp).MatchString(val.Value) if res { return *env.NewInteger(1) } else { return *env.NewInteger(0) } default: return MakeArgError(ps, 1, []env.Type{env.NativeType}, "regexp//matches") } default: return MakeArgError(ps, 2, []env.Type{env.StringType}, "regexp//matches") } }, }, "regexp//submatch?": { Argsn: 2, Doc: "Get the first submatch from string given the regular exprepesion.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg1.(type) { case env.String: switch s := arg0.(type) { case env.Native: res := s.Value.(*regexp.Regexp).FindStringSubmatch(val.Value) if len(res) > 1 { return *env.NewString(res[1]) } else { return MakeBuiltinError(ps, "No submatch.", "regexp//submatch?") } default: return MakeArgError(ps, 1, []env.Type{env.NativeType}, "regexp//submatch?") } default: return MakeArgError(ps, 2, []env.Type{env.StringType}, "regexp//submatch?") } }, }, "regexp//submatches?": { Argsn: 2, Doc: "Get all regexp submatches in a Block.", Fn: func(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg1.(type) { case env.String: switch s := arg0.(type) { case env.Native: res := s.Value.(*regexp.Regexp).FindStringSubmatch(val.Value) if len(res) > 0 { col1 := make([]env.Object, len(res)-1) for i, row := range res { if i > 0 { col1[i-1] = *env.NewString(row) } } return *env.NewBlock(*env.NewTSeries(col1)) } return MakeBuiltinError(env1, "No results", "submatches?") default: return MakeError(env1, "Arg2 not Native") } default: return MakeError(env1, "Arg1 not String") } }, }, "regexp//find-all": { Argsn: 2, Doc: "Find all matches and return them in a Block", Fn: func(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg1.(type) { case env.String: switch s := arg0.(type) { case env.Native: res := s.Value.(*regexp.Regexp).FindAllString(val.Value, -1) if len(res) > 0 { col1 := make([]env.Object, len(res)) for i, row := range res { col1[i] = *env.NewString(row) } return *env.NewBlock(*env.NewTSeries(col1)) } return MakeBuiltinError(env1, "No results", "submatches?") default: return MakeError(env1, "Arg2 not Native") } default: return MakeError(env1, "Arg1 not String") } }, }, "regexp//match?": { Argsn: 2, Doc: "Get the regexp match.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg1.(type) { case env.String: switch s := arg0.(type) { case env.Native: res := s.Value.(*regexp.Regexp).FindString(val.Value) return *env.NewString(res) default: return MakeArgError(ps, 1, []env.Type{env.NativeType}, "regexp//match?") } default: return MakeArgError(ps, 2, []env.Type{env.StringType}, "regexp//match?") } }, }, "regexp//replace-all": { Argsn: 3, Doc: "Replace all mathes in a string given the regexp with another string.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch re := arg0.(type) { case env.Native: switch val := arg1.(type) { case env.String: switch replac := arg2.(type) { case env.String: res := re.Value.(*regexp.Regexp).ReplaceAllString(val.Value, replac.Value) return *env.NewString(res) default: return MakeArgError(ps, 3, []env.Type{env.StringType}, "regexp//replace-all") } default: return MakeArgError(ps, 2, []env.Type{env.StringType}, "regexp//replace-all") } default: return MakeArgError(ps, 1, []env.Type{env.NativeType}, "regexp//replace-all") } }, }, }
var Builtins_smtpd = map[string]*env.Builtin{}
var Builtins_spreadsheet = map[string]*env.Builtin{ "spreadsheet": { Argsn: 2, Doc: "Create a spreadsheet by accepting block of column names and flat block of values", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch header1 := arg0.(type) { case env.Block: header := header1.Series hlen := header.Len() cols := make([]string, hlen) for header.Pos() < hlen { i := header.Pos() k1 := header.Pop() switch k := k1.(type) { case env.String: cols[i] = k.Value } } spr := env.NewSpreadsheet(cols) switch data1 := arg1.(type) { case env.Block: rdata := data1.Series.S for i := 0; i < len(rdata)/hlen; i++ { rowd := make([]any, hlen) for ii := 0; ii < hlen; ii++ { rowd[ii] = rdata[i*hlen+ii] } spr.AddRow(*env.NewSpreadsheetRow(rowd, spr)) } return *spr case env.List: rdata := data1.Data for i := 0; i < len(rdata)/hlen; i++ { rowd := make([]any, hlen) for ii := 0; ii < hlen; ii++ { rowd[ii] = rdata[i*hlen+ii] } spr.AddRow(*env.NewSpreadsheetRow(rowd, spr)) } return *spr default: return MakeArgError(ps, 2, []env.Type{env.BlockType}, "spreadsheet") } default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "spreadsheet") } }, }, "to-spreadsheet": { Argsn: 1, Doc: "Create a spreadsheet by accepting block or list of dicts", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch block := arg0.(type) { case env.Block: data := block.Series if data.Len() == 0 { return MakeBuiltinError(ps, "Block is empty", "to-spreadsheet") } k := make(map[string]struct{}) for _, obj := range data.S { switch dict := obj.(type) { case env.Dict: for key := range dict.Data { k[key] = struct{}{} } default: return MakeBuiltinError(ps, "Block must contain only dicts", "to-spreadsheet") } } var keys []string for key := range k { keys = append(keys, key) } spr := env.NewSpreadsheet(keys) for _, obj := range data.S { switch dict := obj.(type) { case env.Dict: row := make([]any, len(keys)) for i, key := range keys { data, ok := dict.Data[key] if !ok { data = env.Void{} } row[i] = data } spr.AddRow(*env.NewSpreadsheetRow(row, spr)) } } return *spr case env.List: data := block.Data if len(data) == 0 { return MakeBuiltinError(ps, "List is empty", "to-spreadsheet") } k := make(map[string]struct{}) for _, obj := range data { switch dict := obj.(type) { case map[string]any: for key := range dict { k[key] = struct{}{} } default: return MakeBuiltinError(ps, "List must contain only dicts", "to-spreadsheet") } } var keys []string for key := range k { keys = append(keys, key) } spr := env.NewSpreadsheet(keys) for _, obj := range data { row := make([]any, len(keys)) switch dict := obj.(type) { case map[string]any: for i, key := range keys { data, ok := dict[key] if !ok { data = env.Void{} } row[i] = data } } spr.AddRow(*env.NewSpreadsheetRow(row, spr)) } return *spr default: return MakeArgError(ps, 1, []env.Type{env.BlockType, env.ListType}, "to-spreadsheet") } }, }, "get-rows": { Argsn: 1, Doc: "Create a spreadsheet by accepting block of column names and flat block of values", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: rows := spr.GetRows() return *env.NewNative(ps.Idx, rows, "spreadsheet-rows") default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "get-rows") } }, }, "add-rows": { Argsn: 2, Doc: "Create a spreadsheet by accepting block of column names and flat block of values", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch data1 := arg1.(type) { case env.Block: data := data1.Series for data.Pos() < data.Len() { rowd := make([]any, len(spr.Cols)) for ii := 0; ii < len(spr.Cols); ii++ { k1 := data.Pop() rowd[ii] = k1 } spr.AddRow(*env.NewSpreadsheetRow(rowd, &spr)) } return spr case env.Native: spr.Rows = append(spr.Rows, data1.Value.([]env.SpreadsheetRow)...) return spr default: return MakeArgError(ps, 2, []env.Type{env.BlockType, env.NativeType}, "add-rows") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "add-rows") } }, }, "load\\csv": { Argsn: 1, Doc: "Loads a .csv file to a spreadsheet datatype.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch file := arg0.(type) { case env.Uri: f, err := os.Open(file.GetPath()) if err != nil { return MakeBuiltinError(ps, "Unable to read input file.", "load\\csv") } defer f.Close() csvReader := csv.NewReader(f) rows, err := csvReader.ReadAll() if err != nil { return MakeBuiltinError(ps, "Unable to parse file as CSV.", "load\\csv") } spr := env.NewSpreadsheet(rows[0]) if len(rows) > 1 { for _, row := range rows[1:] { anyRow := make([]any, len(row)) for i, v := range row { anyRow[i] = *env.NewString(v) } spr.AddRow(*env.NewSpreadsheetRow(anyRow, spr)) } } return *spr default: return MakeArgError(ps, 1, []env.Type{env.UriType}, "load\\csv") } }, }, "save\\csv": { Argsn: 2, Doc: "Saves a spreadsheet to a .csv file.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch file := arg1.(type) { case env.Uri: f, err := os.Create(file.GetPath()) if err != nil { return MakeBuiltinError(ps, "Unable to create input file.", "save\\csv") } defer f.Close() cLen := len(spr.Cols) csvWriter := csv.NewWriter(f) err1 := csvWriter.Write(spr.Cols) if err1 != nil { return MakeBuiltinError(ps, "Unable to create write header.", "save\\csv") } for ir, row := range spr.Rows { strVals := make([]string, cLen) for i, v := range row.Values { var sv string switch tv := v.(type) { case env.String: sv = tv.Value case env.Integer: sv = strconv.Itoa(int(tv.Value)) case env.Decimal: sv = fmt.Sprintf("%f", tv.Value) } strVals[i] = sv } err := csvWriter.Write(strVals) if err != nil { return MakeBuiltinError(ps, "Unable to write line: "+strconv.Itoa(ir), "save\\csv") } } csvWriter.Flush() f.Close() return spr default: return MakeArgError(ps, 1, []env.Type{env.UriType}, "save\\csv") } default: return MakeArgError(ps, 1, []env.Type{env.UriType}, "save\\csv") } }, }, "where-equal": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum is equal to given value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: return WhereEquals(ps, spr, ps.Idx.GetWord(col.Index), arg2) case env.String: return WhereEquals(ps, spr, col.Value, arg2) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-equal") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-equal") } }, }, "where-match": { Argsn: 3, Doc: "Returns spreadsheet of rows where a specific colum matches a regex.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch reNative := arg2.(type) { case env.Native: re, ok := reNative.Value.(*regexp.Regexp) if !ok { return MakeArgError(ps, 2, []env.Type{env.NativeType}, "where-match") } switch col := arg1.(type) { case env.Word: return WhereMatch(ps, spr, ps.Idx.GetWord(col.Index), re) case env.String: return WhereMatch(ps, spr, col.Value, re) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-match") } default: return MakeArgError(ps, 3, []env.Type{env.NativeType}, "where-match") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-match") } }, }, "where-contains": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum contains a given string value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch s := arg2.(type) { case env.String: switch col := arg1.(type) { case env.Word: return WhereContains(ps, spr, ps.Idx.GetWord(col.Index), s.Value, false) case env.String: return WhereContains(ps, spr, col.Value, s.Value, false) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-contains") } default: return MakeArgError(ps, 3, []env.Type{env.StringType}, "where-contains") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-contains") } }, }, "where-not-contains": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum contains a given string value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch s := arg2.(type) { case env.String: switch col := arg1.(type) { case env.Word: return WhereContains(ps, spr, ps.Idx.GetWord(col.Index), s.Value, true) case env.String: return WhereContains(ps, spr, col.Value, s.Value, true) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-contains") } default: return MakeArgError(ps, 3, []env.Type{env.StringType}, "where-contains") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-contains") } }, }, "where-greater": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum is greater than given value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: return WhereGreater(ps, spr, ps.Idx.GetWord(col.Index), arg2) case env.String: return WhereGreater(ps, spr, col.Value, arg2) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-greater") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-greater") } }, }, "where-lesser": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum is lesser than given value.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: return WhereLesser(ps, spr, ps.Idx.GetWord(col.Index), arg2) case env.String: return WhereLesser(ps, spr, col.Value, arg2) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-lesser") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-lesser") } }, }, "where-between": { Argsn: 4, Doc: "Returns spreadsheet of rows where specific colum is between given values.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: return WhereBetween(ps, spr, ps.Idx.GetWord(col.Index), arg2, arg3) case env.String: return WhereBetween(ps, spr, col.Value, arg2, arg3) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-between") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-between") } }, }, "where-in": { Argsn: 3, Doc: "Returns spreadsheet of rows where specific colum value if found in block of values.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch s := arg2.(type) { case env.Block: switch col := arg1.(type) { case env.Word: return WhereIn(ps, spr, ps.Idx.GetWord(col.Index), s.Series.S) case env.String: return WhereIn(ps, spr, col.Value, s.Series.S) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-in") } default: return MakeArgError(ps, 3, []env.Type{env.StringType}, "where-in") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "where-in") } }, }, "limit": { Argsn: 2, Doc: "Returns spreadsheet with number of rows limited to second argument.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch n := arg1.(type) { case env.Integer: return Limit(ps, spr, int(n.Value)) default: return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "limit") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "limit") } }, }, "sort-col!": { Argsn: 2, Doc: "Sorts row by given column.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: SortByColumn(ps, &spr, ps.Idx.GetWord(col.Index)) return spr default: return MakeArgError(ps, 2, []env.Type{env.WordType}, "sort-col!") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "sort-col!") } }, }, "sort-col\\desc!": { Argsn: 2, Doc: "Sorts rows by given column, descending.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: SortByColumnDesc(ps, &spr, ps.Idx.GetWord(col.Index)) return spr default: return MakeArgError(ps, 2, []env.Type{env.WordType}, "sort-col\\desc!") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "sort-col\\desc!") } }, }, "columns": { Argsn: 2, Doc: "Returs spreasheet with just given columns.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Block: cols := make([]string, col.Series.Len()) for c := range col.Series.S { switch ww := col.Series.S[c].(type) { case env.String: cols[c] = ww.Value case env.Tagword: cols[c] = ps.Idx.GetWord(ww.Index) } } return spr.Columns(ps, cols) default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "columns") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "columns") } }, }, "columns?": { Argsn: 1, Doc: "Gets the column names as block.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: return spr.GetColumns() default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "columns?") } }, }, "column?": { Argsn: 2, Doc: "Gets all values of a column as a block.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Word: return spr.Column(ps.Idx.GetWord(col.Index)) case env.String: return spr.Column(col.Value) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "column?") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "column?") } }, }, "add-col!": { Argsn: 4, Doc: "Adds a new column to spreadsheet. Changes in-place and returns the new spreadsheet.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch newCol := arg1.(type) { case env.Word: switch fromCols := arg2.(type) { case env.Block: switch code := arg3.(type) { case env.Block: return GenerateColumn(ps, spr, newCol, fromCols, code) default: return MakeArgError(ps, 4, []env.Type{env.BlockType}, "add-col!") } case env.Word: switch replaceBlock := arg3.(type) { case env.Block: if replaceBlock.Series.Len() != 2 { return MakeBuiltinError(ps, "Replacement block must contain a regex object and replacement string.", "add-col!") } regexNative, ok := replaceBlock.Series.S[0].(env.Native) if !ok { return MakeBuiltinError(ps, "First element of replacement block must be a regex object.", "add-col!") } regex, ok := regexNative.Value.(*regexp.Regexp) if !ok { return MakeBuiltinError(ps, "First element of replacement block must be a regex object.", "add-col!") } replaceStr, ok := replaceBlock.Series.S[1].(env.String) if !ok { return MakeBuiltinError(ps, "Second element of replacement block must be a string.", "add-col!") } err := GenerateColumnRegexReplace(ps, &spr, newCol, fromCols, regex, replaceStr.Value) if err != nil { return err } return spr default: return MakeArgError(ps, 3, []env.Type{env.BlockType}, "add-col!") } default: return MakeArgError(ps, 3, []env.Type{env.BlockType}, "add-col!") } default: return MakeArgError(ps, 2, []env.Type{env.WordType}, "add-col!") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "add-col!") } }, }, "add-indexes!": { Argsn: 2, Doc: "Creates an index for all values in the provided columns. Changes in-place and returns the new spreadsheet.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch spr := arg0.(type) { case env.Spreadsheet: switch col := arg1.(type) { case env.Block: colWords := make([]env.Word, col.Series.Len()) for c := range col.Series.S { switch ww := col.Series.S[c].(type) { case env.Word: colWords[c] = ww default: return MakeError(ps, "Block of tagwords needed") } } err := AddIndexes(ps, &spr, colWords) if err != nil { return err } return spr default: return MakeArgError(ps, 2, []env.Type{env.BlockType}, "add-index!") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "add-index!") } }, }, "indexes?": { Argsn: 1, Doc: "Returns the columns that are indexed in a spreadsheet.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: res := make([]env.Object, 0) for col := range spr.Indexes { res = append(res, *env.NewString(col)) } return *env.NewBlock(*env.NewTSeries(res)) default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "indexes?") } }, }, "autotype": { Argsn: 2, Doc: "Takes a spreadsheet and tries to determine and change the types of columns.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch percent := arg1.(type) { case env.Decimal: return AutoType(ps, &spr, percent.Value) default: return MakeArgError(ps, 2, []env.Type{env.DecimalType}, "autotype") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "autotype") } }, }, "left-join": { Argsn: 4, Doc: "Left joins two spreadsheets on the given columns.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr1 := arg0.(type) { case env.Spreadsheet: switch spr2 := arg1.(type) { case env.Spreadsheet: switch col1 := arg2.(type) { case env.Word: col2, ok := arg3.(env.Word) if !ok { return MakeArgError(ps, 4, []env.Type{env.WordType}, "left-join") } return LeftJoin(ps, spr1, spr2, ps.Idx.GetWord(col1.Index), ps.Idx.GetWord(col2.Index), false) case env.String: col2, ok := arg3.(env.String) if !ok { MakeArgError(ps, 4, []env.Type{env.StringType}, "left-join") } return LeftJoin(ps, spr1, spr2, col1.Value, col2.Value, false) default: return MakeArgError(ps, 3, []env.Type{env.WordType, env.StringType}, "left-join") } default: return MakeArgError(ps, 2, []env.Type{env.SpreadsheetType}, "left-join") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "left-join") } }, }, "inner-join": { Argsn: 4, Doc: "Inner joins two spreadsheets on the given columns.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr1 := arg0.(type) { case env.Spreadsheet: switch spr2 := arg1.(type) { case env.Spreadsheet: switch col1 := arg2.(type) { case env.Word: col2, ok := arg3.(env.Word) if !ok { return MakeArgError(ps, 4, []env.Type{env.WordType}, "inner-join") } return LeftJoin(ps, spr1, spr2, ps.Idx.GetWord(col1.Index), ps.Idx.GetWord(col2.Index), true) case env.String: col2, ok := arg3.(env.String) if !ok { MakeArgError(ps, 4, []env.Type{env.StringType}, "inner-join") } return LeftJoin(ps, spr1, spr2, col1.Value, col2.Value, true) default: return MakeArgError(ps, 3, []env.Type{env.WordType, env.StringType}, "inner-join") } default: return MakeArgError(ps, 2, []env.Type{env.SpreadsheetType}, "inner-join") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "inner-join") } }, }, "group-by": { Argsn: 3, Doc: "Groups a spreadsheet by the given column and (optional) aggregations.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) { switch spr := arg0.(type) { case env.Spreadsheet: switch aggBlock := arg2.(type) { case env.Block: if len(aggBlock.Series.S)%2 != 0 { return MakeBuiltinError(ps, "Aggregation block must contain pairs of column name and function for each aggregation.", "group-by") } aggregations := make(map[string][]string) for i := 0; i < len(aggBlock.Series.S); i += 2 { col := aggBlock.Series.S[i] fun, ok := aggBlock.Series.S[i+1].(env.Word) if !ok { return MakeBuiltinError(ps, "Aggregation function must be a word", "group-by") } colStr := "" switch col := col.(type) { case env.Tagword: colStr = ps.Idx.GetWord(col.Index) case env.String: colStr = col.Value default: return MakeBuiltinError(ps, "Aggregation column must be a word or string", "group-by") } funStr := ps.Idx.GetWord(fun.Index) aggregations[colStr] = append(aggregations[colStr], funStr) } switch col := arg1.(type) { case env.Word: return GroupBy(ps, spr, ps.Idx.GetWord(col.Index), aggregations) case env.String: return GroupBy(ps, spr, col.Value, aggregations) default: return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "group-by") } default: return MakeArgError(ps, 3, []env.Type{env.BlockType}, "group-by") } default: return MakeArgError(ps, 1, []env.Type{env.SpreadsheetType}, "group-by") } }, }, }
var Builtins_sqlite = map[string]*env.Builtin{}
var Builtins_stackless = map[string]*env.Builtin{ "ry0": { Argsn: 1, Doc: "TODODOC", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch bloc := arg0.(type) { case env.Block: ser := ps.Ser ps.Ser = bloc.Series Stck_EvalBlock(ps) ps.Ser = ser return ps.Res default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "ry0") } }, }, "ry0-loop": { Argsn: 2, Doc: "TODODOC", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch cond := arg0.(type) { case env.Integer: switch bloc := arg1.(type) { case env.Block: ser := ps.Ser ps.Ser = bloc.Series for i := 0; int64(i) < cond.Value; i++ { ps = Stck_EvalBlock(ps) ps.Ser.Reset() } ps.Ser = ser return ps.Res default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "ry0-loop") } default: return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "ry0-loop") } }, }, }
var Builtins_structures = map[string]*env.Builtin{ "process": { Argsn: 2, Doc: "TODODOC", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { rm, err := load_structures_Dict(ps, arg1.(env.Block)) if err != nil { ps.FailureFlag = true return err } switch data := arg0.(type) { case env.Dict: return do_structures(ps, data, rm) } return nil }, }, }
var Builtins_sxml = map[string]*env.Builtin{}
var Builtins_telegrambot = map[string]*env.Builtin{}
var Builtins_validation = map[string]*env.Builtin{ "validate": { Argsn: 2, Doc: "Validates Dictionary using the Validation dialect and returns result or a Failure.", Fn: func(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { return BuiValidate(env1, arg0, arg1) }, }, "validate>ctx": { Argsn: 2, Doc: "Validates Dictionary using the Validation dialect and returns result as a Context or a Failure.", Fn: func(env1 *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { obj := BuiValidate(env1, arg0, arg1) switch obj1 := obj.(type) { case env.Dict: return util.Dict2Context(env1, obj1) default: return obj1 } }, }, }
var Builtins_vector = map[string]*env.Builtin{ "vector": { Argsn: 1, Doc: "Creates vector object.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch s := arg0.(type) { case env.Block: data := ArrayFloat32FromSeries(s.Series) val, err := govector.AsVector(data) if err != nil { return MakeError(ps, err.Error()) } return *env.NewVector(val) default: return MakeArgError(ps, 1, []env.Type{env.BlockType}, "vector") } }, }, "normalize": { Argsn: 1, Doc: "Normalize vector.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Vector: return *env.NewDecimal(govector.Norm(val.Value, 2.0)) default: return MakeArgError(ps, 1, []env.Type{env.VectorType}, "norm") } }, }, "std-deviation?": { Argsn: 1, Doc: "Calculate standard deviation of a vector", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch val := arg0.(type) { case env.Vector: return *env.NewDecimal(val.Value.Sd()) default: return MakeArgError(ps, 1, []env.Type{env.VectorType}, "std-deviation") } }, }, "cosine-similarity?": { Argsn: 2, Doc: "Calculate cosine similarity.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch v1 := arg0.(type) { case env.Vector: switch v2 := arg1.(type) { case env.Vector: res, err := govector.Cosine(v1.Value, v2.Value) if err != nil { return MakeBuiltinError(ps, err.Error(), "cosine-similarity") } return *env.NewDecimal(res) default: return MakeArgError(ps, 2, []env.Type{env.VectorType}, "cosine-similarity") } default: return MakeArgError(ps, 1, []env.Type{env.VectorType}, "cosine-similarity") } }, }, "correlation": { Argsn: 2, Doc: "Get correlation between two vectors", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch v1 := arg0.(type) { case env.Vector: switch v2 := arg1.(type) { case env.Vector: res, err := govector.Cor(v1.Value, v2.Value) if err != nil { return MakeError(ps, err.Error()) } return *env.NewDecimal(res) default: return MakeArgError(ps, 2, []env.Type{env.VectorType}, "correlation") } default: return MakeArgError(ps, 1, []env.Type{env.VectorType}, "correlation") } }, }, "dot-product": { Argsn: 2, Doc: "Calculate dot product between two vectors.", Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object { switch v1 := arg0.(type) { case env.Vector: switch v2 := arg1.(type) { case env.Vector: res, err := govector.DotProduct(v1.Value, v2.Value) if err != nil { return MakeError(ps, err.Error()) } return *env.NewDecimal(res) default: return MakeArgError(ps, 2, []env.Type{env.VectorType}, "dot-product") } default: return MakeArgError(ps, 1, []env.Type{env.VectorType}, "dot-product") } }, }, }
var Builtins_web = map[string]*env.Builtin{}
var OutBuffer = "" // how does this work with multiple threads / ... in server use ... probably we would need some per environment variable, not global / global?
var ShowResults bool
Functions ¶
func AddIndexes ¶
func AddIndexes(ps *env.ProgramState, s *env.Spreadsheet, columns []env.Word) env.Object
func ArrayFloat32FromSeries ¶
func AutoType ¶
func AutoType(ps *env.ProgramState, s *env.Spreadsheet, percent float64) env.Object
func BuiConvert ¶
func BuiValidate ¶
func CallBuiltin ¶
func CallFunction ¶
func CallFunctionArgs2 ¶
func CallFunctionArgs4 ¶
func Conversion_EvalBlockCtx ¶
func DialectMath ¶ added in v0.0.11
func DirectlyCallBuiltin ¶
func DoRyeRepl ¶
func DoRyeRepl(es *env.ProgramState, showResults bool)
func EvalBlock ¶
func EvalBlock(ps *env.ProgramState) *env.ProgramState
DESCR: the most general EvalBlock
func EvalBlockInCtx ¶
func EvalBlockInCtx(ps *env.ProgramState, ctx *env.RyeCtx) *env.ProgramState
DESCR: eval a block in specific context
func EvalBlockInCtxInj ¶
func EvalBlockInCtxInj(ps *env.ProgramState, ctx *env.RyeCtx, inj env.Object, injnow bool) *env.ProgramState
DESCR: eval a block in specific context
func EvalBlockInj ¶
func EvalBlockInj(ps *env.ProgramState, inj env.Object, injnow bool) *env.ProgramState
DESCR: the main evaluator of block
func EvalExpression2 ¶
func EvalExpression2(ps *env.ProgramState, limited bool) *env.ProgramState
this functions is used to evaluate expression in the middle of block currently it's called to collect arguments for builtins and functions
func EvalExpressionConcrete ¶
func EvalExpressionConcrete(ps *env.ProgramState) *env.ProgramState
the main part of evaluator, if it were a polish only we would need almost only this switches over all rye values and acts on them
func EvalExpressionInj ¶
func EvalExpressionInj(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
I don't fully get this function in this review ... it's this way so it handles op and pipe words mainly, but I need to get deeper again to write a proper explanation TODO -- return to this and explain
func EvalExpressionInjLimited ¶
func EvalExpressionInjLimited(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
REFATOR THIS WITH CODE ABOVE when seeing bigger picture, just adding fow eval-with
func EvalGenword ¶
func EvalGenword(ps *env.ProgramState, word env.Genword, leftVal env.Object, toLeft bool) *env.ProgramState
if word is defined to be generic ... I am not sure we will keep this ... we will decide with more use then if explicitly treats it as generic word
func EvalGetword ¶
func EvalGetword(ps *env.ProgramState, word env.Getword, leftVal env.Object, toLeft bool) *env.ProgramState
evaluates a get-word . it retrieves rye value behid it w/o evaluation
func EvalObject ¶
func EvalObject(ps *env.ProgramState, object env.Object, leftVal env.Object, toLeft bool, ctx *env.RyeCtx, pipeSecond bool, firstVal env.Object) *env.ProgramState
evaluates a rye value, most of them just get returned, except builtins, functions and context paths
func EvalSetword ¶
func EvalSetword(ps *env.ProgramState, word env.Setword) *env.ProgramState
evaluates expression to the right and sets the result of it to a word in current context
func EvalWord ¶
func EvalWord(ps *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool, pipeSecond bool) *env.ProgramState
Evaluates a word first tries to find a value in normal context. If there were no generic words this would be mostly it if word is not found then it tries to get the value of next expression and find a generic word based on that, it here is leftval already present it can dispatc on it otherwise
func Eyr_CallBuiltin ¶
func Eyr_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool, stack *EyrStack) *env.ProgramState
func Eyr_EvalBlock ¶
func Eyr_EvalBlock(es *env.ProgramState, stack *EyrStack) *env.ProgramState
func Eyr_EvalExpression ¶
func Eyr_EvalExpression(es *env.ProgramState, stack *EyrStack) *env.ProgramState
func Eyr_EvalObject ¶
func Eyr_EvalWord ¶
func Eyr_EvalWord(es *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool, stack *EyrStack) *env.ProgramState
func GenerateColumn ¶
func GenerateColumnRegexReplace ¶ added in v0.0.17
func GroupBy ¶ added in v0.0.17
func GroupBy(ps *env.ProgramState, s env.Spreadsheet, col string, aggregations map[string][]string) env.Object
func LeftJoin ¶ added in v0.0.17
func LeftJoin(ps *env.ProgramState, s1 env.Spreadsheet, s2 env.Spreadsheet, col1 string, col2 string, innerJoin bool) env.Object
func Limit ¶
func Limit(ps *env.ProgramState, s env.Spreadsheet, n int) env.Object
func MakeArgError ¶
func MakeBuiltinError ¶
func MakeRyeError ¶
func Math_EvalBlock ¶ added in v0.0.11
func Math_EvalBlock(es *env.ProgramState) []env.Object
func MaybeAcceptComma ¶
func MaybeAcceptComma(ps *env.ProgramState, inj env.Object, injnow bool) (*env.ProgramState, bool)
comma (expression guard) can be present between block-level expressions, in case of injected block they reinject the value
func MaybeDisplayFailureOrError ¶
func MaybeDisplayFailureOrError(es *env.ProgramState, genv *env.Idxs)
func MaybeDisplayFailureOrErrorWASM ¶ added in v0.0.13
func MaybeDisplayFailureOrErrorWASM(es *env.ProgramState, genv *env.Idxs, printfn func(string))
func MaybeEvalOpwordOnRight ¶
func MaybeEvalOpwordOnRight(nextObj env.Object, ps *env.ProgramState, limited bool) *env.ProgramState
this function get's the next object (unevaluated), progra state, limited bool (op or pipe) first if there is return flag it returns (not sure if this is necesarry here) TODO -- figure out if next object is opword it steps to next and evaluates the word then recurse to maybe again if next object is pipeword
on limited return (what is limited exactly ? TODO) step to next word and evaluate it again check for return flag check for failure flag and cwitch to error ... doesn't one of checkFlags do this or similar? .TODO recurse again
if next is lsetword
set the value to word and recurse
func MoveCursorBackward ¶
func MoveCursorBackward(bias int)
Move cursor backward relative the current position
func MoveCursorForward ¶
func MoveCursorForward(bias int)
Move cursor forward relative the current position
func PopOutBuffer ¶
func PopOutBuffer() string
func RegisterBuiltins ¶
func RegisterBuiltins(ps *env.ProgramState)
func RegisterBuiltins2 ¶
func RegisterBuiltinsInContext ¶ added in v0.0.16
func SortByColumn ¶
func SortByColumn(ps *env.ProgramState, s *env.Spreadsheet, name string)
func SortByColumnDesc ¶
func SortByColumnDesc(ps *env.ProgramState, s *env.Spreadsheet, name string)
func SpreadsheetToJSON ¶
func SpreadsheetToJSON(s env.Spreadsheet) string
Inspect returns a string representation of the Integer.
func Stck_CallBuiltin ¶
func Stck_CallBuiltin(bi env.Builtin, ps *env.ProgramState, arg0_ env.Object, toLeft bool) *env.ProgramState
func Stck_EvalBlock ¶
func Stck_EvalBlock(ps *env.ProgramState) *env.ProgramState
func Stck_EvalExpression ¶
func Stck_EvalExpression(ps *env.ProgramState) *env.ProgramState
func Stck_EvalObject ¶
func Stck_EvalWord ¶
func Stck_EvalWord(ps *env.ProgramState, word env.Object, leftVal env.Object, toLeft bool) *env.ProgramState
func Validation_EvalBlock ¶
func WhereBetween ¶ added in v0.0.17
func WhereContains ¶ added in v0.0.17
func WhereContains(ps *env.ProgramState, s env.Spreadsheet, name string, val string, not bool) env.Object
func WhereEquals ¶
func WhereEquals(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
func WhereGreater ¶
func WhereGreater(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
func WhereIn ¶ added in v0.0.17
func WhereIn(ps *env.ProgramState, s env.Spreadsheet, name string, b []env.Object) env.Object
func WhereLesser ¶
func WhereLesser(ps *env.ProgramState, s env.Spreadsheet, name string, val env.Object) env.Object
func WhereMatch ¶ added in v0.0.17
func WhereMatch(ps *env.ProgramState, s env.Spreadsheet, name string, r *regexp.Regexp) env.Object
Types ¶
type ConversionError ¶
type ConversionError struct {
// contains filtered or unexported fields
}
Integer represents an integer.
type EyrStack ¶
func NewEyrStack ¶
func NewEyrStack() *EyrStack
type RyeBlockSort ¶
Sort object interface
func (RyeBlockSort) Len ¶
func (s RyeBlockSort) Len() int
func (RyeBlockSort) Less ¶
func (s RyeBlockSort) Less(i, j int) bool
func (RyeBlockSort) Swap ¶
func (s RyeBlockSort) Swap(i, j int)
type RyeListSort ¶
type RyeListSort []any
Sort list interface
func (RyeListSort) Len ¶
func (s RyeListSort) Len() int
func (RyeListSort) Less ¶
func (s RyeListSort) Less(i, j int) bool
func (RyeListSort) Swap ¶
func (s RyeListSort) Swap(i, j int)
type ValidationError ¶
type ValidationError struct {
// contains filtered or unexported fields
}
Integer represents an integer.
Source Files ¶
- builtins.go
- builtins_bcrypt_not.go
- builtins_bson_not.go
- builtins_conversion.go
- builtins_crypto_not.go
- builtins_email_not.go
- builtins_eyr.go
- builtins_goroutines.go
- builtins_html_not.go
- builtins_http_not.go
- builtins_io.go
- builtins_json.go
- builtins_mail_not.go
- builtins_math.go
- builtins_mysql_not.go
- builtins_psql_not.go
- builtins_psutil_not.go
- builtins_regexp.go
- builtins_smtpd_not.go
- builtins_spreadsheet.go
- builtins_sqlite_not.go
- builtins_stackless.go
- builtins_structures.go
- builtins_sxml_not.go
- builtins_telegrambot_not.go
- builtins_validation.go
- builtins_vector.go
- builtins_web_not.go
- evaldo.go
- generic.go
- repl.go