forthic 0.1.0

data/lib/forthic/global_module.rb

@@ -0,0 +1,2341 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+
+require_relative 'forthic_module'
+require_relative 'forthic_error'
+require_relative 'words/word'
+require_relative 'words/push_value_word'
+require_relative 'words/map_word'
+require_relative 'tokenizer'
+require_relative 'code_location'
+
+module Forthic
+  class GlobalModule < ForthicModule
+    attr_accessor :module_id, :literal_handlers
+
+    def initialize(interp)
+      super("<GLOBAL>", interp)
+      @module_id = "<GLOBAL>-#{rand(1_000_000)}"
+
+      # Set default flags
+      interp.set_flags(@module_id, {
+        with_key: nil,
+        push_error: nil,
+        comparator: nil,
+        push_rest: nil,
+        depth: nil,
+        interps: 1,
+      })
+
+      @literal_handlers = [
+        method(:to_bool),
+        method(:to_float),
+        method(:to_literal_date),
+        method(:to_time),
+        method(:to_int),
+      ]
+
+      # --------------------------------------------------
+      # Base words
+      add_module_word("VARIABLES", method(:word_VARIABLES))
+      add_module_word("!", method(:word_bang))
+      add_module_word("@", method(:word_at))
+      add_module_word("!@", method(:word_bang_at))
+      add_module_word("INTERPRET", method(:word_INTERPRET))
+      add_module_word("EXPORT", method(:word_EXPORT))
+      add_module_word("USE-MODULES", method(:word_USE_MODULES))
+      add_module_word("REC", method(:word_REC))
+      add_module_word("REC@", method(:word_REC_at))
+      add_module_word("<REC!", method(:word_l_REC_bang))
+
+      # --------------------------------------------------
+      # Array/Record words
+      add_module_word("APPEND", method(:word_APPEND))
+      add_module_word("REVERSE", method(:word_REVERSE))
+      add_module_word("UNIQUE", method(:word_UNIQUE))
+      add_module_word("<DEL", method(:word_L_DEL))
+      add_module_word("RELABEL", method(:word_RELABEL))
+      add_module_word("BY-FIELD", method(:word_BY_FIELD))
+      add_module_word("GROUP-BY-FIELD", method(:word_GROUP_BY_FIELD))
+      add_module_word("GROUP-BY", method(:word_GROUP_BY))
+      add_module_word("GROUPS-OF", method(:word_GROUPS_OF))
+      add_module_word("INDEX", method(:word_INDEX))
+      add_module_word("MAP", method(:word_MAP))
+      add_module_word("FOREACH", method(:word_FOREACH))
+      add_module_word("INVERT-KEYS", method(:word_INVERT_KEYS))
+      add_module_word("ZIP", method(:word_ZIP))
+      add_module_word("ZIP-WITH", method(:word_ZIP_WITH))
+      add_module_word("KEYS", method(:word_KEYS))
+      add_module_word("VALUES", method(:word_VALUES))
+      add_module_word("LENGTH", method(:word_LENGTH))
+      add_module_word("RANGE", method(:word_RANGE))
+      add_module_word("SLICE", method(:word_SLICE))
+      add_module_word("DIFFERENCE", method(:word_DIFFERENCE))
+      add_module_word("INTERSECTION", method(:word_INTERSECTION))
+      add_module_word("UNION", method(:word_UNION))
+      add_module_word("SELECT", method(:word_SELECT))
+      add_module_word("TAKE", method(:word_TAKE))
+      add_module_word("DROP", method(:word_DROP))
+      add_module_word("ROTATE", method(:word_ROTATE))
+      add_module_word("ARRAY?", method(:word_ARRAY_q))
+      add_module_word("SHUFFLE", method(:word_SHUFFLE))
+      add_module_word("SORT", method(:word_SORT))
+      add_module_word("FIELD-KEY-FUNC", method(:word_FIELD_KEY_FUNC))
+      add_module_word("NTH", method(:word_NTH))
+      add_module_word("LAST", method(:word_LAST))
+      add_module_word("UNPACK", method(:word_UNPACK))
+      add_module_word("FLATTEN", method(:word_FLATTEN))
+      add_module_word("KEY-OF", method(:word_KEY_OF))
+      add_module_word("REDUCE", method(:word_REDUCE))
+
+      # --------------------------------------------------
+      # Stack words
+      add_module_word("POP", method(:word_POP))
+      add_module_word("DUP", method(:word_DUP))
+      add_module_word("SWAP", method(:word_SWAP))
+
+      # --------------------------------------------------
+      # String words
+      add_module_word(">STR", method(:word_to_STR))
+      add_module_word("CONCAT", method(:word_CONCAT))
+      add_module_word("SPLIT", method(:word_SPLIT))
+      add_module_word("JOIN", method(:word_JOIN))
+      add_module_word("/N", method(:word_slash_N))
+      add_module_word("/R", method(:word_slash_R))
+      add_module_word("/T", method(:word_slash_T))
+      add_module_word("LOWERCASE", method(:word_LOWERCASE))
+      add_module_word("UPPERCASE", method(:word_UPPERCASE))
+      add_module_word("ASCII", method(:word_ASCII))
+      add_module_word("STRIP", method(:word_STRIP))
+      add_module_word("REPLACE", method(:word_REPLACE))
+      add_module_word("RE-MATCH", method(:word_RE_MATCH))
+      add_module_word("RE-MATCH-GROUP", method(:word_RE_MATCH_GROUP))
+      add_module_word("RE-MATCH-ALL", method(:word_RE_MATCH_ALL))
+
+      # --------------------------------------------------
+      # Misc words
+      add_module_word("NULL", method(:word_NULL))
+      add_module_word("DEFAULT", method(:word_DEFAULT))
+      add_module_word("*DEFAULT", method(:word_star_DEFAULT))
+      add_module_word("<REPEAT", method(:word_l_REPEAT))
+      add_module_word(">FIXED", method(:word_to_FIXED))
+      add_module_word(">JSON", method(:word_to_JSON))
+      add_module_word("JSON>", method(:word_JSON_to))
+      add_module_word(".s", method(:word_dot_s))
+      add_module_word(".S", method(:word_dot_S))
+
+      # --------------------------------------------------
+      # Date/time words
+      add_module_word("AM", method(:word_AM))
+      add_module_word("PM", method(:word_PM))
+      add_module_word("NOW", method(:word_NOW))
+      add_module_word(">TIME", method(:word_to_TIME))
+      add_module_word(">DATE", method(:word_to_DATE))
+      add_module_word("TODAY", method(:word_TODAY))
+      add_module_word("MONDAY", method(:word_MONDAY))
+      add_module_word("TUESDAY", method(:word_TUESDAY))
+      add_module_word("WEDNESDAY", method(:word_WEDNESDAY))
+      add_module_word("THURSDAY", method(:word_THURSDAY))
+      add_module_word("FRIDAY", method(:word_FRIDAY))
+      add_module_word("SATURDAY", method(:word_SATURDAY))
+      add_module_word("SUNDAY", method(:word_SUNDAY))
+      add_module_word("ADD-DAYS", method(:word_ADD_DAYS))
+      add_module_word("SUBTRACT-DATES", method(:word_SUBTRACT_DATES))
+      add_module_word("DATE>STR", method(:word_DATE_to_STR))
+      add_module_word("TIME>STR", method(:word_TIME_to_STR))
+      add_module_word("DATE-TIME>DATETIME", method(:word_DATE_TIME_to_DATETIME))
+      add_module_word("DATETIME>TIMESTAMP", method(:word_DATETIME_to_TIMESTAMP))
+      add_module_word("TIMESTAMP>DATETIME", method(:word_TIMESTAMP_to_DATETIME))
+      add_module_word("STR>DATETIME", method(:word_STR_to_DATETIME))
+      add_module_word("STR>TIMESTAMP", method(:word_STR_to_TIMESTAMP))
+
+      # --------------------------------------------------
+      # Math words
+      add_module_word("+", method(:word_plus))
+      add_module_word("-", method(:word_minus))
+      add_module_word("*", method(:word_times))
+      add_module_word("/", method(:word_divide_by))
+      add_module_word("ADD", method(:word_plus))
+      add_module_word("SUBTRACT", method(:word_minus))
+      add_module_word("MULTIPLY", method(:word_times))
+      add_module_word("DIVIDE", method(:word_divide_by))
+      add_module_word("MOD", method(:word_MOD))
+      add_module_word("MEAN", method(:word_MEAN))
+      add_module_word("MAX", method(:word_MAX))
+      add_module_word("MIN", method(:word_MIN))
+      add_module_word("ROUND", method(:word_ROUND))
+      add_module_word("==", method(:word_equal_equal))
+      add_module_word("!=", method(:word_not_equal))
+      add_module_word(">", method(:word_greater_than))
+      add_module_word(">=", method(:word_greater_than_or_equal))
+      add_module_word("<", method(:word_less_than))
+      add_module_word("<=", method(:word_less_than_or_equal))
+      add_module_word("OR", method(:word_OR))
+      add_module_word("AND", method(:word_AND))
+      add_module_word("NOT", method(:word_NOT))
+      add_module_word("IN", method(:word_IN))
+      add_module_word("ANY", method(:word_ANY))
+      add_module_word("ALL", method(:word_ALL))
+      add_module_word(">BOOL", method(:word_to_BOOL))
+      add_module_word(">INT", method(:word_to_INT))
+      add_module_word(">FLOAT", method(:word_to_FLOAT))
+      add_module_word("RANGE-INDEX", method(:word_RANGE_INDEX))
+      add_module_word("INFINITY", method(:word_INFINITY))
+
+      # --------------------------------------------------
+      # Flag words
+      add_module_word("!PUSH-ERROR", method(:word_bang_PUSH_ERROR))
+      add_module_word("!WITH-KEY", method(:word_bang_WITH_KEY))
+      add_module_word("!COMPARATOR", method(:word_bang_COMPARATOR))
+      add_module_word("!PUSH-REST", method(:word_bang_PUSH_REST))
+      add_module_word("!DEPTH", method(:word_bang_DEPTH))
+      add_module_word("!INTERPS", method(:word_bang_INTERPS))
+
+      # --------------------------------------------------
+      # Profiling words
+      add_module_word("PROFILE-START", method(:word_PROFILE_START))
+      add_module_word("PROFILE-TIMESTAMP", method(:word_PROFILE_TIMESTAMP))
+      add_module_word("PROFILE-END", method(:word_PROFILE_END))
+      add_module_word("PROFILE-DATA", method(:word_PROFILE_DATA))
+
+      # --------------------------------------------------
+      # Ruby-specific words
+      add_module_word(">SYM", method(:word_to_SYM))
+
+    end
+
+    def find_word(name)
+      result = super(name)
+      result ||= find_literal_word(name)
+      result
+    end
+
+    def find_literal_word(string)
+      value = nil
+      @literal_handlers.each do |handler|
+        value = handler.call(string)
+        return PushValueWord.new(string, value) unless value.nil?
+      end
+      nil
+    end
+
+    # Literal handlers
+    def to_bool(str_val)
+      return true if str_val == "TRUE"
+      return false if str_val == "FALSE"
+      nil
+    end
+
+    def to_int(str_val)
+      result = Integer(str_val) rescue nil
+      result
+    end
+
+    def to_float(str_val)
+      return nil unless str_val.include?(".")
+      result = Float(str_val) rescue nil
+      result
+    end
+
+    def to_literal_date(str_val)
+      match = str_val.match(/(\d{4})-(\d{2})-(\d{2})/)
+      return nil unless match
+
+      year = match[1].to_i
+      month = match[2].to_i
+      day = match[3].to_i
+      result = Date.new(year, month, day)
+      result
+    end
+
+    def to_time(str_val)
+      match = str_val.match(/(\d{1,2}):(\d{2})/)
+      return nil unless match
+
+      hours = match[1].to_i
+      minutes = match[2].to_i
+      return nil if hours > 23 || minutes >= 60
+
+      result = Time.now
+      result = Time.new(result.year, result.month, result.day, hours, minutes, 0)
+      result
+    end
+
+    # Convenience function to create element word handlers
+    def make_element_word(element_name)
+      proc do |interp|
+        interp.stack_push(element_name)
+        interp.run("Element")
+      end
+    end
+
+    def add_element_word(element_name)
+      add_module_word(element_name, make_element_word(element_name))
+    end
+
+    # Words
+
+    # ( varnames -- )
+    def word_VARIABLES(interp)
+      varnames = interp.stack_pop
+      module_ = interp.cur_module
+      varnames.each do |v|
+        if v.match(/__.*/)
+          raise ForthicError.new(
+            "global_module-696",
+            "word_VARIABLES: variable names cannot begin with '__': '#{v}'",
+            "This is a reserved variable naming convention"
+          )
+        end
+        module_.add_variable(v)
+      end
+    end
+
+    # ( value variable -- )
+    def word_bang(interp)
+      variable = interp.stack_pop
+      value = interp.stack_pop
+      variable.value = value
+    end
+
+    # ( variable -- value )
+    def word_at(interp)
+      variable = interp.stack_pop
+      interp.stack_push(variable.value)
+    end
+
+    # ( value variable -- value )
+    def word_bang_at(interp)
+      variable = interp.stack_pop
+      value = interp.stack_pop
+      variable.value = value
+      interp.stack_push(variable.value)
+    end
+
+    # ( string -- )
+    def word_INTERPRET(interp)
+      string = interp.stack_pop
+      string_location = interp.get_string_location
+      interp.run(string, string_location) if string
+    end
+
+    # ( names -- )
+    def word_EXPORT(interp)
+      names = interp.stack_pop
+      interp.cur_module.add_exportable(names)
+    end
+
+    # ( names -- )
+    def word_USE_MODULES(interp)
+      names = interp.stack_pop
+
+      names.each do |name|
+        module_name, prefix = name.is_a?(Array) ? name : [name, name]
+        mod = interp.find_module(module_name)
+        interp.get_app_module.import_module(prefix, mod, interp)
+      end
+    end
+
+    # ( key_vals -- rec )
+    def word_REC(interp)
+      key_vals = interp.stack_pop || []
+      result = {}
+      key_vals.each do |pair|
+        key, val = pair
+        result[key] = val
+      end
+      interp.stack_push(result)
+    end
+
+    # ( rec field -- value )
+    # ( rec fields -- value )
+    def word_REC_at(interp)
+      field = interp.stack_pop
+      rec = interp.stack_pop
+
+      if rec.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      fields = field.is_a?(Array) ? field : [field]
+      result = drill_for_value(rec, fields)
+      interp.stack_push(result)
+    end
+
+
+    # ( rec value field -- rec )
+    def word_l_REC_bang(interp)
+      field = interp.stack_pop
+      value = interp.stack_pop
+      rec = interp.stack_pop || {}
+
+      fields = field.is_a?(Array) ? field : [field]
+
+      cur_rec = rec
+      fields[0...-1].each do |f|
+        cur_rec[f] ||= {}
+        cur_rec = cur_rec[f]
+      end
+
+      cur_rec[fields[-1]] = value
+      interp.stack_push(rec)
+    end
+
+    # ( array item -- array )
+    # ( record key/val -- record )
+    def word_APPEND(interp)
+      item = interp.stack_pop
+      result = interp.stack_pop
+
+      result ||= []
+
+      if result.is_a?(Array)
+        result.push(item)
+      else
+        result[item[0]] = item[1]
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- record )
+    def word_REVERSE(interp)
+      result = interp.stack_pop
+
+      if result.nil?
+        interp.stack_push(result)
+        return
+      end
+
+      result = result.reverse if result.is_a?(Array)
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    def word_UNIQUE(interp)
+      container = interp.stack_pop
+
+      if container.nil?
+        interp.stack_push(container)
+        return
+      end
+
+      result = container
+      result = container.uniq if container.is_a?(Array)
+
+      interp.stack_push(result)
+    end
+
+    # ( array index -- array )
+    # ( record key -- record )
+    def word_L_DEL(interp)
+      key = interp.stack_pop
+      container = interp.stack_pop
+
+      if container.nil?
+        interp.stack_push(container)
+        return
+      end
+
+      if container.is_a?(Array)
+        container.delete_at(key)
+      else
+        container.delete(key)
+      end
+
+      interp.stack_push(container)
+    end
+
+    # ( array old_keys new_keys -- array )
+    # ( record old_keys new_keys -- record )
+    def word_RELABEL(interp)
+      new_keys = interp.stack_pop
+      old_keys = interp.stack_pop
+      container = interp.stack_pop
+
+      if container.nil?
+        interp.stack_push(container)
+        return
+      end
+
+      raise "RELABEL: old_keys and new_keys must be same length" if old_keys.length != new_keys.length
+
+      new_to_old = {}
+      old_keys.each_with_index do |old_key, i|
+        new_to_old[new_keys[i]] = old_key
+      end
+
+      result = if container.is_a?(Array)
+                 new_to_old.keys.sort.map { |k| container[new_to_old[k]] }
+               else
+                 new_to_old.each_with_object({}) { |(new_key, old_key), res| res[new_key] = container[old_key] }
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array field -- field_to_item )
+    # ( record field -- field_to_item )
+    def word_BY_FIELD(interp)
+      field = interp.stack_pop
+      container = interp.stack_pop
+
+      container ||= []
+
+      values = if container.is_a?(Array)
+                 container
+               else
+                 container.values
+               end
+
+      result = {}
+      values.each do |v|
+        result[v[field]] = v if v
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array field -- field_to_items )
+    # ( record field -- field_to_items )
+    def word_GROUP_BY_FIELD(interp)
+      field = interp.stack_pop
+      container = interp.stack_pop
+
+      container ||= []
+
+      values = if container.is_a?(Array)
+                 container
+               else
+                 container.values
+               end
+
+      result = {}
+      values.each do |v|
+        field_val = v[field]
+        if field_val.is_a?(Array)
+          field_val.each do |fv|
+            result[fv] ||= []
+            result[fv].push(v)
+          end
+        else
+          result[field_val] ||= []
+          result[field_val].push(v)
+        end
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array forthic -- group_to_items )
+    # ( record forthic -- group_to_items )
+    def word_GROUP_BY(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+
+      container = interp.stack_pop
+
+      flags = interp.get_flags(self.module_id)
+
+      container ||= []
+
+      keys, values = if container.is_a?(Array)
+                       [Array.new(container.size) { |i| i }, container]
+                     else
+                       [container.keys, container.values]
+                     end
+
+      result = {}
+      values.each_with_index do |value, i|
+        key = keys[i]
+        interp.stack_push(key) if flags[:with_key]
+        interp.stack_push(value)
+        interp.run(forthic, string_location)
+        group = interp.stack_pop
+        result[group] ||= []
+        result[group].push(value)
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array n -- arrays )
+    # ( record n -- records )
+    def word_GROUPS_OF(interp)
+      size = interp.stack_pop
+      container = interp.stack_pop
+      raise "GROUPS-OF requires group size > 0" if size <= 0
+
+      container ||= []
+      result = if container.is_a?(Array)
+                 group_items(container, size)
+               else
+                 keys = container.keys
+                 key_groups = group_items(keys, size)
+                 key_groups.map { |ks| extract_rec(container, ks) }
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array forthic -- record )
+    def word_INDEX(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+      items = interp.stack_pop
+
+      if !items
+        interp.stack_push(items)
+        return
+      end
+
+      result = {}
+      items.each do |item|
+        interp.stack_push(item)
+        interp.run(forthic, string_location)
+        keys = interp.stack_pop
+        keys.each do |k|
+          lowercased_key = k.downcase
+          if result[lowercased_key]
+            result[lowercased_key].push(item)
+          else
+            result[lowercased_key] = [item]
+          end
+        end
+      end
+      interp.stack_push(result)
+    end
+
+    # ( items forthic -- [ ? ] )
+    def word_MAP(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+      items = interp.stack_pop
+      flags = interp.get_flags(self.module_id)
+
+      map_word = MapWord.new(items, forthic, string_location, flags)
+      map_word.execute(interp)
+    end
+
+    # ( items forthic -- )
+    def word_FOREACH(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+
+      items = interp.stack_pop
+      flags = interp.get_flags(self.module_id)
+
+      if !items
+        interp.stack_push(items)
+        return
+      end
+
+      errors = []
+      if items.is_a?(Array)
+        items.each_with_index do |item, i|
+          if flags[:with_key]
+            interp.stack_push(i)
+          end
+          interp.stack_push(item)
+          if flags[:push_error]
+            errors.push(execute_returning_error(interp, forthic, string_location))
+          else
+            interp.run(forthic, string_location)
+          end
+        end
+      else
+        items.each do |k, item|
+          if flags[:with_key]
+            interp.stack_push(k)
+          end
+          interp.stack_push(item)
+          if flags[:push_error]
+            errors.push(execute_returning_error(interp, forthic, string_location))
+          else
+            interp.run(forthic, string_location)
+          end
+        end
+      end
+
+      if flags[:push_error]
+        interp.stack_push(errors)
+      end
+    end
+
+    # ( record -- record )
+    def word_INVERT_KEYS(interp)
+      record = interp.stack_pop
+      result = {}
+      record.each do |first_key, sub_record|
+        sub_record.each do |second_key, value|
+          result[second_key] ||= {}
+          result[second_key][first_key] = value
+        end
+      end
+      interp.stack_push(result)
+    end
+
+    # ( array1 array2 -- array )
+    # ( record1 record2 -- record )
+    def word_ZIP(interp)
+      container2 = interp.stack_pop
+      container1 = interp.stack_pop
+
+      container1 ||= []
+      container2 ||= []
+
+      result = if container2.is_a?(Array)
+                 container1.map.with_index { |v, i| [v, container2[i]] }
+               else
+                 container1.each_with_object({}) { |(k, v), res| res[k] = [v, container2[k]] }
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array1 array2 forthic -- array )
+    # ( record1 record2 forthic -- record )
+    def word_ZIP_WITH(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+
+      container2 = interp.stack_pop
+      container1 = interp.stack_pop
+
+      container1 ||= []
+      container2 ||= []
+
+      result = if container2.is_a?(Array)
+                 container1.map.with_index do |v, i|
+                   interp.stack_push(v)
+                   interp.stack_push(container2[i])
+                   interp.run(forthic, string_location)
+                   interp.stack_pop
+                 end
+               else
+                 container1.each_with_object({}) do |(k, v), res|
+                   interp.stack_push(v)
+                   interp.stack_push(container2[k])
+                   interp.run(forthic, string_location)
+                   res[k] = interp.stack_pop
+                 end
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- array )
+    def word_KEYS(interp)
+      container = interp.stack_pop
+
+      container ||= []
+
+      result = if container.is_a?(Array)
+                 container.each_index.to_a
+               else
+                 container.keys
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- array )
+    def word_VALUES(interp)
+      container = interp.stack_pop
+
+      container ||= []
+
+      result = if container.is_a?(Array)
+                 container
+               else
+                 container.values
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- length )
+    # ( record -- length )
+    def word_LENGTH(interp)
+      container = interp.stack_pop
+
+      if container.nil?
+        interp.stack_push(container)
+        return
+      end
+
+      result = container.length
+      interp.stack_push(result)
+    end
+
+    # ( array start end -- array )
+    # ( record start end -- record )
+    def word_RANGE(interp)
+      fend = interp.stack_pop
+      fend_string_location = interp.get_string_location
+
+      fstart = interp.stack_pop
+      fstart_string_location = interp.get_string_location
+
+      array = interp.stack_pop
+
+      array ||= []
+
+      start_found = false
+      end_found = false
+
+      start_index = nil
+      end_index = nil
+
+      array.each_with_index do |item, index|
+        unless start_found
+          interp.stack_push(item)
+          interp.run(fstart, fstart_string_location)
+          start_found = interp.stack_pop
+          start_index = index if start_found
+        end
+
+        if start_found && !end_found
+          interp.stack_push(item)
+          interp.run(fend, fend_string_location)
+          end_found = interp.stack_pop
+          end_index = index if end_found
+          break if end_found
+        end
+      end
+
+      interp.stack_push([start_index, end_index])
+    end
+
+    # ( array start end -- array )
+    # ( record start end -- record )
+    def word_SLICE(interp)
+      fend = interp.stack_pop.to_i
+      fstart = interp.stack_pop.to_i
+      container = interp.stack_pop
+
+      container ||= []
+
+      length = container.length
+
+      start = normalize_index(fstart, length)
+      fend = normalize_index(fend, length)
+
+      step = 1
+      step = -1 if start > fend
+
+      indexes = [start]
+      indexes = [] if start < 0 || start >= length
+
+      while start != fend
+        start += step
+        if start < 0 || start >= length
+          indexes.push(nil)
+        else
+          indexes.push(start)
+        end
+      end
+
+      result = if container.is_a?(Array)
+                 indexes.map { |i| i.nil? ? nil : container[i] }
+               else
+                 keys = container.keys.sort
+                 indexes.each_with_object({}) do |i, res|
+                   next if i.nil?
+
+                   k = keys[i]
+                   res[k] = container[k]
+                 end
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( larray rarray -- array )
+    # ( lrecord rrecord -- record )
+    def word_DIFFERENCE(interp)
+      rcontainer = interp.stack_pop
+      lcontainer = interp.stack_pop
+
+      lcontainer ||= []
+      rcontainer ||= []
+
+      result = if rcontainer.is_a?(Array)
+                 lcontainer - rcontainer
+               else
+                 diff = lcontainer.keys - rcontainer.keys
+                 diff.each_with_object({}) { |k, res| res[k] = lcontainer[k] }
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( larray rarray -- array )
+    # ( lrecord rrecord -- record )
+    def word_INTERSECTION(interp)
+      rcontainer = interp.stack_pop
+      lcontainer = interp.stack_pop
+
+      lcontainer ||= []
+      rcontainer ||= []
+
+      result = if rcontainer.is_a?(Array)
+                 lcontainer & rcontainer
+               else
+                 lkeys = lcontainer.keys
+                 rkeys = rcontainer.keys
+
+                 intersect = lkeys & rkeys
+                 intersect.each_with_object({}) { |k, res| res[k] = lcontainer[k] }
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( larray rarray -- array )
+    # ( lrecord rrecord -- record )
+    def word_UNION(interp)
+      rcontainer = interp.stack_pop
+      lcontainer = interp.stack_pop
+
+      lcontainer ||= []
+      rcontainer ||= []
+
+      result = if rcontainer.is_a?(Array)
+                 lcontainer | rcontainer
+               else
+                 lkeys = lcontainer.keys
+                 rkeys = rcontainer.keys
+
+                 keys = lkeys | rkeys
+                 keys.each_with_object({}) do |k, res|
+                   val = lcontainer[k]
+                   val = rcontainer[k] if val.nil?
+                   res[k] = val
+                 end
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( larray forthic -- array )
+    # ( lrecord forthic -- record )
+    def word_SELECT(interp)
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+
+      container = interp.stack_pop
+      flags = interp.get_flags(self.module_id)
+
+      if !container
+        interp.stack_push(container)
+        return
+      end
+
+      result = nil
+      if container.is_a?(Array)
+        result = []
+        container.each_with_index do |item, i|
+          interp.stack_push(i) if flags[:with_key]
+          interp.stack_push(item)
+          interp.run(forthic, string_location)
+          should_select = interp.stack_pop
+          result.push(item) if should_select
+        end
+      else
+        result = {}
+        container.each do |k, v|
+          interp.stack_push(k) if flags[:with_key]
+          interp.stack_push(v)
+          interp.run(forthic, string_location)
+          should_select = interp.stack_pop
+          result[k] = v if should_select
+        end
+      end
+      interp.stack_push(result)
+    end
+
+    # ( array n -- taken rest )
+    # ( record n -- taken rest )
+    def word_TAKE(interp)
+      n = interp.stack_pop
+      container = interp.stack_pop
+      flags = interp.get_flags(self.module_id)
+
+      container ||= []
+
+      taken = nil
+      rest = nil
+
+      if container.is_a?(Array)
+        taken = container[0...n]
+        rest = container[n..-1]
+      else
+        keys = container.keys.sort
+        taken_keys = keys[0...n]
+        rest_keys = keys[n..-1]
+        taken = taken_keys.each_with_object({}) { |k, res| res[k] = container[k] }
+        rest = rest_keys.each_with_object({}) { |k, res| res[k] = container[k] }
+      end
+
+      interp.stack_push(taken)
+      interp.stack_push(rest) if flags[:push_rest]
+    end
+
+    # ( array n -- array )
+    # ( record n -- record )
+    def word_DROP(interp)
+      n = interp.stack_pop
+      container = interp.stack_pop
+
+      if !container
+        interp.stack_push(container)
+        return
+      end
+
+      result = nil
+      if container.is_a?(Array)
+        result = container[n..-1]
+      else
+        keys = container.keys.sort
+        rest_keys = keys[n..-1]
+        result = rest_keys.each_with_object({}) { |k, res| res[k] = container[k] }
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- record )
+    def word_ROTATE(interp)
+      container = interp.stack_pop
+
+      result = container
+      if !container
+        result = container
+      elsif container.is_a?(Array)
+        result = container
+        if container.length > 0
+          val = result.pop
+          result.unshift(val)
+        end
+      else
+        result = container
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( val -- bool )
+    def word_ARRAY_q(interp)
+      val = interp.stack_pop
+      result = val.is_a?(Array)
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- record )
+    def word_SHUFFLE(interp)
+      container = interp.stack_pop
+
+      if !container
+        interp.stack_push(container)
+        return
+      end
+
+      result = container
+      if container.is_a?(Array)
+        result = container.shuffle
+      else
+        result = container
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- array )
+    # ( record -- record )
+    def word_SORT(interp)
+      flag_string_position = interp.get_string_location
+      container = interp.stack_pop
+
+      flags = interp.get_flags(self.module_id)
+      comparator = flags[:comparator]
+
+      container ||= []
+      unless container.is_a?(Array)
+        interp.stack_push(container)
+        return
+      end
+
+
+      # Figure out what to do
+      result = if comparator.is_a?(String)
+                 sort_with_forthic(interp, comparator, flag_string_position, container)
+               elsif comparator.nil?
+                 sort_without_comparator(container)
+               else
+                 sort_with_key_func(container, comparator)
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( field -- key_func )
+    def word_FIELD_KEY_FUNC(interp)
+      field = interp.stack_pop
+
+      result = lambda do |record|
+        record[field]
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array n -- item )
+    # ( record n -- value )
+    def word_NTH(interp)
+      n = interp.stack_pop
+      container = interp.stack_pop
+
+      if n.nil? || !container
+        interp.stack_push(nil)
+        return
+      end
+
+      result = nil
+      if container.is_a?(Array)
+        if n < 0 || n >= container.length
+          interp.stack_push(nil)
+          return
+        end
+        result = container[n]
+      else
+        if n < 0 || n >= container.keys.length
+          interp.stack_push(nil)
+          return
+        end
+        keys = container.keys.sort
+        key = keys[n]
+        result = container[key]
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- item )
+    # ( record -- value )
+    def word_LAST(interp)
+      container = interp.stack_pop
+
+      if !container
+        interp.stack_push(nil)
+        return
+      end
+
+      result = nil
+      if container.is_a?(Array)
+        if container.length == 0
+          result = nil
+        else
+          result = container[container.length - 1]
+        end
+      else
+        keys = container.keys.sort
+        if keys.length == 0
+          result = nil
+        else
+          result = container[keys[keys.length - 1]]
+        end
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( array -- a1 a2 .. an )
+    # ( record -- v1 v2 .. vn )
+    def word_UNPACK(interp)
+      container = interp.stack_pop
+
+      container = [] unless container
+
+      if container.is_a?(Array)
+        container.each do |item|
+          interp.stack_push(item)
+        end
+      else
+        keys = container.keys.sort
+        keys.each do |k|
+          interp.stack_push(container[k])
+        end
+      end
+    end
+
+    # ( array -- array )
+    # ( record -- record )
+    def word_FLATTEN(interp)
+      nested = interp.stack_pop
+      flags = interp.get_flags(self.module_id)
+
+      nested ||= []
+      depth = flags[:depth]
+
+      result = if nested.is_a?(Array)
+                 flatten_array(nested, depth)
+               else
+                 flatten_record(nested, depth, {}, [])
+               end
+
+      interp.stack_push(result)
+    end
+
+    # ( array item -- index )
+    # ( record item -- key )
+    def word_KEY_OF(interp)
+      item = interp.stack_pop
+      container = interp.stack_pop
+
+      container ||= []
+
+      result = nil
+      if container.is_a?(Array)
+        index = container.index(item)
+        # If index is nil or < 0, return nil
+        result = index.nil? || index < 0 ? nil : index
+      else
+        keys = container.keys
+        keys.each do |k|
+          v = container[k]
+          if v == item
+            result = k
+            break
+          end
+        end
+      end
+
+      interp.stack_push(result)
+    end
+
+      # ( array init forthic -- value )
+      # ( record init forthic -- value )
+      def word_REDUCE(interp)
+        forthic = interp.stack_pop
+        string_location = interp.get_string_location
+
+        initial = interp.stack_pop
+        container = interp.stack_pop
+
+        container ||= []
+
+        result = nil
+        if container.is_a?(Array)
+          interp.stack_push(initial)
+          container.each do |item|
+            interp.stack_push(item)
+            interp.run(forthic, string_location)
+          end
+          result = interp.stack_pop
+        else
+          interp.stack_push(initial)
+          container.each do |k, v|
+            interp.stack_push(v)
+            interp.run(forthic, string_location)
+          end
+          result = interp.stack_pop
+        end
+
+        interp.stack_push(result)
+      end
+
+
+    # ( a -- )
+    def word_POP(interp)
+      interp.stack_pop
+    end
+
+    # ( a -- a a )
+    def word_DUP(interp)
+      a = interp.stack_pop
+      interp.stack_push(a)
+      interp.stack_push(a)
+    end
+
+    # ( a b -- b a )
+    def word_SWAP(interp)
+      b = interp.stack_pop
+      a = interp.stack_pop
+      interp.stack_push(b)
+      interp.stack_push(a)
+    end
+
+    # ( item -- str )
+    def word_to_STR(interp)
+      item = interp.stack_pop
+      interp.stack_push(item.to_s)
+    end
+
+    # ( str1 str2 -- str )
+    # ( array_of_str -- str )
+    def word_CONCAT(interp)
+      str2 = interp.stack_pop
+      array = str2.is_a?(Array) ? str2 : [interp.stack_pop, str2]
+      result = array.join("")
+      interp.stack_push(result)
+    end
+
+    # ( string sep -- items )
+    def word_SPLIT(interp)
+      sep = interp.stack_pop
+      string = interp.stack_pop
+
+      if !string
+        string = ""
+      end
+
+      result = string.split(sep)
+      interp.stack_push(result)
+    end
+
+    # ( strings sep -- string )
+    def word_JOIN(interp)
+      sep = interp.stack_pop
+      strings = interp.stack_pop
+
+      if !strings
+        strings = []
+      end
+
+      result = strings.join(sep)
+      interp.stack_push(result)
+    end
+
+    # ( -- char )
+    def word_slash_N(interp)
+      interp.stack_push("\n")
+    end
+
+    # ( -- char )
+    def word_slash_R(interp)
+      interp.stack_push("\r")
+    end
+
+    # ( -- char )
+    def word_slash_T(interp)
+      interp.stack_push("\t")
+    end
+
+    # ( A -- a )
+    def word_LOWERCASE(interp)
+      string = interp.stack_pop
+      result = string ? string.downcase : ""
+      interp.stack_push(result)
+    end
+
+    # ( a -- A )
+    def word_UPPERCASE(interp)
+      string = interp.stack_pop
+      result = string ? string.upcase : ""
+      interp.stack_push(result)
+    end
+
+    # ( string -- string )
+    def word_ASCII(interp)
+      string = interp.stack_pop
+
+      if !string
+        string = ""
+      end
+
+      result = ""
+      string.each_char do |ch|
+        result += ch if ch.ord < 256
+      end
+      interp.stack_push(result)
+    end
+
+    # ( string -- string )
+    def word_STRIP(interp)
+      string = interp.stack_pop
+      result = string ? string.strip : ""
+      interp.stack_push(result)
+    end
+
+    # ( string text replace -- string )
+    def word_REPLACE(interp)
+      replace = interp.stack_pop
+      text = interp.stack_pop
+      string = interp.stack_pop
+
+      result = string
+      if string
+        pattern = Regexp.new(text)
+        result = string.gsub(pattern, replace)
+      end
+      interp.stack_push(result)
+    end
+
+    # ( string pattern -- match )
+    def word_RE_MATCH(interp)
+      pattern = interp.stack_pop
+      string = interp.stack_pop
+
+      re_pattern = Regexp.new(pattern)
+      result = false
+      if string
+        result = string.match(re_pattern)
+      end
+      interp.stack_push(result)
+    end
+
+    # ( match num -- string )
+    def word_RE_MATCH_GROUP(interp)
+      num = interp.stack_pop
+      match = interp.stack_pop
+      result = nil
+      if match
+        result = match[num]
+      end
+      interp.stack_push(result)
+    end
+
+    # ( string pattern -- matches )
+    def word_RE_MATCH_ALL(interp)
+      pattern = interp.stack_pop
+      string = interp.stack_pop
+
+      re_pattern = Regexp.new(pattern)
+      matches = []
+      if string
+        matches = string.scan(re_pattern)
+      end
+      result = matches.map { |m| m[0] }
+      interp.stack_push(result)
+    end
+
+    # ( -- nil )
+    def word_NULL(interp)
+      interp.stack_push(nil)
+    end
+
+    # ( value default -- value )
+    def word_DEFAULT(interp)
+      default_value = interp.stack_pop
+      value = interp.stack_pop
+      result = value.nil? || value == "" ? default_value : value
+      interp.stack_push(result)
+    end
+
+    # ( value default_forthic -- value )
+    def word_star_DEFAULT(interp)
+      default_forthic = interp.stack_pop
+      value = interp.stack_pop
+
+      if value.nil? || value == ""
+        interp.run(default_forthic)
+        value = interp.stack_pop
+      end
+      interp.stack_push(value)
+    end
+
+    # ( item forthic num-times -- ? )
+    def word_l_REPEAT(interp)
+      num_times = interp.stack_pop
+      forthic = interp.stack_pop
+      string_location = interp.get_string_location
+
+      num_times.times do
+        item = interp.stack_pop
+        interp.stack_push(item)
+
+        interp.run(forthic, string_location)
+        res = interp.stack_pop
+
+        interp.stack_push(item)
+        interp.stack_push(res)
+      end
+    end
+
+    # ( value num_places -- str )
+    def word_to_FIXED(interp)
+      num_places = interp.stack_pop
+      value = interp.stack_pop
+      result = value
+      if value.nil?
+        result = ""
+      elsif !value.is_a?(Numeric)
+        result = value
+      else
+        # Round value to num_places
+        result = value.round(num_places)
+      end
+      interp.stack_push(result.to_s)
+    end
+
+    # ( object -- json )
+    def word_to_JSON(interp)
+      object = interp.stack_pop
+      result = object.to_json
+      interp.stack_push(result)
+    end
+
+    # ( json -- object )
+    def word_JSON_to(interp)
+      json = interp.stack_pop
+      result = JSON.parse(json)
+      interp.stack_push(result)
+    end
+
+    # ( -- )
+    def word_dot_s(interp)
+      stack = interp.stack
+      puts "===> Stack <==="
+      if stack.length > 0
+        p stack[stack.length - 1]
+      else
+        puts "<STACK EMPTY>"
+      end
+      interp.halt
+    end
+
+    # ( -- )
+    def word_dot_S(interp)
+      # Print full stack in reverse with index, pretty printing stack value
+      puts "===> Stack <==="
+      # Get reversed stack
+      reversed_stack = interp.stack.reverse
+      reversed_stack.each_with_index do |item, i|
+        puts "#{i}: #{item.inspect}"
+      end
+    end
+
+
+    # ( time -- time )
+    def word_AM(interp)
+      time = interp.stack_pop
+      raise "AM expecting a time" unless time.is_a?(Time)
+
+      result = time
+      if time.hour >= 12
+        result = Time.new(time.year, time.month, time.day, time.hour - 12, time.min, time.sec)
+      end
+      interp.stack_push(result)
+    end
+
+    # ( time -- time )
+    def word_PM(interp)
+      time = interp.stack_pop
+      raise "PM expecting a time" unless time.is_a?(Time)
+
+      result = time
+      if time.hour < 12
+        result = Time.new(time.year, time.month, time.day, time.hour + 12, time.min, time.sec)
+      end
+      interp.stack_push(result)
+    end
+
+    # ( -- time )
+    def word_NOW(interp)
+      result = Time.now
+      interp.stack_push(result)
+    end
+
+    # ( obj -- time )
+    def word_to_TIME(interp)
+      obj = interp.stack_pop
+      result = nil
+      if obj.is_a?(Time)
+        result = obj
+      else
+        result = Time.parse(obj.to_s)
+      end
+      interp.stack_push(result)
+    end
+
+
+    # ( obj -- date )
+    def word_to_DATE(interp)
+      obj = interp.stack_pop
+      result = nil
+      if obj.is_a?(Date)
+        result = obj
+      else
+        result = Date.parse(obj.to_s)
+      end
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_TODAY(interp)
+      result = Date.today
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_MONDAY(interp)
+      result = get_day_this_week(0)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_TUESDAY(interp)
+      result = get_day_this_week(1)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_WEDNESDAY(interp)
+      result = get_day_this_week(2)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_THURSDAY(interp)
+      result = get_day_this_week(3)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_FRIDAY(interp)
+      result = get_day_this_week(4)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_SATURDAY(interp)
+      result = get_day_this_week(5)
+      interp.stack_push(result)
+    end
+
+    # ( -- date )
+    def word_SUNDAY(interp)
+      result = get_day_this_week(6)
+      interp.stack_push(result)
+    end
+
+    # ( date num-days -- date )
+    def word_ADD_DAYS(interp)
+      num_days = interp.stack_pop
+      date = interp.stack_pop
+
+      result = date + num_days
+      interp.stack_push(result)
+    end
+
+    # ( l_date r_date -- num_days )
+    def word_SUBTRACT_DATES(interp)
+      r_date = interp.stack_pop
+      l_date = interp.stack_pop
+      result = (l_date - r_date).to_i
+      interp.stack_push(result)
+    end
+
+    # ( a b -- a+b )
+    # ( items -- sum )
+    def word_plus(interp)
+      items = interp.stack_pop
+
+      if items.is_a?(Array)
+        sum = 0
+        items.each do |item|
+          sum += item
+        end
+        interp.stack_push(sum)
+      else
+        b = items
+        a = interp.stack_pop
+        interp.stack_push(a + b)
+      end
+    end
+
+    # ( a b -- a - b )
+    def word_minus(interp)
+      b = interp.stack_pop
+      a = interp.stack_pop
+      interp.stack_push(a - b)
+    end
+
+    # ( a b -- a*b )
+    def word_times(interp)
+      b = interp.stack_pop
+      result = 1
+      numbers = []
+
+      if b.is_a?(Array)
+        numbers = b
+      else
+        a = interp.stack_pop
+        numbers = [a, b]
+      end
+
+      numbers.each do |num|
+        if num.nil?
+          interp.stack_push(nil)
+          return
+        end
+        result *= num
+      end
+
+      interp.stack_push(result)
+    end
+
+    # ( a b -- a/b )
+    def word_divide_by(interp)
+      b = interp.stack_pop
+      a = interp.stack_pop
+      result = a / b
+      interp.stack_push(result)
+    end
+
+    # ( value mod -- remainder )
+    def word_MOD(interp)
+      mod = interp.stack_pop
+      value = interp.stack_pop
+      result = value % mod
+      interp.stack_push(result)
+    end
+
+    # ( numbers -- mean )
+    # ( records -- mean_record )
+    def word_MEAN(interp)
+      values = interp.stack_pop
+
+      if !values || values.empty?
+        interp.stack_push(0)
+        return
+      end
+
+      result = compute_mean(values)
+      interp.stack_push(result)
+    end
+
+    # ( num1 num2 -- num )
+    # ( numbers -- num )
+    def word_MAX(interp)
+      num2 = interp.stack_pop
+
+      numbers = []
+      if num2.is_a?(Array)
+        numbers = num2
+      else
+        num1 = interp.stack_pop
+        numbers = [num1, num2]
+      end
+
+      interp.stack_push(numbers.max)
+    end
+
+    # ( num1 num2 -- num )
+    # ( numbers -- num )
+    def word_MIN(interp)
+      num2 = interp.stack_pop
+
+      numbers = []
+      if num2.is_a?(Array)
+        numbers = num2
+      else
+        num1 = interp.stack_pop
+        numbers = [num1, num2]
+      end
+
+      interp.stack_push(numbers.min)
+    end
+
+    # ( a -- a )
+    def word_ROUND(interp)
+      a = interp.stack_pop
+      result = a.round
+      interp.stack_push(result)
+    end
+
+    # ( a b -- a == b )
+    # ( items -- all_equal )
+    def word_equal_equal(interp)
+      items = interp.stack_pop
+
+      if items.is_a?(Array)
+        all_equal = items.all? { |item| item == items[0] }
+        interp.stack_push(all_equal)
+      else
+        b = items
+        a = interp.stack_pop
+        interp.stack_push(a == b)
+      end
+    end
+
+    # ( a b -- a != b )
+    # ( items -- all_not_equal )
+    def word_not_equal(interp)
+      items = interp.stack_pop
+
+      if items.is_a?(Array)
+        all_not_equal = items.all? { |item| item != items[0] }
+        interp.stack_push(all_not_equal)
+      else
+        b = items
+        a = interp.stack_pop
+        interp.stack_push(a != b)
+      end
+    end
+
+    # ( l r -- bool )
+    def word_greater_than(interp)
+      r = interp.stack_pop
+      l = interp.stack_pop
+
+      if l.nil? || r.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      result = l > r
+      interp.stack_push(result)
+    end
+
+    # ( l r -- bool )
+    def word_greater_than_or_equal(interp)
+      r = interp.stack_pop
+      l = interp.stack_pop
+
+      if l.nil? || r.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      result = l >= r
+      interp.stack_push(result)
+    end
+
+    # ( l r -- bool )
+    def word_less_than(interp)
+      r = interp.stack_pop
+      l = interp.stack_pop
+
+      if l.nil? || r.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      result = l < r
+      interp.stack_push(result)
+    end
+
+    # ( l r -- bool )
+    # ( items -- bool )
+    def word_OR(interp)
+      r = interp.stack_pop
+
+      items = r.is_a?(Array) ? r : [interp.stack_pop, r]
+      result = items.any? { |item| item }
+      interp.stack_push(result)
+    end
+
+    # ( l r -- bool )
+    # ( items -- bool )
+    def word_AND(interp)
+      r = interp.stack_pop
+
+      items = r.is_a?(Array) ? r : [interp.stack_pop, r]
+      result = items.all? { |item| item }
+      interp.stack_push(result)
+    end
+
+    # ( bool -- bool )
+    def word_NOT(interp)
+      value = interp.stack_pop
+      interp.stack_push(!value)
+    end
+
+    # ( item items -- bool )
+    def word_IN(interp)
+      items = interp.stack_pop
+      item = interp.stack_pop
+
+      if !items
+        items = []
+      end
+      result = items.include?(item)
+      interp.stack_push(result)
+    end
+
+    # ( vals required_vals -- bool )
+    def word_ANY(interp)
+      required_vals = interp.stack_pop
+      vals = interp.stack_pop
+
+      result = false
+      required_vals.each do |rv|
+        if vals.include?(rv)
+          result = true
+          break
+        end
+      end
+
+      # If nothing is required, then all values are true
+      result = true if required_vals.empty?
+
+      interp.stack_push(result)
+    end
+
+
+    # ( vals required_vals -- bool )
+    def word_ALL(interp)
+      required_vals = interp.stack_pop
+      vals = interp.stack_pop
+
+      vals ||= []
+      required_vals ||= []
+
+      result = required_vals.all? { |val| vals.include?(val) }
+      interp.stack_push(result)
+    end
+
+    # ( item -- bool )
+    def word_to_BOOL(interp)
+      item = interp.stack_pop
+      result = false
+      if item.nil? || item == "" || item == 0
+        result = false
+      else
+        result = !!item
+      end
+      interp.stack_push(result)
+    end
+
+    # ( item -- int )
+    def word_to_INT(interp)
+      str = interp.stack_pop
+      result = str.to_i
+      interp.stack_push(result)
+    end
+
+    # ( item -- float )
+    def word_to_FLOAT(interp)
+      str = interp.stack_pop
+      result = str.to_f
+      interp.stack_push(result)
+    end
+
+
+    # ( val start_ranges -- index )
+    def word_RANGE_INDEX(interp)
+      start_ranges = interp.stack_pop
+      val = interp.stack_pop
+
+      # Cap off the value ranges with infinity
+      start_ranges.push(Float::INFINITY)
+
+      if val.nil? || start_ranges.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      if val < start_ranges[0]
+        interp.stack_push(nil)
+        return
+      end
+
+      result = nil
+      (0...start_ranges.length - 1).each do |i|
+        if val >= start_ranges[i] && val < start_ranges[i + 1]
+          result = i
+          break
+        end
+      end
+
+      interp.stack_push(result)
+    end
+
+
+    # ( -- Infinity )
+    def word_INFINITY(interp)
+      interp.stack_push(Float::INFINITY)
+    end
+
+    # ( l r -- bool )
+    def word_less_than_or_equal(interp)
+      r = interp.stack_pop
+      l = interp.stack_pop
+
+      if l.nil? || r.nil?
+        interp.stack_push(nil)
+        return
+      end
+
+      result = l <= r
+      interp.stack_push(result)
+    end
+
+    # ( date -- str )
+    def word_DATE_to_STR(interp)
+      date = interp.stack_pop
+      result = date_to_string(date)
+      interp.stack_push(result)
+    end
+
+    # ( time -- str )
+    def word_TIME_to_STR(interp)
+      time = interp.stack_pop
+      result = time.strftime("%H:%M")
+      interp.stack_push(result)
+    end
+
+    # ( date time -- datetime )
+    def word_DATE_TIME_to_DATETIME(interp)
+      time = interp.stack_pop
+      date = interp.stack_pop
+      dt_string = "#{date.year}-#{date.month}-#{date.day} #{time.hour}:#{time.min}"
+      result = Time.parse(dt_string)
+      interp.stack_push(result)
+    end
+
+    # ( datetime -- timestamp )
+    def word_DATETIME_to_TIMESTAMP(interp)
+      datetime = interp.stack_pop
+      result = datetime.to_i
+      interp.stack_push(result)
+    end
+
+    # ( timestamp -- datetime )
+    def word_TIMESTAMP_to_DATETIME(interp)
+      timestamp = interp.stack_pop
+      result = Time.at(timestamp)
+      interp.stack_push(result)
+    end
+
+    # ( str -- datetime )
+    def word_STR_to_DATETIME(interp)
+      s = interp.stack_pop
+      result = Time.parse(s)
+      interp.stack_push(result)
+    end
+
+    # ( str -- timestamp )
+    def word_STR_to_TIMESTAMP(interp)
+      s = interp.stack_pop
+      datetime = Time.parse(s)
+      result = datetime.to_i
+      interp.stack_push(result)
+    end
+
+    # ( -- )
+    def word_bang_PUSH_ERROR(interp)
+      interp.modify_flags(self.module_id, {push_error: true})
+    end
+
+    # ( -- )
+    def word_bang_WITH_KEY(interp)
+      interp.modify_flags(self.module_id, {with_key: true})
+    end
+
+    # ( comparator -- )
+    def word_bang_COMPARATOR(interp)
+      comparator = interp.stack_pop
+      interp.modify_flags(self.module_id, {comparator: comparator})
+    end
+
+    # ( -- )
+    def word_bang_PUSH_REST(interp)
+      interp.modify_flags(self.module_id, {push_rest: true})
+    end
+
+    # ( depth -- )
+    #
+    # NOTE: `depth` of 0 is the same not having set depth
+    def word_bang_DEPTH(interp)
+      depth = interp.stack_pop
+      interp.modify_flags(self.module_id, {depth: depth})
+    end
+
+    # ( num_inteprs -- )
+    def word_bang_INTERPS(interp)
+      num_interps = interp.stack_pop
+      interp.modify_flags(self.module_id, { interps: num_interps })
+    end
+
+    # ( -- )
+    def word_PROFILE_START(interp)
+      interp.start_profiling
+    end
+
+    # ( -- )
+    def word_PROFILE_END(interp)
+      interp.stop_profiling
+    end
+
+    # ( label -- )
+    def word_PROFILE_TIMESTAMP(interp)
+      label = interp.stack_pop
+      interp.add_timestamp(label)
+    end
+
+    # ( -- )
+    def word_PROFILE_DATA(interp)
+      histogram = interp.word_histogram
+      timestamps = interp.profile_timestamps
+
+      result = {
+        word_counts: [],
+        timestamps: [],
+      }
+
+      histogram.each do |val|
+        rec = { word: val[:word], count: val[:count] }
+        result[:word_counts].push(rec)
+      end
+
+      prev_time = 0.0
+      timestamps.each do |t|
+        rec = {
+          label: t[:label],
+          time_ms: t[:time_ms],
+          delta: t[:time_ms] - prev_time,
+        }
+        prev_time = t[:time_ms]
+        result[:timestamps].push(rec)
+      end
+
+      interp.stack_push(result)
+    end
+
+
+    # ( string -- symbol )
+    def word_to_SYM(interp)
+      string = interp.stack_pop
+      result = string.to_sym
+      interp.stack_push(result)
+    end
+
+    # --------------------------------------------------
+    # Helpers
+    private
+    def drill_for_value(rec, fields)
+      cur_rec = rec
+      fields.each do |f|
+        if cur_rec.is_a?(Array) or cur_rec.is_a?(Hash)
+          cur_rec = cur_rec[f]
+        else
+          return nil
+        end
+      end
+      cur_rec
+    end
+
+    def date_to_string(date)
+      date.strftime("%Y-%m-%d")
+    end
+
+    def group_items(items, group_size)
+      num_groups = (items.length / group_size.to_f).ceil
+      res = []
+      remaining = items.dup
+      num_groups.times do
+        res.push(remaining.slice!(0, group_size))
+      end
+      res
+    end
+
+    def extract_rec(record, keys)
+      res = {}
+      keys.each { |k| res[k] = record[k] }
+      res
+    end
+
+    def execute_returning_error(interp, forthic, string_location)
+      result = nil
+      begin
+        interp.run(forthic, string_location)
+      rescue StandardError => e
+        result = e
+      end
+      result
+    end
+
+    def normalize_index(index, length)
+      res = index
+      res += length if index < 0
+      res
+    end
+
+      # Default sort
+      def sort_without_comparator(container)
+        # Separate nil values from non-nil values
+        nils, non_nils = container.partition(&:nil?)
+
+        # Sort non_nils and append nils
+        non_nils.sort + nils
+      end
+
+      # Sort using a forthic string
+      def sort_with_forthic(interp, forthic, flag_string_position, container)
+        aug_array = make_aug_array(interp, forthic, flag_string_position, container)
+        aug_array.sort! { |l, r| cmp_items(l, r) }
+        de_aug_array(aug_array)
+      end
+
+      def make_aug_array(interp, forthic, flag_string_position, vals)
+        res = []
+        vals.each do |val|
+          interp.stack_push(val)
+          interp.run(forthic, flag_string_position)
+          aug_val = interp.stack_pop
+          res.push([val, aug_val])
+        end
+        res
+      end
+
+      def cmp_items(l, r)
+        l_val = l[1]
+        r_val = r[1]
+
+        if l_val < r_val
+          -1
+        elsif l_val > r_val
+          1
+        else
+          0
+        end
+      end
+
+      def de_aug_array(aug_vals)
+        aug_vals.map { |aug_val| aug_val[0] }
+      end
+
+      # Sort with key func
+      def sort_with_key_func(container, key_func)
+        container.sort do |l, r|
+          l_val = key_func.call(l)
+          r_val = key_func.call(r)
+          if l_val < r_val
+            -1
+          elsif l_val > r_val
+            1
+          else
+            0
+          end
+        end
+      end
+
+      def add_to_record_result(item, key, keys, result)
+        new_key = (keys + [key]).join("\t")
+        result[new_key] = item
+      end
+
+      def fully_flatten_record(record, res, keys)
+        record.each do |k, item|
+          if is_record(item)
+            fully_flatten_record(item, res, keys + [k])
+          else
+            add_to_record_result(item, k, keys, res)
+          end
+        end
+        res
+      end
+
+      def flatten_record(record, depth, res, keys)
+        return fully_flatten_record(record, res, keys) if depth.nil?
+
+        record.each do |k, item|
+          if depth > 0 && is_record(item)
+            flatten_record(item, depth - 1, res, keys + [k])
+          else
+            add_to_record_result(item, k, keys, res)
+          end
+        end
+        res
+      end
+
+      def flatten_array(array, depth)
+        return array.flatten(depth) if depth
+        array.flatten
+      end
+
+      def is_record(obj)
+        obj.is_a?(Hash) && !obj.empty?
+      end
+
+      def get_day_this_week(day_of_week)
+        # Assume the start of the week is Monday and a day_of_week of 0 means a Monday
+        # Get the current day of the week
+        today = Date.today
+        current_day_of_week = today.wday
+
+        # Return the date of the day_of_week
+        today - (current_day_of_week - day_of_week)
+      end
+
+      # NOTE: Monday is the start of the week
+      def normalize_day(day)
+        day
+      end
+
+      def compute_number_mean(numbers)
+        sum = numbers.reduce(0) { |acc, num| acc + num }
+        sum.to_f / numbers.length
+      end
+
+      def compute_non_number_mean(objects)
+        non_null_objects = objects.reject { |obj| obj.nil? }
+        res = Hash.new(0)
+
+        non_null_objects.each do |obj|
+          obj_str = obj.is_a?(String) ? obj : obj.to_json
+          res[obj_str] += 1
+        end
+
+        res.each do |key, value|
+          res[key] = value.to_f / non_null_objects.length
+        end
+        res
+      end
+
+      def compute_object_mean(records)
+        res = {}
+        records.each do |record|
+          record.each do |key, value|
+            res[key] ||= []
+            res[key] << value
+          end
+        end
+
+        res.each do |key, values|
+          res[key] = compute_mean(values)
+        end
+        res
+      end
+
+      def is_all_numbers(values)
+        values.all? { |val| val.is_a?(Numeric) }
+      end
+
+      def is_all_records(values)
+        values.all? { |val| val.is_a?(Hash) }
+      end
+
+      def select_non_null_values(values)
+        values.reject { |val| val.nil? }
+      end
+
+      def compute_mean(values)
+        result = nil
+        if values.is_a?(Array)
+          non_null_values = select_non_null_values(values)
+          if is_all_numbers(non_null_values)
+            result = compute_number_mean(non_null_values)
+          elsif is_all_records(non_null_values)
+            result = compute_object_mean(non_null_values)
+          else
+            result = compute_non_number_mean(non_null_values)
+          end
+        end
+        result
+      end
+
+  end
+end