evaldo

var BatteryConvertHook func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object = func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object {
	return MakeBuiltinError(ps, "Conversion requires the batteries package (call batteries.RegisterBatteries first).", "convert")
}

var BatteryDialectMathHook func(ps *env.ProgramState, arg0 env.Object) env.Object = func(ps *env.ProgramState, arg0 env.Object) env.Object {
	return MakeBuiltinError(ps, "Math dialect requires the batteries package.", "math")
}

var BatteryEvalInPersistentCtxHook func(ps *env.ProgramState, ctx PersistentCtxInterface) = func(ps *env.ProgramState, ctx PersistentCtxInterface) {

}

var BatteryEyrEvalBlockHook func(ps *env.ProgramState, full bool) = func(ps *env.ProgramState, full bool) {

}

var BatteryEyrEvalBlockInsideHook func(ps *env.ProgramState, inj env.Object, injnow bool) = func(ps *env.ProgramState, inj env.Object, injnow bool) {

}

var BatteryIsScenarioHook func(ps *env.ProgramState) bool = func(ps *env.ProgramState) bool { return false }

var BatteryMarkdownDisplayHook func(source string) []interface{} = func(source string) []interface{} {
	return nil
}

var BatteryScenarioCaptureOutputHook func(ps *env.ProgramState, payload env.Object) bool = func(ps *env.ProgramState, payload env.Object) bool { return false }

var BatteryScenarioGetHook func(ps *env.ProgramState, name string) (bool, env.Object) = func(ps *env.ProgramState, name string) (bool, env.Object) {
	return false, nil
}

var BatteryValidateHook func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object = func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object) env.Object {

	return BuiValidate(ps, arg0, arg1)
}

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_error_creation = ErrorCreationBuiltins

var Builtins_error_handling = ErrorHandlingBuiltins

var Builtins_error_inspection = ErrorInspectionBuiltins

var Builtins_table = map[string]*env.Builtin{

	"table": {
		Argsn: 2,
		Doc:   "Creates a table 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:
				hlen := header1.Series.Len()
				cols, err := ColNames(ps, header1, "table")
				if err != nil {
					return err
				}
				spr := env.NewTable(cols)
				switch data1 := arg1.(type) {
				case env.Block:
					rdata := data1.Series.S

					if hlen > 0 {
						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.NewTableRow(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.NewTableRow(rowd, spr))
					}
					return *spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "table")
				}

			default:
				return MakeArgError(ps, 1, []env.Type{env.BlockType}, "table")
			}
		},
	},

	"table\\columns": {
		Argsn: 2,
		Doc:   "Creats a table by accepting a block 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) {
			return SheetFromColumns(ps, arg0, arg1)
		},
	},

	"table\\rows": {
		Argsn: 2,
		Doc:   "Creates a table by accepting a block or list of rows",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) {
			cols, err := ColNames(ps, arg0, "table\\rows	")
			if err != nil {
				return err
			}
			spr := env.NewTable(cols)
			switch rows := arg1.(type) {
			case env.Block:
				for _, objRow := range rows.Series.S {
					row, err := TableRowsFromBlockOrList(ps, spr, len(cols), objRow)
					if err != nil {
						return err
					}
					spr.AddRow(*row)
				}
				return *spr
			case env.List:
				for _, listRow := range rows.Data {
					row, err := TableRowsFromBlockOrList(ps, spr, len(cols), listRow)
					if err != nil {
						return err
					}
					spr.AddRow(*row)
				}
				return *spr
			default:
				return MakeArgError(ps, 2, []env.Type{env.BlockType, env.ListType}, "table\\rows")
			}
		},
	},

	"to-table": {
		Argsn: 1,
		Doc:   "Creates a table 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-table")
				}
				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-table")
					}
				}
				var keys []string
				for key := range k {
					keys = append(keys, key)
				}
				spr := env.NewTable(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.NewTableRow(row, spr))
					}
				}
				return *spr

			case env.List:
				data := block.Data
				if len(data) == 0 {
					return MakeBuiltinError(ps, "List is empty", "to-table")
				}
				k := make(map[string]struct{})
				for _, obj := range data {
					switch dict := obj.(type) {
					case map[string]any:
						for key := range dict {
							k[key] = struct{}{}
						}
					case env.Dict:
						for key := range dict.Data {
							k[key] = struct{}{}
						}
					default:
						return MakeBuiltinError(ps, "List must contain only dicts", "to-table")
					}
				}
				var keys []string
				for key := range k {
					keys = append(keys, key)
				}
				spr := env.NewTable(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] = env.ToRyeValue(data)
						}
						spr.AddRow(*env.NewTableRow(row, spr))
					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] = env.ToRyeValue(data)
						}
						spr.AddRow(*env.NewTableRow(row, spr))
					}
				}
				return *spr

			default:
				return MakeArgError(ps, 1, []env.Type{env.BlockType, env.ListType}, "to-table")
			}
		},
	},

	"to-dict": {
		Argsn: 1,
		Doc:   "Creates a dict from a two-column table, using the first column as keys and the second column as values.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch s := arg0.(type) {
			case env.Table:
				spr = &s
			case *env.Table:
				spr = s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "to-dict")
			}
			if len(spr.Cols) != 2 {
				return MakeBuiltinError(ps, fmt.Sprintf("to-dict requires a table with exactly 2 columns, got %d", len(spr.Cols)), "to-dict")
			}
			data := make(map[string]any, len(spr.Rows))
			for _, row := range spr.Rows {
				keyObj := env.ToRyeValue(row.Values[0])
				var keyStr string
				switch k := keyObj.(type) {
				case env.String:
					keyStr = k.Value
				case env.Word:
					keyStr = ps.Idx.GetWord(k.Index)
				case env.Integer:
					keyStr = fmt.Sprintf("%d", k.Value)
				case env.Decimal:
					keyStr = fmt.Sprintf("%g", k.Value)
				default:
					return MakeBuiltinError(ps, fmt.Sprintf("to-dict: key column values must be strings or numbers, got %s", keyObj.Inspect(*ps.Idx)), "to-dict")
				}
				data[keyStr] = env.ToRyeValue(row.Values[1])
			}
			return *env.NewDict(data)
		},
	},

	"where-equal": {
		Argsn: 3,
		Doc:   "Returns table 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 {
			var spr *env.Table
			switch s := arg0.(type) {
			case *env.Table:
				spr = s
			case env.Table:
				spr = &s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-equal")
			}
			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")
			}
		},
	},

	"where-not-equal": {
		Argsn: 3,
		Doc:   "Returns table of rows where specific colum is not 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 {
			var spr *env.Table
			switch s := arg0.(type) {
			case *env.Table:
				spr = s
			case env.Table:
				spr = &s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-not-equal")
			}
			switch col := arg1.(type) {
			case env.Word:
				return WhereNotEquals(ps, spr, ps.Idx.GetWord(col.Index), arg2)
			case env.String:
				return WhereNotEquals(ps, spr, col.Value, arg2)
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-not-equal")
			}
		},
	},

	"where-void": {
		Argsn: 2,
		Doc:   "Returns table of rows where specific colum is void.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch s := arg0.(type) {
			case *env.Table:
				spr = s
			case env.Table:
				spr = &s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-void")
			}
			switch col := arg1.(type) {
			case env.Word:
				return WhereEquals(ps, spr, ps.Idx.GetWord(col.Index), env.NewVoid())
			case env.String:
				return WhereEquals(ps, spr, col.Value, env.NewVoid())
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-void")
			}
		},
	},

	"where-match": {
		Argsn: 3,
		Doc:   "Returns table 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) {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-match")
			}
			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")
			}
		},
	},

	"where-contains": {
		Argsn: 3,
		Doc:   "Returns table 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) {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-contains")
			}
			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")
			}
		},
	},

	"where-not-contains": {
		Argsn: 3,
		Doc:   "Returns table of rows where specific colum does not contain 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) {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-not-contains")
			}
			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-not-contains")
				}
			default:
				return MakeArgError(ps, 3, []env.Type{env.StringType}, "where-not-contains")
			}
		},
	},

	"where-greater": {
		Argsn: 3,
		Doc:   "Returns table 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 {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-greater")
			}
			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")
			}
		},
	},

	"where-lesser": {
		Argsn: 3,
		Doc:   "Returns table 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 {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-lesser")
			}
			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")
			}
		},
	},

	"where-between": {
		Argsn: 4,
		Doc:   "Returns table 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) {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-between")
			}
			switch col := arg1.(type) {
			case env.Word:
				return WhereBetween(ps, spr, ps.Idx.GetWord(col.Index), arg2, arg3, false)
			case env.String:
				return WhereBetween(ps, spr, col.Value, arg2, arg3, false)
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-between")
			}
		},
	},

	"where-between\\inclusive": {
		Argsn: 4,
		Doc:   "Returns table of rows where specific colum is between given values (inclusive).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) (res env.Object) {
			var spr *env.Table
			switch sheet := arg0.(type) {
			case env.Table:
				spr = &sheet
			case *env.Table:
				spr = sheet
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-between\\inclusive")
			}
			switch col := arg1.(type) {
			case env.Word:
				return WhereBetween(ps, spr, ps.Idx.GetWord(col.Index), arg2, arg3, true)
			case env.String:
				return WhereBetween(ps, spr, col.Value, arg2, arg3, true)
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-between\\inclusive")
			}
		},
	},

	"where-in": {
		Argsn: 3,
		Doc:   "Returns table of rows where specific colum value is 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) {
			var spr *env.Table
			switch s := arg0.(type) {
			case env.Table:
				spr = &s
			case *env.Table:
				spr = s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-in")
			}
			switch vals := arg2.(type) {
			case env.Block:
				switch col := arg1.(type) {
				case env.Word:
					return WhereIn(ps, spr, ps.Idx.GetWord(col.Index), vals.Series.S)
				case env.String:
					return WhereIn(ps, spr, col.Value, vals.Series.S)
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-in")
				}
			default:
				return MakeArgError(ps, 3, []env.Type{env.BlockType}, "where-in")
			}
		},
	},

	"where-not-in": {
		Argsn: 3,
		Doc:   "Returns table of rows where specific colum value is not 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) {
			var spr *env.Table
			switch s := arg0.(type) {
			case env.Table:
				spr = &s
			case *env.Table:
				spr = s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where-not-in")
			}
			switch vals := arg2.(type) {
			case env.Block:
				switch col := arg1.(type) {
				case env.Word:
					return WhereNotIn(ps, spr, ps.Idx.GetWord(col.Index), vals.Series.S)
				case env.String:
					return WhereNotIn(ps, spr, col.Value, vals.Series.S)
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "where-not-in")
				}
			default:
				return MakeArgError(ps, 3, []env.Type{env.BlockType}, "where-not-in")
			}
		},
	},

	"where": {
		Argsn: 3,
		Doc:   "Returns table of rows where code block evaluates to true for the column value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch table := arg0.(type) {
			case env.Table:
				spr = &table
			case *env.Table:
				spr = table
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "where")
			}

			switch col := arg1.(type) {
			case env.Word:
				colName := ps.Idx.GetWord(col.Index)
				switch block := arg2.(type) {
				case env.Block:
					return WhereBlock(ps, spr, colName, block)
				case env.Builtin:
					return WhereBuiltin(ps, spr, colName, block)
				case env.Function:
					return WhereFunction(ps, spr, colName, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType, env.BuiltinType, env.FunctionType}, "where")
				}
			case env.String:
				colName := col.Value
				switch block := arg2.(type) {
				case env.Block:
					return WhereBlock(ps, spr, colName, block)
				case env.Builtin:
					return WhereBuiltin(ps, spr, colName, block)
				case env.Function:
					return WhereFunction(ps, spr, colName, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType, env.BuiltinType, env.FunctionType}, "where")
				}
			case env.Block:
				switch block := arg2.(type) {
				case env.Block:
					return WhereBlockMultiCol(ps, spr, col, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType}, "where")
				}
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType, env.BlockType}, "where")
			}
		},
	},

	"distinct": {
		Argsn: 2,
		Doc:   "Returns table with duplicate rows removed based on specified column(s).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch s := arg0.(type) {
			case env.Table:
				spr = &s
			case *env.Table:
				spr = s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "distinct")
			}
			switch col := arg1.(type) {
			case env.Word:
				return Distinct(ps, spr, []string{ps.Idx.GetWord(col.Index)})
			case env.String:
				return Distinct(ps, spr, []string{col.Value})
			case env.Block:
				var cols []string
				for _, word := range col.Series.S {
					switch w := word.(type) {
					case env.Word:
						cols = append(cols, ps.Idx.GetWord(w.Index))
					case env.Tagword:
						cols = append(cols, ps.Idx.GetWord(w.Index))
					case env.String:
						cols = append(cols, w.Value)
					default:
						return MakeBuiltinError(ps, "Column names block must contain only words or strings.", "distinct")
					}
				}
				return Distinct(ps, spr, cols)
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType, env.BlockType}, "distinct")
			}
		},
	},

	"fill-void": {
		Argsn: 3,
		Doc:   "Returns table with void values in specified column replaced with given value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch s := arg0.(type) {
			case env.Table:
				spr = &s
			case *env.Table:
				spr = s
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "fill-void")
			}
			var colName string
			switch col := arg1.(type) {
			case env.Word:
				colName = ps.Idx.GetWord(col.Index)
			case env.String:
				colName = col.Value
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "fill-void")
			}
			return FillVoid(ps, spr, colName, arg2)
		},
	},

	"count-where": {
		Argsn: 3,
		Doc:   "Returns count of rows where code block evaluates to true for the column value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var spr *env.Table
			switch table := arg0.(type) {
			case env.Table:
				spr = &table
			case *env.Table:
				spr = table
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "count-where")
			}

			switch col := arg1.(type) {
			case env.Word:
				colName := ps.Idx.GetWord(col.Index)
				switch block := arg2.(type) {
				case env.Block:
					return CountWhereBlock(ps, spr, colName, block)
				case env.Builtin:
					return CountWhereBuiltin(ps, spr, colName, block)
				case env.Function:
					return CountWhereFunction(ps, spr, colName, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType, env.BuiltinType, env.FunctionType}, "count-where")
				}
			case env.String:
				colName := col.Value
				switch block := arg2.(type) {
				case env.Block:
					return CountWhereBlock(ps, spr, colName, block)
				case env.Builtin:
					return CountWhereBuiltin(ps, spr, colName, block)
				case env.Function:
					return CountWhereFunction(ps, spr, colName, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType, env.BuiltinType, env.FunctionType}, "count-where")
				}
			case env.Block:
				switch block := arg2.(type) {
				case env.Block:
					return CountWhereBlockMultiCol(ps, spr, col, block)
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType}, "count-where")
				}
			default:
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType, env.BlockType}, "count-where")
			}
		},
	},

	"add-row": {
		Argsn: 2,
		Doc:   "Returns a table with new-row added to it",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch table := arg0.(type) {
			case env.Table:
				switch bloc := arg1.(type) {
				case env.Block:
					vals := make([]any, bloc.Series.Len())
					for i := 0; i < bloc.Series.Len(); i++ {
						vals[i] = bloc.Series.Get(i)
					}
					table.AddRow(*env.NewTableRow(vals, &table))
					return table
				case env.List:
					vals := make([]any, len(bloc.Data))
					for i, v := range bloc.Data {
						vals[i] = env.ToRyeValue(v)
					}
					table.AddRow(*env.NewTableRow(vals, &table))
					return table
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType, env.ListType}, "add-row")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "add-row")
			}
		},
	},

	"get-rows": {
		Argsn: 1,
		Doc:   "Get rows as a native. This value can be used in `add-rows` and `add-rows!`",
		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.Table:
				rows := spr.GetRows()
				return *env.NewNative(ps.Idx, rows, "table-rows")
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "get-rows")
			}
		},
	},

	"add-rows": {
		Argsn: 2,
		Doc:   "Add one or more rows to a table",
		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.Table:
				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.NewTableRow(rowd, &spr))
					}
					return spr
				case env.List:
					data := data1.Data
					for item := range data {
						rowd := make([]any, len(spr.Cols))
						for ii := 0; ii < len(spr.Cols); ii++ {
							k1 := item
							rowd[ii] = k1
						}
						spr.AddRow(*env.NewTableRow(rowd, &spr))
					}
					return spr
				case env.Native:
					spr.Rows = append(spr.Rows, data1.Value.([]env.TableRow)...)
					return spr
				default:
					fmt.Println(data1.Inspect(*ps.Idx))
					return MakeArgError(ps, 2, []env.Type{env.BlockType, env.NativeType}, "add-rows")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "add-rows")
			}
		},
	},

	"add-rows!": {
		Argsn: 2,
		Doc:   "Add one or more rows to a table ref",
		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.Table:
				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.NewTableRow(rowd, spr))
					}
					return spr
				case env.Native:
					spr.Rows = append(spr.Rows, data1.Value.([]env.TableRow)...)
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType, env.NativeType}, "add-rows!")
				}
			case *env.PersistentTable:
				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.NewTableRow(rowd, spr))
					}
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "add-rows!")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType, env.PersistentTableType}, "add-rows!")
			}
		},
	},

	"update-row!": {
		Argsn: 3,
		Doc:   `Update the row at the given index.`,
		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.Table:
				switch idx := arg1.(type) {
				case env.Integer:
					if idx.Value < 1 || (idx.Value-1) > int64(len(spr.Rows)) {
						errMsg := fmt.Sprintf("update-row! called with row index %d, but table only has %d rows", idx.Value, len(spr.Rows))
						return MakeError(ps, errMsg)
					}
					switch updater := arg2.(type) {
					case env.Function:
						CallFunction_CollectArgs(updater, ps, spr.Rows[idx.Value-1], false, ps.Ctx)
						ret := ps.Res
						if ok, err, row := RyeValueToTableRow(spr, ret); ok {
							spr.Rows[idx.Value-1] = *row
							return spr
						} else if len(err) > 0 {
							return MakeError(ps, err)
						} else {
							return MakeError(ps, fmt.Sprintf(
								"Function given to update-row! should have returned a Dict or a TableRow, but returned a %s %#v instead",
								NameOfRyeType(ret.Type()), ret,
							))
						}
					case env.Dict:

						row := spr.Rows[idx.Value-1]

						for keyStr, val := range updater.Data {
							index := spr.GetColumnIndex(keyStr)
							if index < 0 {
								return MakeError(ps, "Column "+keyStr+" was not found")
							}
							row.Values[index] = val
						}
						return spr
					case env.TableRow:
						spr.Rows[idx.Value-1] = updater
						return spr
					default:
						return MakeArgError(ps, 3, []env.Type{env.FunctionType, env.DictType, env.TableRowType}, "update-row!")
					}
				default:
					return MakeArgError(ps, 2, []env.Type{env.IntegerType}, "update-row!")
				}
			default:
				return MakeNeedsThawedArgError(ps, "update-row!")
			}

		},
	},

	"remove-row!": {
		Argsn: 2,
		Doc:   "Remove a row from a table by index",
		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.Table:
				switch data1 := arg1.(type) {
				case env.Integer:
					if data1.Value > 0 && data1.Value <= int64(len(spr.Rows)) {
						spr.RemoveRowByIndex(data1.Value - 1)
						return spr
					} else {
						return MakeError(ps, fmt.Sprintf("Table had less then %d rows", data1.Value))
					}
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType, env.NativeType}, "remove-row!")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "remove-row!")
			}
		},
	},

	"columns?": {
		Argsn: 2,
		Doc:   "Returns table with just given columns. Use lsetwords (:newName) to rename the previous 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.Table:
				switch col := arg1.(type) {
				case env.Block:
					cols := make([]string, 0)
					colNames := make([]string, 0)

					for _, obj := range col.Series.S {
						switch ww := obj.(type) {
						case env.String:
							cols = append(cols, ww.Value)
							colNames = append(colNames, ww.Value)
						case env.Tagword:
							colName := ps.Idx.GetWord(ww.Index)
							cols = append(cols, colName)
							colNames = append(colNames, colName)
						case env.LSetword:

							if len(colNames) == 0 {
								return MakeBuiltinError(ps, "LSetword :"+ps.Idx.GetWord(ww.Index)+" found but no previous column to rename", "columns?")
							}

							newName := ps.Idx.GetWord(ww.Index)
							colNames[len(colNames)-1] = newName
						default:
							return MakeBuiltinError(ps, "Expected string, tagword, or lsetword in columns specification", "columns?")
						}
					}
					return spr.ColumnsRenamed(ps, cols, colNames)
				default:
					return MakeArgError(ps, 1, []env.Type{env.BlockType}, "columns?")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "columns?")
			}
		},
	},

	"header?": {
		Argsn: 1,
		Doc:   "Gets the column names (header) 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.Table:
				return spr.GetColumns()
			case env.Table:
				return spr.GetColumns()
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "headers?")
			}
		},
	},

	"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.Table:
				switch col := arg1.(type) {
				case env.Word:
					res := spr.GetColumn(ps.Idx.GetWord(col.Index))
					if _, isErr := res.(*env.Error); isErr {
						ps.FailureFlag = true
					}
					return res
				case env.String:
					res := spr.GetColumn(col.Value)
					if _, isErr := res.(*env.Error); isErr {
						ps.FailureFlag = true
					}
					return res
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "column?")
				}
			case env.Block:
				switch col := arg1.(type) {
				case env.Integer:
					col1 := make([]env.Object, len(spr.Series.S))
					if col.Value < 0 {
						return MakeBuiltinError(ps, "Index can't be negative", "column?")
					}
					for i, item_ := range spr.Series.S {
						switch item := item_.(type) {
						case env.Block:
							if len(item.Series.S) < int(col.Value) {
								return MakeBuiltinError(ps, "index out of bounds for item: "+strconv.Itoa(i), "column?")
							}
							col1[i] = item.Series.S[col.Value]
						}
					}
					return *env.NewBlock(*env.NewTSeries(col1))
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "column?")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "column?")
			}
		},
	},

	"drop-column": {
		Argsn: 2,
		Doc:   "Remove a column from a table. Returns new table",
		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.Table:
				switch rmCol := arg1.(type) {
				case env.Word:
					return DropColumn(ps, spr, *env.NewString(ps.Idx.GetWord(rmCol.Index)))
				case env.String:
					return DropColumn(ps, spr, rmCol)
				case env.Block:
					return DropColumnBlock(ps, spr, rmCol)
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType, env.BlockType}, "drop-column")
				}
			}
			return MakeArgError(ps, 1, []env.Type{env.TableType}, "drop-column")
		},
	},

	"rename-column!": {
		Argsn: 3,
		Doc:   "Remove a column from a table. Returns new table",
		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.Table:
				switch oldName := arg1.(type) {
				case env.String:
					switch newName := arg2.(type) {
					case env.String:
						return RenameColumn(ps, spr, oldName, newName)
					default:
						return MakeArgError(ps, 2, []env.Type{env.WordType, env.BlockType}, "rename-column")
					}
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.BlockType}, "rename-column")
				}
			}
			return MakeArgError(ps, 1, []env.Type{env.TableType}, "rename-column")
		},
	},

	"gen-column": {
		Argsn: 4,
		Doc:   "Adds a new column to table. Changes in-place and returns the new table.",
		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.Table:
				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}, "gen-column")
						}
					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.", "genadd-umn")
							}
							regexNative, ok := replaceBlock.Series.S[0].(env.Native)
							if !ok {
								return MakeBuiltinError(ps, "First element of replacement block must be a regex object.", "genaddumn")
							}
							regex, ok := regexNative.Value.(*regexp.Regexp)
							if !ok {
								return MakeBuiltinError(ps, "First element of replacement block must be a regex object.", "gen-column")
							}
							replaceStr, ok := replaceBlock.Series.S[1].(env.String)
							if !ok {
								return MakeBuiltinError(ps, "Second element of replacement block must be a string.", "gen-column")
							}
							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}, "gen-column")
						}
					default:
						return MakeArgError(ps, 3, []env.Type{env.BlockType}, "gen-column")
					}
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType}, "gen-column")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "gen-column")
			}
		},
	},

	"update-column!": {
		Argsn: 3,
		Doc:   "Updates all cells in a column by applying a function that receives the cell value and the row.",
		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.Table:
				var colName string
				switch col := arg1.(type) {
				case env.Word:
					colName = ps.Idx.GetWord(col.Index)
				case env.String:
					colName = col.Value
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "update-column!")
				}

				colIdx := slices.Index(spr.Cols, colName)
				if colIdx < 0 {
					return MakeBuiltinError(ps, fmt.Sprintf("Column '%s' not found", colName), "update-column!")
				}

				switch updater := arg2.(type) {
				case env.Function:
					for i := range spr.Rows {
						cell := env.ToRyeValue(spr.Rows[i].Values[colIdx])
						CallFunctionArgs2(updater, ps, cell, spr.Rows[i], ps.Ctx)
						if ps.ErrorFlag {
							return ps.Res
						}
						spr.Rows[i].Values[colIdx] = ps.Res
					}
					return spr
				default:
					return MakeArgError(ps, 3, []env.Type{env.FunctionType}, "update-column!")
				}
			default:
				return MakeNeedsThawedArgError(ps, "update-column!")
			}
		},
	},

	"add-column": {
		Argsn: 3,
		Doc:   "Adds a new column to table with the given data. Returns the modified table.",
		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.Table:
				var colName string
				switch col := arg1.(type) {
				case env.Word:
					colName = ps.Idx.GetWord(col.Index)
				case env.String:
					colName = col.Value
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType}, "add-column")
				}

				numRows := len(spr.Rows)

				switch data := arg2.(type) {
				case env.Block:

					if data.Series.Len() != numRows {
						return MakeBuiltinError(ps, fmt.Sprintf("Column data has %d values but table has %d rows", data.Series.Len(), numRows), "add-column")
					}

					spr.Cols = append(spr.Cols, colName)

					for i, row := range spr.Rows {
						row.Values = append(row.Values, data.Series.S[i])
						spr.Rows[i] = row
					}
					return spr
				case env.List:
					if len(data.Data) != numRows {
						return MakeBuiltinError(ps, fmt.Sprintf("Column data has %d values but table has %d rows", len(data.Data), numRows), "add-column")
					}

					spr.Cols = append(spr.Cols, colName)

					for i, row := range spr.Rows {
						row.Values = append(row.Values, env.ToRyeValue(data.Data[i]))
						spr.Rows[i] = row
					}
					return spr
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType, env.ListType}, "add-column")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "add-column")
			}
		},
	},

	"order-by!": {
		Argsn: 3,
		Doc:   "Sorts row by given column, changes table in place.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			dir, ok := arg2.(env.Word)
			if !ok {
				return MakeArgError(ps, 3, []env.Type{env.WordType}, "sort-by!")
			}
			var dirAsc bool
			if dir.Index == ps.Idx.IndexWord("asc") {
				dirAsc = true
			} else if dir.Index == ps.Idx.IndexWord("desc") {
				dirAsc = false
			} else {
				return MakeBuiltinError(ps, "Direction can be just asc or desc.", "sort-by!")
			}
			switch spr := arg0.(type) {
			case env.Table:
				switch col := arg1.(type) {
				case env.String:
					if dirAsc {
						SortByColumn(ps, &spr, col.Value)
					} else {
						SortByColumnDesc(ps, &spr, col.Value)
					}
					return spr
				case env.Word:
					if dirAsc {
						SortByColumn(ps, &spr, ps.Idx.GetWord(col.Index))
					} else {
						SortByColumnDesc(ps, &spr, ps.Idx.GetWord(col.Index))
					}
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType}, "sort-by!")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "sort-by!")
			}
		},
	},

	"order-by": {
		Argsn: 3,
		Doc:   "Sorts row by given column, changes table in place.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			dir, ok := arg2.(env.Word)
			if !ok {
				return MakeArgError(ps, 3, []env.Type{env.WordType}, "sort-by!")
			}
			var dirAsc bool
			if dir.Index == ps.Idx.IndexWord("asc") {
				dirAsc = true
			} else if dir.Index == ps.Idx.IndexWord("desc") {
				dirAsc = false
			} else {
				return MakeBuiltinError(ps, "Direction can be just asc or desc.", "sort-by!")
			}
			switch spr := arg0.(type) {
			case env.Table:
				copied := make([]env.TableRow, len(spr.Rows))
				copy(copied, spr.Rows)
				newSpr := env.NewTable(spr.Cols)
				newSpr.Rows = copied
				switch col := arg1.(type) {
				case env.String:
					if dirAsc {
						SortByColumn(ps, newSpr, col.Value)
					} else {
						SortByColumnDesc(ps, newSpr, col.Value)
					}
					return *newSpr
				case env.Word:
					if dirAsc {
						SortByColumn(ps, newSpr, ps.Idx.GetWord(col.Index))
					} else {
						SortByColumnDesc(ps, newSpr, ps.Idx.GetWord(col.Index))
					}
					return *newSpr
				default:
					return MakeArgError(ps, 2, []env.Type{env.WordType}, "sort-by!")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "sort-by!")
			}
		},
	},

	"add-indexes!": {
		Argsn: 2,
		Doc:   "Creates an index for all values in the provided columns. Changes in-place and returns the new table.",
		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.Table:
				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-indexes!")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "add-indexes!")
			}
		},
	},

	"indexes?": {
		Argsn: 1,
		Doc:   "Returns the columns that are indexed in a table.",
		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.Table:
				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.TableType}, "indexes?")
			}
		},
	},

	"autotype": {
		Argsn: 2,
		Doc:   "Takes a table 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.Table:
				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.TableType}, "autotype")
			}
		},
	},

	"left-join": {
		Argsn: 4,
		Doc:   "Left joins two tables 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.Table:
				switch spr2 := arg1.(type) {
				case env.Table:
					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.TableType}, "left-join")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "left-join")
			}
		},
	},

	"inner-join": {
		Argsn: 4,
		Doc:   "Inner joins two tables 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.Table:
				switch spr2 := arg1.(type) {
				case env.Table:
					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.TableType}, "inner-join")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "inner-join")
			}
		},
	},

	"group-by": {
		Argsn: 3,
		Doc:   "Groups a table by the given column(s) 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.Table:
				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, []string{ps.Idx.GetWord(col.Index)}, aggregations)
					case env.String:
						return GroupBy(ps, spr, []string{col.Value}, aggregations)
					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)
							case env.Word:
								cols[c] = ps.Idx.GetWord(ww.Index)
							default:
								return MakeBuiltinError(ps, "Block must contain only strings or words for column names", "group-by")
							}
						}
						return GroupBy(ps, spr, cols, aggregations)
					default:
						return MakeArgError(ps, 2, []env.Type{env.WordType, env.StringType, env.BlockType}, "group-by")
					}
				default:
					return MakeArgError(ps, 3, []env.Type{env.BlockType}, "group-by")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "group-by")
			}
		},
	},

	"A1": {
		Argsn: 1,
		Doc:   "Accepts a Table and returns the first row first column cell.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch s0 := arg0.(type) {
			case env.Table:
				r := s0.Rows[0].Values[0]
				return env.ToRyeValue(r)

			default:
				ps.ErrorFlag = true
				return env.NewError("first arg not table")
			}
		},
	},

	"B1": {
		Argsn: 1,
		Doc:   "Accepts a Table and returns the first row second column cell.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch s0 := arg0.(type) {
			case env.Table:
				r := s0.Rows[0].Values[1]
				return env.ToRyeValue(r)

			default:
				ps.ErrorFlag = true
				return env.NewError("first arg not table")
			}
		},
	},

	"A2": {
		Argsn: 1,
		Doc:   "Accepts a Table and returns the second row first column cell.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch s0 := arg0.(type) {
			case env.Table:
				r := s0.Rows[1].Values[0]
				return env.ToRyeValue(r)

			default:
				ps.ErrorFlag = true
				return env.NewError("first arg not table")
			}
		},
	},

	"B2": {
		Argsn: 1,
		Doc:   "Accepts a Table and returns the second row second column cell.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch s0 := arg0.(type) {
			case env.Table:
				r := s0.Rows[1].Values[1]
				return env.ToRyeValue(r)

			default:
				ps.ErrorFlag = true
				return env.NewError("first arg not table")
			}
		},
	},

	"file-uri//Load\\csv": {

		Argsn: 1,
		Doc:   "Loads a .csv file to a table 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:"+err.Error(), "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: "+err.Error(), "Load\\csv")
				}
				if len(rows) == 0 {
					return MakeBuiltinError(ps, "File is empty", "Load\\csv")
				}
				spr := env.NewTable(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.NewTableRow(anyRow, spr))
					}
				}
				return *spr
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "Load\\csv")
			}
		},
	},

	"file-uri//Load\\csv\\": {

		Argsn: 2,
		Doc:   "Loads a .csv file to a table 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:
				switch separator := arg1.(type) {
				case env.String:

					f, err := os.Open(file.GetPath())
					if err != nil {

						return MakeBuiltinError(ps, "Unable to read input file:"+err.Error(), "Load\\csv")
					}
					defer f.Close()

					csvReader := csv.NewReader(f)
					if len(separator.Value) != 1 {
						return MakeBuiltinError(ps, "Separator must be exactly 1 character long", "Load\\csv\\")
					}
					csvReader.Comma = rune(separator.Value[0])
					rows, err := csvReader.ReadAll()
					if err != nil {

						return MakeBuiltinError(ps, "Unable to parse file as CSV: "+err.Error(), "Load\\csv")
					}
					if len(rows) == 0 {
						return MakeBuiltinError(ps, "File is empty", "Load\\csv")
					}
					spr := env.NewTable(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.NewTableRow(anyRow, spr))
						}
					}
					return *spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.StringType}, "Load\\csv\\")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "Load\\csv\\")
			}
		},
	},

	"file-uri//Load\\tsv": {

		Argsn: 1,
		Doc:   "Loads a .csv file to a table 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:"+err.Error(), "Load\\csv")
				}
				defer f.Close()

				csvReader := csv.NewReader(f)
				csvReader.Comma = '\t'
				rows, err := csvReader.ReadAll()
				if err != nil {

					return MakeBuiltinError(ps, "Unable to parse file as CSV: "+err.Error(), "Load\\csv")
				}
				if len(rows) == 0 {
					return MakeBuiltinError(ps, "File is empty", "Load\\csv")
				}
				spr := env.NewTable(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.NewTableRow(anyRow, spr))
					}
				}
				return *spr
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "Load\\csv")
			}
		},
	},

	"file-uri//Save\\csv": {
		Argsn: 2,
		Doc:   "Saves a table 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 file := arg0.(type) {
			case env.Uri:
				switch spr := arg1.(type) {
				case env.Table:

					f, err := os.Create(file.GetPath())
					if err != nil {

						return MakeBuiltinError(ps, "Unable to create input file.", "file-uri//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.", "file-uri//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 string:
								sv = tv
							case int64:
								sv = strconv.Itoa(int(tv))
							case float64:
								sv = strconv.FormatFloat(tv, 'f', -1, 64)
							case env.String:
								sv = tv.Value
							case env.Integer:
								sv = strconv.Itoa(int(tv.Value))
							case env.Decimal:
								sv = fmt.Sprintf("%f", tv.Value)
							}
							if i < cLen {
								strVals[i] = sv
							}
						}
						err := csvWriter.Write(strVals)
						if err != nil {
							return MakeBuiltinError(ps, "Unable to write line: "+strconv.Itoa(ir), "file-uri//Save\\csv")
						}
					}
					csvWriter.Flush()
					f.Close()
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.TableType}, "file-uri//Save\\csv")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "file-uri//Save\\csv")
			}
		},
	},

	"file-uri//Save\\tsv": {
		Argsn: 2,
		Doc:   "Saves a table to a .tsv file.",
		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:
				switch spr := arg1.(type) {
				case env.Table:

					f, err := os.Create(file.GetPath())
					if err != nil {

						return MakeBuiltinError(ps, "Unable to create input file.", "file-uri//Save\\tsv")
					}
					defer f.Close()

					cLen := len(spr.Cols)

					csvWriter := csv.NewWriter(f)
					csvWriter.Comma = '\t'
					err1 := csvWriter.Write(spr.Cols)
					if err1 != nil {
						return MakeBuiltinError(ps, "Unable to create write header.", "file-uri//Save\\tsv")
					}

					for ir, row := range spr.Rows {
						strVals := make([]string, cLen)

						for i, v := range row.Values {
							var sv string
							switch tv := v.(type) {
							case string:
								sv = tv
							case int64:
								sv = strconv.Itoa(int(tv))
							case float64:
								sv = strconv.FormatFloat(tv, 'f', -1, 64)
							case env.String:
								sv = tv.Value
							case env.Integer:
								sv = strconv.Itoa(int(tv.Value))
							case env.Decimal:
								sv = fmt.Sprintf("%f", tv.Value)
							}
							if i < cLen {
								strVals[i] = sv
							}
						}
						err := csvWriter.Write(strVals)
						if err != nil {
							return MakeBuiltinError(ps, "Unable to write line: "+strconv.Itoa(ir), "file-uri//Save\\tsv")
						}
					}
					csvWriter.Flush()
					f.Close()
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.TableType}, "file-uri//Save\\tsv")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "file-uri//Save\\tsv")
			}
		},
	},

	"file-uri//Load\\xlsx": {
		Argsn: 1,
		Doc:   "Loads the first sheet in an .xlsx file to a Table.",
		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 := excelize.OpenFile(file.GetPath())
				if err != nil {
					return MakeBuiltinError(ps, fmt.Sprintf("Unable to open file: %s", err), "Load\\xlsx")
				}
				defer f.Close()

				sheetMap := f.GetSheetMap()
				if len(sheetMap) == 0 {
					return MakeBuiltinError(ps, "No sheets found in file", "Load\\xlsx")
				}

				sheetName := sheetMap[1]
				rows, err := f.Rows(sheetName)
				if err != nil {
					return MakeBuiltinError(ps, fmt.Sprintf("Unable to get rows from sheet: %s", err), "Load\\xlsx")
				}
				rows.Next()
				header, err := rows.Columns()
				if err != nil {
					return MakeBuiltinError(ps, fmt.Sprintf("Unable to get columns from sheet: %s", err), "Load\\xlsx")
				}
				if len(header) == 0 {
					return MakeBuiltinError(ps, "Header row is empty", "Load\\xlsx")
				}
				spr := env.NewTable(header)
				for rows.Next() {
					row, err := rows.Columns()
					if err != nil {
						return MakeBuiltinError(ps, fmt.Sprintf("Unable to get row: %s", err), "Load\\xlsx")
					}
					anyRow := make([]any, len(row))
					for i, v := range row {
						anyRow[i] = *env.NewString(v)
					}

					for i := len(row); i < len(spr.Cols); i++ {
						anyRow[i] = *env.NewString("")
					}
					spr.AddRow(*env.NewTableRow(anyRow, spr))
				}
				return *spr
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "Load\\xlsx")
			}
		},
	},

	"file-uri//Save\\xlsx": {
		Argsn: 2,
		Doc:   "Saves a Table to a .xlsx file.",
		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:
				switch spr := arg1.(type) {
				case env.Table:
					sheetName := "Sheet1"
					f := excelize.NewFile()
					index, err := f.NewSheet(sheetName)
					if err != nil {
						return MakeBuiltinError(ps, fmt.Sprintf("Unable to create new sheet: %s", err), "file-uri//Save\\xlsx")
					}
					err = f.SetSheetRow(sheetName, "A1", &spr.Cols)
					if err != nil {
						return MakeBuiltinError(ps, fmt.Sprintf("Unable to set header row: %s", err), "file-uri//Save\\xlsx")
					}
					for i, row := range spr.Rows {

						rowIndex := i + 2
						vals := make([]any, len(row.Values))
						for j, v := range row.Values {
							switch val := v.(type) {
							case env.String:
								vals[j] = val.Value
							case string:
								vals[j] = val
							case env.Integer:
								vals[j] = val.Value
							case int64:
								vals[j] = val
							case env.Decimal:
								vals[j] = val.Value
							case float64:
								vals[j] = val
							default:
								return MakeBuiltinError(ps, fmt.Sprintf("Unable to save table: unsupported type %T", val), "file-uri//Save\\xlsx")
							}
						}
						err = f.SetSheetRow(sheetName, fmt.Sprintf("A%d", rowIndex), &vals)
						if err != nil {
							return MakeBuiltinError(ps, fmt.Sprintf("Unable to set row %d: %s", rowIndex, err), "file-uri//Save\\xlsx")
						}
					}
					f.SetActiveSheet(index)
					err = f.SaveAs(file.GetPath())
					if err != nil {
						return MakeBuiltinError(ps, fmt.Sprintf("Unable to save table: %s", err), "file-uri//Save\\xlsx")
					}
					return spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.TableType}, "file-uri//Save\\xlsx")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.UriType}, "file-uri//Save\\xlsx")
			}
		},
	},

	"persistent-table": {
		Argsn: 3,
		Doc:   "Creates a persistent table using BadgerDB for storage",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			cols, err := ColNames(ps, arg0, "persistent-table")
			if err != nil {
				return err
			}

			switch dbPath := arg1.(type) {
			case env.String:
				switch tableName := arg2.(type) {
				case env.String:
					pt, err := env.NewPersistentTable(cols, dbPath.Value, tableName.Value)
					if err != nil {
						return MakeBuiltinError(ps, fmt.Sprintf("Failed to create persistent table: %v", err), "persistent-table")
					}
					return pt
				default:
					return MakeArgError(ps, 3, []env.Type{env.StringType}, "persistent-table")
				}
			default:
				return MakeArgError(ps, 2, []env.Type{env.StringType}, "persistent-table")
			}
		},
	},

	"close-persistent-table!": {
		Argsn: 1,
		Doc:   "Closes the BadgerDB connection for a persistent table",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch pt := arg0.(type) {
			case *env.PersistentTable:
				err := pt.Close()
				if err != nil {
					return MakeBuiltinError(ps, fmt.Sprintf("Failed to close persistent table: %v", err), "close-persistent-table!")
				}
				return pt
			default:
				return MakeArgError(ps, 1, []env.Type{env.PersistentTableType}, "close-persistent-table!")
			}
		},
	},

	"parse\\csv": {
		Argsn: 1,
		Doc:   "Parses a CSV string to a table datatype.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch csvData := arg0.(type) {
			case env.String:
				csvReader := csv.NewReader(strings.NewReader(csvData.Value))
				rows, err := csvReader.ReadAll()
				if err != nil {
					return MakeBuiltinError(ps, "Unable to parse string as CSV: "+err.Error(), "parse\\csv")
				}
				if len(rows) == 0 {
					return MakeBuiltinError(ps, "CSV data is empty", "parse\\csv")
				}
				spr := env.NewTable(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.NewTableRow(anyRow, spr))
					}
				}
				return *spr
			default:
				return MakeArgError(ps, 1, []env.Type{env.StringType}, "parse\\csv")
			}
		},
	},

	"parse\\csv\\separator": {
		Argsn: 2,
		Doc:   "Parses a CSV string to a table datatype with a custom separator character.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch csvData := arg0.(type) {
			case env.String:
				switch separator := arg1.(type) {
				case env.String:
					if len(separator.Value) != 1 {
						return MakeBuiltinError(ps, "Separator must be exactly 1 character long", "parse\\csv\\separator")
					}
					csvReader := csv.NewReader(strings.NewReader(csvData.Value))
					csvReader.Comma = rune(separator.Value[0])
					rows, err := csvReader.ReadAll()
					if err != nil {
						return MakeBuiltinError(ps, "Unable to parse string as CSV: "+err.Error(), "parse\\csv\\separator")
					}
					if len(rows) == 0 {
						return MakeBuiltinError(ps, "CSV data is empty", "parse\\csv\\separator")
					}
					spr := env.NewTable(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.NewTableRow(anyRow, spr))
						}
					}
					return *spr
				default:
					return MakeArgError(ps, 2, []env.Type{env.StringType}, "parse\\csv\\separator")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.StringType}, "parse\\csv\\separator")
			}
		},
	},

	"parse\\tsv": {
		Argsn: 1,
		Doc:   "Parses a TSV (tab-separated values) string to a table datatype.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch tsvData := arg0.(type) {
			case env.String:
				csvReader := csv.NewReader(strings.NewReader(tsvData.Value))
				csvReader.Comma = '\t'
				rows, err := csvReader.ReadAll()
				if err != nil {
					return MakeBuiltinError(ps, "Unable to parse string as TSV: "+err.Error(), "parse\\tsv")
				}
				if len(rows) == 0 {
					return MakeBuiltinError(ps, "TSV data is empty", "parse\\tsv")
				}
				spr := env.NewTable(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.NewTableRow(anyRow, spr))
					}
				}
				return *spr
			default:
				return MakeArgError(ps, 1, []env.Type{env.StringType}, "parse\\tsv")
			}
		},
	},

	"format\\csv": {
		Argsn: 1,
		Doc:   "Converts a table to a CSV string.",
		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.Table:
				var buf strings.Builder
				csvWriter := csv.NewWriter(&buf)

				cLen := len(spr.Cols)

				err1 := csvWriter.Write(spr.Cols)
				if err1 != nil {
					return MakeBuiltinError(ps, "Unable to write header.", "format\\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 string:
							sv = tv
						case int64:
							sv = strconv.Itoa(int(tv))
						case float64:
							sv = strconv.FormatFloat(tv, 'f', -1, 64)
						case env.String:
							sv = tv.Value
						case env.Integer:
							sv = strconv.Itoa(int(tv.Value))
						case env.Decimal:
							sv = fmt.Sprintf("%f", tv.Value)
						}
						if i < cLen {
							strVals[i] = sv
						}
					}
					err := csvWriter.Write(strVals)
					if err != nil {
						return MakeBuiltinError(ps, "Unable to write line: "+strconv.Itoa(ir), "format\\csv")
					}
				}
				csvWriter.Flush()
				return *env.NewString(buf.String())
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "format\\csv")
			}
		},
	},

	"format\\tsv": {
		Argsn: 1,
		Doc:   "Converts a table to a TSV string.",
		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.Table:
				var buf strings.Builder
				csvWriter := csv.NewWriter(&buf)
				csvWriter.Comma = '\t'

				cLen := len(spr.Cols)

				err1 := csvWriter.Write(spr.Cols)
				if err1 != nil {
					return MakeBuiltinError(ps, "Unable to write header.", "format\\tsv")
				}

				for ir, row := range spr.Rows {
					strVals := make([]string, cLen)

					for i, v := range row.Values {
						var sv string
						switch tv := v.(type) {
						case string:
							sv = tv
						case int64:
							sv = strconv.Itoa(int(tv))
						case float64:
							sv = strconv.FormatFloat(tv, 'f', -1, 64)
						case env.String:
							sv = tv.Value
						case env.Integer:
							sv = strconv.Itoa(int(tv.Value))
						case env.Decimal:
							sv = fmt.Sprintf("%f", tv.Value)
						}
						if i < cLen {
							strVals[i] = sv
						}
					}
					err := csvWriter.Write(strVals)
					if err != nil {
						return MakeBuiltinError(ps, "Unable to write line: "+strconv.Itoa(ir), "format\\tsv")
					}
				}
				csvWriter.Flush()
				return *env.NewString(buf.String())
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "format\\tsv")
			}
		},
	},

	"parse\\xlsx": {
		Argsn: 1,
		Doc:   "Parses an xlsx binary string or bytes into a table (first sheet).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var data []byte

			switch input := arg0.(type) {
			case env.String:
				data = []byte(input.Value)
			case env.Bytes:
				data = input.Value
			default:
				return MakeArgError(ps, 1, []env.Type{env.StringType, env.BytesType}, "parse\\xlsx")
			}

			tmpFile, err := os.CreateTemp("", "parse_xlsx_*.xlsx")
			if err != nil {
				return MakeBuiltinError(ps, "Unable to create temporary file: "+err.Error(), "parse\\xlsx")
			}
			defer os.Remove(tmpFile.Name())
			defer tmpFile.Close()

			_, err = tmpFile.Write(data)
			if err != nil {
				return MakeBuiltinError(ps, "Unable to write to temporary file: "+err.Error(), "parse\\xlsx")
			}
			tmpFile.Close()

			f, err := excelize.OpenFile(tmpFile.Name())
			if err != nil {
				return MakeBuiltinError(ps, "Unable to open xlsx data: "+err.Error(), "parse\\xlsx")
			}
			defer f.Close()

			sheetMap := f.GetSheetMap()
			if len(sheetMap) == 0 {
				return MakeBuiltinError(ps, "No sheets found in xlsx data", "parse\\xlsx")
			}

			sheetName := sheetMap[1]
			rows, err := f.Rows(sheetName)
			if err != nil {
				return MakeBuiltinError(ps, "Unable to get rows from sheet: "+err.Error(), "parse\\xlsx")
			}
			rows.Next()
			header, err := rows.Columns()
			if err != nil {
				return MakeBuiltinError(ps, "Unable to get columns from sheet: "+err.Error(), "parse\\xlsx")
			}
			if len(header) == 0 {
				return MakeBuiltinError(ps, "Header row is empty", "parse\\xlsx")
			}
			spr := env.NewTable(header)
			for rows.Next() {
				row, err := rows.Columns()
				if err != nil {
					return MakeBuiltinError(ps, "Unable to get row: "+err.Error(), "parse\\xlsx")
				}
				anyRow := make([]any, len(header))
				for i, v := range row {
					if i < len(header) {
						anyRow[i] = *env.NewString(v)
					}
				}

				for i := len(row); i < len(header); i++ {
					anyRow[i] = *env.NewString("")
				}
				spr.AddRow(*env.NewTableRow(anyRow, spr))
			}
			return *spr
		},
	},

	"format\\xlsx": {
		Argsn: 1,
		Doc:   "Converts a table to an XLSX as bytes native 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.Table:
				sheetName := "Sheet1"
				f := excelize.NewFile()
				index, err := f.NewSheet(sheetName)
				if err != nil {
					return MakeBuiltinError(ps, "Unable to create new sheet: "+err.Error(), "format\\xlsx")
				}
				err = f.SetSheetRow(sheetName, "A1", &spr.Cols)
				if err != nil {
					return MakeBuiltinError(ps, "Unable to set header row: "+err.Error(), "format\\xlsx")
				}
				for i, row := range spr.Rows {

					rowIndex := i + 2
					vals := make([]any, len(row.Values))
					for j, v := range row.Values {
						switch val := v.(type) {
						case env.String:
							vals[j] = val.Value
						case string:
							vals[j] = val
						case env.Integer:
							vals[j] = val.Value
						case int64:
							vals[j] = val
						case env.Decimal:
							vals[j] = val.Value
						case float64:
							vals[j] = val
						default:
							return MakeBuiltinError(ps, "Unable to format table: unsupported type "+fmt.Sprintf("%T", val), "format\\xlsx")
						}
					}
					err = f.SetSheetRow(sheetName, fmt.Sprintf("A%d", rowIndex), &vals)
					if err != nil {
						return MakeBuiltinError(ps, "Unable to set row "+strconv.Itoa(rowIndex)+": "+err.Error(), "format\\xlsx")
					}
				}
				f.SetActiveSheet(index)

				tmpFile, err := os.CreateTemp("", "format_xlsx_*.xlsx")
				if err != nil {
					return MakeBuiltinError(ps, "Unable to create temporary file: "+err.Error(), "format\\xlsx")
				}
				defer os.Remove(tmpFile.Name())
				defer tmpFile.Close()

				err = f.SaveAs(tmpFile.Name())
				if err != nil {
					return MakeBuiltinError(ps, "Unable to save xlsx data: "+err.Error(), "format\\xlsx")
				}

				data, err := os.ReadFile(tmpFile.Name())
				if err != nil {
					return MakeBuiltinError(ps, "Unable to read xlsx data: "+err.Error(), "format\\xlsx")
				}

				return *env.NewBytes(data)
			default:
				return MakeArgError(ps, 1, []env.Type{env.TableType}, "format\\xlsx")
			}
		},
	},
}

var Builtins_validation = map[string]*env.Builtin{

	"validate": {
		Argsn: 2,
		Doc:   "Validates and transforms data according to specified rules, returning a dictionary with converted values or an error.",
		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 and transforms data according to specified rules, returning a context object for easy field access.",
		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)
			if env1.FailureFlag {
				return obj
			}
			switch obj1 := obj.(type) {
			case env.Dict:
				return util.Dict2Context(env1, obj1)
			default:
				return obj1
			}
		},
	},
}

var ErrorCreationBuiltins = map[string]*env.Builtin{

	"fail": {
		Argsn: 1,
		Doc:   "Creates an error and sets the failure flag, but continues execution (unlike ^fail).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = true
			return MakeRyeError(ps, arg0, nil)
		},
	},

	"^fail": {
		Argsn: 1,
		Doc:   "Creates an error and immediately returns from the current function with failure state.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = true
			ps.ReturnFlag = true
			return MakeRyeError(ps, arg0, nil)
		},
	},

	"refail": {
		Argsn: 2,
		Doc:   "Re-raises an existing error with additional context. TODO -- duplicate of check",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch er := arg0.(type) {
			case *env.Error:
				ps.FailureFlag = true
				return MakeRyeError(ps, arg1, er)
			default:
				return MakeArgError(ps, 1, []env.Type{env.ErrorType}, "reraise")
			}
		},
	},

	"failure": {
		Argsn: 1,
		Doc:   "Creates an error object without setting any flags (unlike fail and ^fail).",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return MakeRyeError(ps, arg0, nil)
		},
	},

	"empty": {
		Argsn: 0,
		Doc:   "Creates an 404 error object without setting any flags.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			return MakeRyeError(ps, *env.NewInteger(404), nil)
		},
	},

	"failure\\wrap": {
		Argsn: 2,
		Doc:   "Creates a new error that wraps an existing error, allowing for error chaining.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch er := arg1.(type) {
			case *env.Error:
				return MakeRyeError(ps, arg0, er)
			default:
				return MakeArgError(ps, 2, []env.Type{env.ErrorType}, "wrap\\failure")
			}
		},
	},
}

var ErrorHandlingBuiltins = map[string]*env.Builtin{

	"disarm": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Clears the failure flag while preserving the error object, allowing error inspection without propagation.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false
			return arg0
		},
	},

	"check": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Checks if a value is in failure state and wraps it with a new error if so, otherwise returns the original value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {

				switch er := arg0.(type) {
				case *env.Error:
					if er.Status == 0 && er.Message == "" {
						er = nil
					}
					return MakeRyeError(ps, arg1, er)
				case env.Error:

					return MakeRyeError(ps, arg1, &er)
				}
				return env.NewError("Failure flag but value not Failure")
			}
			return arg0
		},
	},

	"^check": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Like 'check' but also sets the return flag to immediately exit the current function.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {
				ps.ReturnFlag = true
				switch er := arg0.(type) {
				case *env.Error:
					if er.Status == 0 && er.Message == "" {
						er = nil
					}
					return MakeRyeError(ps, arg1, er)
				case env.Error:

					return MakeRyeError(ps, arg1, &er)
				}
				return env.NewError("Failure flag but value not Failure")
			}
			return arg0
		},
	},

	"^ensure": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Checks if a value is truthy and returns it if so, otherwise creates an error and immediately returns from the function.",
		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.Object:
				if !util.IsTruthy(cond) {
					ps.FailureFlag = true
					ps.ReturnFlag = true
					return MakeRyeError(ps, arg1, nil)
				} else {
					return arg0
				}
			}
			return arg0
		},
	},

	"ensure": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Checks if a value is truthy and returns it if so, otherwise creates an error with the failure flag set.",
		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.Object:
				if !util.IsTruthy(cond) {
					ps.FailureFlag = true
					return MakeRyeError(ps, arg1, nil)
				} else {
					return arg0
				}
			}
			return arg0
		},
	},

	"requires-one-of": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Validates that a value matches one of the provided options, failing with a descriptive error if not.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch optionsBlock := arg1.(type) {
			case env.Block:

				options := optionsBlock.Series.GetAll()
				for _, option := range options {

					if arg0.GetKind() == option.GetKind() && arg0.Inspect(*ps.Idx) == option.Inspect(*ps.Idx) {
						return arg0
					}
				}

				ps.FailureFlag = true

				valueStr := arg0.Inspect(*ps.Idx)

				// Build error message with options
				var errorMsg string
				if len(options) > 0 {
					optionsStr := "{ "
					for i, opt := range options {
						if i > 0 {
							optionsStr += " "
						}
						optionsStr += opt.Inspect(*ps.Idx)
					}
					optionsStr += " }"
					errorMsg = fmt.Sprintf("Value %s must be one of %s", valueStr, optionsStr)
				} else {
					errorMsg = fmt.Sprintf("Value %s does not match any valid option", valueStr)
				}

				return MakeRyeError(ps, *env.NewString(errorMsg), nil)
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 2, []env.Type{env.BlockType}, "requires-one-of")
			}
		},
	},

	"^requires-one-of": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Validates that a value matches one of the provided options, failing with a descriptive error if not.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch optionsBlock := arg1.(type) {
			case env.Block:

				options := optionsBlock.Series.GetAll()
				for _, option := range options {

					if arg0.GetKind() == option.GetKind() && arg0.Inspect(*ps.Idx) == option.Inspect(*ps.Idx) {
						return arg0
					}
				}

				ps.FailureFlag = true

				valueStr := arg0.Inspect(*ps.Idx)

				// Build error message with options
				var errorMsg string
				if len(options) > 0 {
					optionsStr := "{ "
					for i, opt := range options {
						if i > 0 {
							optionsStr += " "
						}
						optionsStr += opt.Inspect(*ps.Idx)
					}
					optionsStr += " }"
					errorMsg = fmt.Sprintf("Value %s must be one of %s", valueStr, optionsStr)
				} else {
					errorMsg = fmt.Sprintf("Value %s does not match any valid option", valueStr)
				}
				ps.ReturnFlag = true
				return MakeRyeError(ps, *env.NewString(errorMsg), nil)
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 2, []env.Type{env.BlockType}, "requires-one-of")
			}
		},
	},

	"ensure\\with": {
		AcceptFailure: true,
		Argsn:         3,
		Doc:           "Injects a value into a validation block and returns the value if the block is truthy, otherwise creates an error.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg1.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				EvalBlockInj(ps, arg0, true)
				if ps.ErrorFlag {
					ps.Ser = ser
					return ps.Res
				}
				ps.Ser = ser
				if util.IsTruthy(ps.Res) {
					return arg0
				} else {
					ps.FailureFlag = true
					return MakeRyeError(ps, arg2, nil)
				}
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 2, []env.Type{env.BlockType}, "ensure\\with")
			}
		},
	},

	"^ensure\\with": {
		AcceptFailure: true,
		Argsn:         3,
		Doc:           "Like ensure\\with but also sets the return flag to immediately exit the current function.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch bloc := arg1.(type) {
			case env.Block:
				ser := ps.Ser
				ps.Ser = bloc.Series
				EvalBlockInj(ps, arg0, true)
				if ps.ErrorFlag {
					ps.Ser = ser
					ps.ReturnFlag = true
					return ps.Res
				}
				ps.Ser = ser
				if util.IsTruthy(ps.Res) {
					return arg0
				} else {
					ps.FailureFlag = true
					ps.ReturnFlag = true
					return MakeRyeError(ps, arg2, nil)
				}
			default:
				ps.FailureFlag = true
				ps.ReturnFlag = true
				return MakeArgError(ps, 2, []env.Type{env.BlockType}, "^ensure\\with")
			}
		},
	},

	"fix": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Handles errors by executing a block if the value is in failure state, clearing the failure flag.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "fix")
					if ps.ErrorFlag {
						ps.Ser = ser
						return ps.Res
					}
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "fix")
				}
			} else {
				return arg0
			}
		},
	},

	"^fix": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Like 'fix' but also sets the return flag to immediately exit the current function with the handler result.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "^fix")
					ps.Ser = ser
					ps.ReturnFlag = true
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "^fix")
				}
			} else {
				return arg0
			}
		},
	},

	"fix\\either": {
		AcceptFailure: true,
		Argsn:         3,
		Doc:           "Executes one of two blocks depending on whether the value is in failure state.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "fix\\either")
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "fix\\either")
				}
			} else {
				switch bloc := arg2.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "fix\\either")
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 3, []env.Type{env.BlockType}, "fix\\either")
				}
			}
		},
	},

	"fix\\else": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Executes a block if the value is not in failure state, otherwise returns the original value.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if !(ps.FailureFlag || arg0.Type() == env.ErrorType) {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "fix\\else")
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "fix\\else")
				}
			} else {
				return arg0
			}
		},
	},

	"fix\\continue": {
		AcceptFailure: true,
		Argsn:         3,
		Doc:           "Executes one of two blocks depending on whether the value is in failure state, like an error-handling if/else.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if ps.FailureFlag || arg0.Type() == env.ErrorType {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "fix\\continue")
				}
			} else {
				switch bloc := arg2.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 3, []env.Type{env.BlockType}, "fix\\continue")
				}
			}
		},
	},

	"continue": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Executes a block only if the value is not in failure state, opposite of 'fix'.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			if !(ps.FailureFlag || arg0.Type() == env.ErrorType) {
				ps.FailureFlag = false

				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					EvalBlockInj(ps, arg0, true)
					MaybeDisplayFailureOrError(ps, ps.Idx, "continue")
					ps.Ser = ser
					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "continue")
				}
			} else {
				ps.FailureFlag = false
				return arg0
			}
		},
	},

	"^fix\\match": {
		Argsn:         2,
		Doc:           "Error handling switch that matches error codes with handler blocks and sets the return flag.",
		AcceptFailure: true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false

			switch er := arg0.(type) {
			case env.Error, *env.Error:
				switch bloc := arg1.(type) {
				case env.Block:
					var code env.Object
					any_found := false

					for i := 0; i < bloc.Series.Len(); i += 2 {
						if i > bloc.Series.Len()-2 {
							return MakeBuiltinError(ps, "Switch block malformed.", "^fix\\match")
						}

						switch ev := bloc.Series.Get(i).(type) {
						case env.Integer:
							var status int
							if err, ok := er.(env.Error); ok {
								status = err.Status
							} else if errPtr, ok := er.(*env.Error); ok {
								status = errPtr.Status
							}

							if status == int(ev.Value) {
								any_found = true
								code = bloc.Series.Get(i + 1)
							}
						case env.Void:
							if !any_found {
								code = bloc.Series.Get(i + 1)
								any_found = true
							}
						default:
							return MakeBuiltinError(ps, "Invalid type in block series.", "^fix\\match")
						}
					}

					switch cc := code.(type) {
					case env.Block:

						ser := ps.Ser

						ps.Ser = cc.Series

						EvalBlockInj(ps, arg0, true)

						MaybeDisplayFailureOrError(ps, ps.Idx, "fix\\match")

						ps.Ser = ser

						ps.ReturnFlag = true
						return ps.Res
					default:

						ps.FailureFlag = true
						return MakeBuiltinError(ps, "Malformed switch block.", "^fix\\match")
					}
				default:

					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "^fix\\match")
				}
			default:
				return arg0
			}
		},
	},

	"try": {
		Argsn: 1,
		Doc:   "Takes a block of code and does (runs) it.",
		Pure:  true,
		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
				ps.InErrHandler = true
				Eval(ps)

				ps.InErrHandler = false
				ps.ReturnFlag = false
				ps.ErrorFlag = false
				ps.FailureFlag = false

				ps.Ser = ser
				return ps.Res
			default:
				return MakeArgError(ps, 1, []env.Type{env.BlockType}, "try")
			}
		},
	},

	"try-all": {
		Argsn: 1,
		Doc:   "Executes a block and returns a result tuple [success, result], where success is true if no error occurred.",
		Pure:  true,
		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:

				oldSer := ps.Ser
				oldFailureFlag := ps.FailureFlag
				oldErrorFlag := ps.ErrorFlag
				ps.InErrHandler = true

				ps.Ser = bloc.Series
				Eval(ps)
				MaybeDisplayFailureOrError(ps, ps.Idx, "try-all")

				result := ps.Res
				success := !ps.FailureFlag && !ps.ErrorFlag
				ps.InErrHandler = false

				ps.Ser = oldSer
				ps.FailureFlag = oldFailureFlag
				ps.ErrorFlag = oldErrorFlag

				return *env.NewBlock(*env.NewTSeries([]env.Object{
					*env.NewBoolean(success),
					result,
				}))
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.BlockType}, "try-all")
			}
		},
	},

	"try\\in": {
		Argsn: 2,
		Doc:   "Takes a Context and a Block. It Does a block inside a given Context.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch ctx := arg0.(type) {
			case *env.RyeCtx:
				switch bloc := arg1.(type) {
				case env.Block:
					ser := ps.Ser
					ps.Ser = bloc.Series
					ps.InErrHandler = true
					EvalBlockInCtxInj(ps, ctx, nil, false)
					MaybeDisplayFailureOrError(ps, ps.Idx, "try\\in")
					ps.InErrHandler = false
					ps.ReturnFlag = false
					ps.ErrorFlag = false
					ps.FailureFlag = false

					ps.Ser = ser
					return ps.Res
				default:
					ps.ErrorFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "try\\in")
				}
			default:
				ps.ErrorFlag = true
				return MakeArgError(ps, 1, []env.Type{env.ContextType}, "try\\in")
			}
		},
	},

	"finally": {
		Argsn: 2,
		Doc:   "Executes a block and ensures another block is executed afterward, regardless of errors.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch mainBlock := arg0.(type) {
			case env.Block:
				switch finallyBlock := arg1.(type) {
				case env.Block:

					oldSer := ps.Ser
					ps.InErrHandler = true

					ps.Ser = mainBlock.Series
					Eval(ps)
					MaybeDisplayFailureOrError(ps, ps.Idx, "finally")

					result := ps.Res
					hasFailure := ps.FailureFlag
					hasError := ps.ErrorFlag

					ps.Ser = finallyBlock.Series
					ps.FailureFlag = false
					ps.ErrorFlag = false
					ps.InErrHandler = false
					Eval(ps)
					MaybeDisplayFailureOrError(ps, ps.Idx, "finally")

					ps.Res = result
					ps.FailureFlag = hasFailure
					ps.ErrorFlag = hasError

					ps.Ser = oldSer

					return ps.Res
				default:
					ps.FailureFlag = true
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "finally")
				}
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.BlockType}, "finally")
			}
		},
	},

	"retry": {
		Argsn:         2,
		Doc:           "Executes a block and retries it up to N times if it results in a failure.",
		AcceptFailure: true,
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch retries := arg0.(type) {
			case env.Integer:
				switch bloc := arg1.(type) {
				case env.Block:

					ser := ps.Ser

					ps.Ser = bloc.Series
					Eval(ps)
					MaybeDisplayFailureOrError(ps, ps.Idx, "retry")

					if !ps.FailureFlag {
						ps.Ser = ser
						return ps.Res
					}

					result := ps.Res

					for i := int64(1); i < retries.Value; i++ {

						ps.Ser.Reset()
						ps.FailureFlag = false
						ps.ErrorFlag = false

						Eval(ps)
						MaybeDisplayFailureOrError(ps, ps.Idx, "retry")

						if !ps.FailureFlag {
							ps.Ser = ser
							return ps.Res
						}

						result = ps.Res
					}

					ps.Ser = ser
					ps.FailureFlag = true
					return result
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "retry")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "retry")
			}
		},
	},

	"persist": {
		Argsn:         1,
		Doc:           "Executes a block repeatedly until it succeeds (no failure), then returns the successful result. Gives up after 1000 attempts.",
		AcceptFailure: true,
		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

				for attempt := 1; attempt <= 1000; attempt++ {

					ps.Ser = bloc.Series
					ps.Ser.Reset()
					ps.FailureFlag = false
					ps.ErrorFlag = false

					Eval(ps)
					MaybeDisplayFailureOrError(ps, ps.Idx, "persist")

					if !ps.FailureFlag {
						ps.Ser = ser
						return ps.Res
					}

				}

				ps.Ser = ser
				ps.FailureFlag = true
				return MakeRyeError(ps, *env.NewString("Persist failed: Block did not succeed after 1000 attempts"), nil)
			default:
				return MakeArgError(ps, 1, []env.Type{env.BlockType}, "persist")
			}
		},
	},

	"timeout": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Executes a block of code with a timeout, failing if execution exceeds the specified duration in milliseconds.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch ms := arg0.(type) {
			case env.Integer:
				switch bloc := arg1.(type) {
				case env.Block:

					ser := ps.Ser

					resultChan := make(chan env.Object, 1)
					doneChan := make(chan bool, 1)

					psCopy := env.NewProgramStateOLD(bloc.Series, ps.Idx)
					psCopy.Ctx = ps.Ctx
					psCopy.PCtx = ps.PCtx
					psCopy.Gen = ps.Gen

					go func() {
						Eval(psCopy)
						MaybeDisplayFailureOrError(ps, ps.Idx, "timeout")

						resultChan <- psCopy.Res
						doneChan <- psCopy.FailureFlag
					}()

					timeoutDuration := time.Duration(ms.Value) * time.Millisecond

					select {
					case result := <-resultChan:
						ps.FailureFlag = <-doneChan
						ps.Ser = ser
						return result

					case <-time.After(timeoutDuration):
						ps.FailureFlag = true
						ps.Ser = ser
						return MakeRyeError(ps, *env.NewString(fmt.Sprintf("Execution timed out after %d ms", ms.Value)), nil)
					}
				default:
					return MakeArgError(ps, 2, []env.Type{env.BlockType}, "timeout")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.IntegerType}, "timeout")
			}
		},
	},
}

var ErrorInspectionBuiltins = map[string]*env.Builtin{

	"is-error": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Returns true if the value is an error, false otherwise.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false
			switch arg0.(type) {
			case env.Error, *env.Error:
				return *env.NewBoolean(true)
			}
			return *env.NewBoolean(false)
		},
	},

	"error-kind?": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Returns the kind of an error, or void if not an error.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false
			switch err := arg0.(type) {
			case env.Error:
				return *env.NewWord(err.Kind.Index)
			case *env.Error:
				return *env.NewWord(err.Kind.Index)
			}
			return *env.NewVoid()
		},
	},

	"is-error-of-kind": {
		AcceptFailure: true,
		Argsn:         2,
		Doc:           "Returns true if the value is an error of the specified kind, false otherwise.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false

			// Get the kind to check
			var kindIndex int
			switch kind := arg1.(type) {
			case env.Word:
				kindIndex = kind.Index
			case env.Tagword:
				kindIndex = kind.Index
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 2, []env.Type{env.WordType, env.TagwordType}, "is-error-of-kind")
			}

			switch err := arg0.(type) {
			case env.Error:
				return *env.NewBoolean(err.Kind.Index == kindIndex)
			case *env.Error:
				return *env.NewBoolean(err.Kind.Index == kindIndex)
			}

			return *env.NewBoolean(false)
		},
	},

	"cause?": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Extracts the root cause from an error chain by traversing the Parent references.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch er := arg0.(type) {
			case env.Error:

				current := &er
				for current.Parent != nil {
					current = current.Parent
				}
				return *current
			case *env.Error:

				current := er
				for current.Parent != nil {
					current = current.Parent
				}
				return *current
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.ErrorType}, "cause?")
			}
		},
	},

	"status?": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Extracts the numeric status code from an error object.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch er := arg0.(type) {
			case env.Error:
				return *env.NewInteger(int64(er.Status))
			case *env.Error:
				return *env.NewInteger(int64(er.Status))
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.ErrorType}, "status?")
			}
		},
	},

	"message?": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Extracts the message string from an error object.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch er := arg0.(type) {
			case env.Error:
				return *env.NewString(er.Message)
			case *env.Error:
				return *env.NewString(er.Message)
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.ErrorType}, "message?")
			}
		},
	},

	"details?": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Extracts additional details from an error object as a dictionary.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			var originalMap map[string]env.Object
			switch er := arg0.(type) {
			case env.Error:
				originalMap = er.Values
			case *env.Error:
				originalMap = er.Values
			default:
				ps.FailureFlag = true
				return MakeArgError(ps, 1, []env.Type{env.ErrorType}, "details?")
			}

			convertedMap := make(map[string]any)
			for key, value := range originalMap {
				convertedMap[key] = value
			}
			return env.NewDict(convertedMap)
		},
	},

	"has-failed": {
		AcceptFailure: true,
		Argsn:         1,
		Doc:           "Tests if a value is an error object, returning true for errors and false for non-errors.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			ps.FailureFlag = false
			switch arg0.(type) {
			case env.Error, *env.Error:
				return *env.NewBoolean(true)
			}
			return *env.NewBoolean(false)
		},
	},

	"is-failure": {
		Argsn: 1,
		Doc:   "Checks if a value is a failure/error type. Unlike has-failed, this doesn't accept failures - the value must already be disarmed.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch arg0.(type) {
			case env.Error, *env.Error:
				return *env.NewBoolean(true)
			}
			return *env.NewBoolean(false)
		},
	},

	"is-success": {
		Argsn: 1,
		Doc:   "Returns true for any value that is not a failure/error type. The opposite of is-failure.",
		Fn: func(ps *env.ProgramState, arg0 env.Object, arg1 env.Object, arg2 env.Object, arg3 env.Object, arg4 env.Object) env.Object {
			switch arg0.(type) {
			case env.Error, *env.Error:
				return *env.NewBoolean(false)
			}
			return *env.NewBoolean(true)
		},
	},
}

var NoInspectMode bool

var OfferDebuggingOptionsHook func(es *env.ProgramState, genv *env.Idxs, tag string) = func(es *env.ProgramState, genv *env.Idxs, tag string) {}

var ShowResults bool

var VarBuiltins_demo = map[string]*env.VarBuiltin{

	"var-not": {
		Argsn: 1,
		Doc:   "Performs logical negation on boolean values only.",
		Pure:  true,
		Fn: func(env1 *env.ProgramState, args ...env.Object) env.Object {
			switch b := args[0].(type) {
			case env.Boolean:
				return *env.NewBoolean(!b.Value)
			default:
				return MakeArgError(env1, 1, []env.Type{env.BooleanType}, "not")
			}
		},
	},

	"var-and": {
		Argsn: 2,
		Doc:   "Performs a logical AND operation between two boolean values, or a bitwise AND operation between two integer values.",
		Pure:  true,
		Fn: func(ps *env.ProgramState, args ...env.Object) env.Object {
			switch s1 := args[0].(type) {
			case env.Boolean:
				switch s2 := args[1].(type) {
				case env.Boolean:
					return *env.NewBoolean(s1.Value && s2.Value)
				default:
					return MakeArgError(ps, 2, []env.Type{env.BooleanType}, "and")
				}
			case env.Integer:
				switch s2 := args[1].(type) {
				case env.Integer:
					return *env.NewInteger(s1.Value & s2.Value)
				default:
					return MakeArgError(ps, 2, []env.Type{env.IntegerType}, "and")
				}
			default:
				return MakeArgError(ps, 1, []env.Type{env.BooleanType, env.IntegerType}, "and")
			}
		},
	},
}