forthic 0.1.0 → 0.3.0

data/lib/forthic/modules/standard/array_module.rb

@@ -0,0 +1,940 @@
+# frozen_string_literal: true
+
+require_relative '../../decorators/word'
+require 'set'
+
+module Forthic
+  module Modules
+    # ArrayModule - Array and collection operations
+    #
+    # Provides operations for manipulating arrays and records (hashes).
+    class ArrayModule < Decorators::DecoratedModule
+      module_doc <<~DOC
+        Array and collection operations for manipulating arrays and records.
+
+        ## Categories
+        - Access: NTH, LAST, SLICE, TAKE, DROP, LENGTH, INDEX, KEY-OF
+        - Transform: MAP, REVERSE
+        - Combine: APPEND, ZIP, ZIP_WITH, CONCAT
+        - Filter: SELECT, UNIQUE, DIFFERENCE, INTERSECTION, UNION
+        - Sort: SORT, SHUFFLE, ROTATE
+        - Group: BY_FIELD, GROUP-BY-FIELD, GROUP_BY, GROUPS_OF
+        - Utility: <REPEAT, FOREACH, REDUCE, UNPACK, FLATTEN
+
+        ## Options
+        Several words support options via the ~> operator using syntax: [.option_name value ...] ~> WORD
+        - with_key: Push index/key before value (MAP, FOREACH, GROUP-BY, SELECT)
+        - push_error: Push error array after execution (MAP, FOREACH)
+        - depth: Recursion depth for nested operations (MAP, FLATTEN)
+        - push_rest: Push remaining items after operation (MAP, TAKE)
+        - comparator: Custom comparison function as Forthic string (SORT)
+
+        ## Examples
+        [10 20 30] '2 *' MAP
+        [10 20 30] '+ 2 *' [.with_key TRUE] ~> MAP
+        [[[1 2]] [[3 4]]] [.depth 1] ~> FLATTEN
+        [3 1 4 1 5] [.comparator "SWAP -"] ~> SORT
+        [.with_key TRUE .push_error TRUE] ~> MAP
+      DOC
+
+      def initialize
+        super("array")
+      end
+
+      # Basic operations
+
+    forthic_word :APPEND, "( container:any item:any -- container:any )", "Append item to array or add key-value to record"
+      def APPEND(container, item)
+        result = container || []
+
+        if result.is_a?(Array)
+          result.push(item)
+        else
+          # If not a list, treat as record - item should be [key, value]
+          result[item[0]] = item[1]
+        end
+
+        result
+      end
+
+    forthic_word :REVERSE, "( container:any -- container:any )", "Reverse array"
+      def REVERSE(container)
+        return container unless container
+
+        result = container
+        result = result.reverse if result.is_a?(Array)
+
+        result
+      end
+
+    forthic_word :UNIQUE, "( array:any[] -- array:any[] )", "Remove duplicates from array"
+      def UNIQUE(array)
+        return array unless array
+
+        result = array
+        result = array.uniq if array.is_a?(Array)
+
+        result
+      end
+
+    forthic_word :LENGTH, "( container:any -- length:number )", "Get length of array, record, or string"
+      def LENGTH(container)
+        return 0 unless container
+
+        if container.is_a?(Array)
+          container.length
+        elsif container.is_a?(String)
+          container.length
+        else
+          container.keys.length
+        end
+      end
+
+    forthic_direct_word :NTH, "( container:any n:number -- item:any )", "Get nth element from array or record"
+      def NTH(interp)
+        n = interp.stack_pop
+        container = interp.stack_pop
+
+        result = if n.nil? || !container
+                   nil
+                 elsif container.is_a?(Array)
+                   (n < 0 || n >= container.length) ? nil : container[n]
+                 else
+                   keys = container.keys.sort
+                   if n < 0 || n >= keys.length
+                     nil
+                   else
+                     container[keys[n]]
+                   end
+                 end
+
+        interp.stack_push(result)
+      end
+
+    forthic_word :LAST, "( container:any -- item:any )", "Get last element from array or record"
+      def LAST(container)
+        return nil unless container
+
+        if container.is_a?(Array)
+          return nil if container.empty?
+          container.last
+        else
+          keys = container.keys.sort
+          return nil if keys.empty?
+          container[keys.last]
+        end
+      end
+
+    forthic_word :SLICE, "( container:any start:number end:number -- result:any )", "Extract slice from array or record"
+      def SLICE(container, start, end_pos)
+        _container = container || []
+
+        start = start.to_i
+        end_pos = end_pos.to_i
+
+        length = if _container.is_a?(Array)
+                   _container.length
+                 else
+                   _container.keys.length
+                 end
+
+        normalize_index = lambda do |index|
+          index < 0 ? index + length : index
+        end
+
+        start = normalize_index.call(start)
+        end_pos = normalize_index.call(end_pos)
+
+        step = start > end_pos ? -1 : 1
+        indexes = [start]
+
+        if start < 0 || start >= length
+          # Return empty result
+          return _container.is_a?(Array) ? [] : {}
+        end
+
+        while start != end_pos
+          start += step
+          if start < 0 || start >= length
+            indexes << nil
+          else
+            indexes << start
+          end
+        end
+
+        if _container.is_a?(Array)
+          result = []
+          indexes.each do |i|
+            result << (i.nil? ? nil : _container[i])
+          end
+          result
+        else
+          keys = _container.keys.sort
+          result = {}
+          indexes.each do |i|
+            unless i.nil?
+              k = keys[i]
+              result[k] = _container[k]
+            end
+          end
+          result
+        end
+      end
+
+    forthic_word :TAKE, "( container:any[] n:number [options:WordOptions] -- result:any[] )", "Take first n elements"
+      def TAKE(container, n, options = {})
+        flags = {
+          with_key: options[:with_key] || options['with_key'],
+          push_rest: options[:push_rest] || options['push_rest']
+        }
+
+        container ||= []
+
+        taken, rest = if container.is_a?(Array)
+                        [container[0...n], container[n..-1] || []]
+                      else
+                        keys = container.keys.sort
+                        taken_keys = keys[0...n]
+                        rest_keys = keys[n..-1] || []
+                        [taken_keys.map { |k| container[k] }, rest_keys.map { |k| container[k] }]
+                      end
+
+        if flags[:push_rest]
+          interp.stack_push(taken)
+          return rest
+        end
+
+        taken
+      end
+
+    forthic_word :DROP, "( container:any n:number -- result:any )", "Drop first n elements from array or record"
+      def DROP(container, n)
+        return [] unless container
+        return container if n <= 0
+
+        if container.is_a?(Array)
+          container[n..-1] || []
+        else
+          keys = container.keys.sort
+          rest_keys = keys[n..-1] || []
+          rest_keys.map { |k| container[k] }
+        end
+      end
+
+      # Set operations
+
+    forthic_word :DIFFERENCE, "( lcontainer:any rcontainer:any -- result:any )", "Set difference between two containers"
+      def DIFFERENCE(lcontainer, rcontainer)
+        _lcontainer = lcontainer || []
+        _rcontainer = rcontainer || []
+
+        difference = lambda do |l, r|
+          l.select { |item| !r.include?(item) }
+        end
+
+        if _rcontainer.is_a?(Array)
+          difference.call(_lcontainer, _rcontainer)
+        else
+          lkeys = _lcontainer.keys
+          rkeys = _rcontainer.keys
+          diff = difference.call(lkeys, rkeys)
+          result = {}
+          diff.each { |k| result[k] = _lcontainer[k] }
+          result
+        end
+      end
+
+    forthic_word :INTERSECTION, "( lcontainer:any rcontainer:any -- result:any )", "Set intersection between two containers"
+      def INTERSECTION(lcontainer, rcontainer)
+        _lcontainer = lcontainer || []
+        _rcontainer = rcontainer || []
+
+        intersection = lambda do |l, r|
+          l.select { |item| r.include?(item) }
+        end
+
+        if _rcontainer.is_a?(Array)
+          intersection.call(_lcontainer, _rcontainer)
+        else
+          lkeys = _lcontainer.keys
+          rkeys = _rcontainer.keys
+          inter = intersection.call(lkeys, rkeys)
+          result = {}
+          inter.each { |k| result[k] = _lcontainer[k] }
+          result
+        end
+      end
+
+    forthic_word :UNION, "( lcontainer:any rcontainer:any -- result:any )", "Set union between two containers"
+      def UNION(lcontainer, rcontainer)
+        lcontainer ||= []
+        rcontainer ||= []
+
+        union_fn = lambda do |l, r|
+          (l + r).uniq
+        end
+
+        if rcontainer.is_a?(Array)
+          union_fn.call(lcontainer, rcontainer)
+        else
+          lkeys = lcontainer.keys
+          rkeys = rcontainer.keys
+          keys = union_fn.call(lkeys, rkeys)
+          result = {}
+          keys.each do |k|
+            val = lcontainer[k]
+            val = rcontainer[k] if val.nil?
+            result[k] = val
+          end
+          result
+        end
+      end
+
+      # Sort and shuffle
+
+    forthic_word :SORT, "( container:any[] [options:WordOptions] -- array:any[] )", "Sort container. Options: comparator (string or function). Example: [3 1 4] [.comparator \"-1 *\"] ~> SORT"
+      def SORT(container, options = {})
+        return container unless container
+        return container unless container.is_a?(Array)
+
+        comparator = options[:comparator] || options['comparator']
+        flag_string_position = interp.get_string_location
+
+        # Default sort - handle nils by putting them at the end
+        if comparator.nil?
+          return container.sort do |a, b|
+            if a.nil? && b.nil?
+              0
+            elsif a.nil?
+              1  # nil goes after non-nil
+            elsif b.nil?
+              -1  # non-nil goes before nil
+            else
+              a <=> b
+            end
+          end
+        end
+
+        # Sort using a forthic string as a key function
+        if comparator.is_a?(String)
+          aug_array = container.map do |val|
+            interp.stack_push(val)
+            interp.run(comparator, flag_string_position)
+            aug_val = interp.stack_pop
+            [val, aug_val]
+          end
+
+          aug_array.sort! do |l, r|
+            l_val = l[1]
+            r_val = r[1]
+            l_val <=> r_val
+          end
+
+          return aug_array.map { |aug_val| aug_val[0] }
+        end
+
+        # Sort with key function (proc/lambda)
+        container.sort do |l, r|
+          l_val = comparator.call(l)
+          r_val = comparator.call(r)
+          l_val <=> r_val
+        end
+      end
+
+    forthic_word :SHUFFLE, "( array:any[] -- array:any[] )", "Shuffle array randomly"
+      def SHUFFLE(array)
+        return array unless array
+
+        array.shuffle
+      end
+
+    forthic_word :ROTATE, "( container:any -- container:any )", "Rotate container by moving last element to front"
+      def ROTATE(container)
+        return container unless container
+
+        result = container
+        if container.is_a?(Array) && !container.empty?
+          result = container.dup
+          val = result.pop
+          result.unshift(val)
+        end
+
+        result
+      end
+
+      # Unpacking and flattening
+
+    forthic_word :UNPACK, "( container:any -- elements:any )", "Unpack array or record elements onto stack"
+      def UNPACK(container)
+        _container = 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
+
+        nil # Return nil so nothing gets auto-pushed
+      end
+
+    forthic_word :FLATTEN, "( container:any [options:WordOptions] -- flat:any )", "Flatten nested arrays or records. Options: depth (number). Example: [[[1 2]]] [.depth 1] ~> FLATTEN"
+      def FLATTEN(container, options = {})
+        return [] unless container
+
+        depth = options[:depth] || options['depth']
+
+        # Helpers defined as lambdas
+        fully_flatten_array = nil
+        fully_flatten_array = lambda do |items, accum|
+          items.each do |item|
+            if item.is_a?(Array)
+              fully_flatten_array.call(item, accum)
+            else
+              accum << item
+            end
+          end
+          accum
+        end
+
+        flatten_array = nil
+        flatten_array = lambda do |items, depth_val, accum = []|
+          return fully_flatten_array.call(items, accum) if depth_val.nil?
+
+          items.each do |item|
+            if depth_val > 0 && item.is_a?(Array)
+              flatten_array.call(item, depth_val - 1, accum)
+            else
+              accum << item
+            end
+          end
+          accum
+        end
+
+        is_record = lambda do |obj|
+          obj.is_a?(Hash) && !obj.keys.empty?
+        end
+
+        add_to_record_result = lambda do |item, key, keys, result|
+          new_key = (keys + [key]).join("\t")
+          result[new_key] = item
+        end
+
+        fully_flatten_record = nil
+        fully_flatten_record = lambda do |record, res, keys|
+          record.keys.each do |k|
+            item = record[k]
+            if is_record.call(item)
+              fully_flatten_record.call(item, res, keys + [k])
+            else
+              add_to_record_result.call(item, k, keys, res)
+            end
+          end
+          res
+        end
+
+        flatten_record = nil
+        flatten_record = lambda do |record, depth_val, res, keys|
+          return fully_flatten_record.call(record, res, keys) if depth_val.nil?
+
+          record.keys.each do |k|
+            item = record[k]
+            if depth_val > 0 && is_record.call(item)
+              flatten_record.call(item, depth_val - 1, res, keys + [k])
+            else
+              add_to_record_result.call(item, k, keys, res)
+            end
+          end
+          res
+        end
+
+        if container.is_a?(Array)
+          flatten_array.call(container, depth)
+        else
+          flatten_record.call(container, depth, {}, [])
+        end
+      end
+
+    forthic_word :REDUCE, "( container:any initial:any forthic:string -- result:any )", "Reduce array or record with accumulator"
+      def REDUCE(container, initial, forthic)
+        _container = container || []
+
+        string_location = interp.get_string_location
+
+        interp.stack_push(initial)
+
+        if _container.is_a?(Array)
+          _container.each do |item|
+            interp.stack_push(item)
+            interp.run(forthic, string_location)
+          end
+        else
+          _container.keys.each do |k|
+            v = _container[k]
+            interp.stack_push(v)
+            interp.run(forthic, string_location)
+          end
+        end
+
+        interp.stack_pop
+      end
+
+      # Zip operations
+
+    forthic_word :ZIP, "( container1:any[] container2:any[] -- result:any[] )", "Zip two arrays into array of pairs"
+      def ZIP(container1, container2)
+        container1 ||= []
+        container2 ||= []
+
+        if container2.is_a?(Array)
+          result = []
+          container1.each_with_index do |item, i|
+            value2 = i < container2.length ? container2[i] : nil
+            result << [item, value2]
+          end
+          result
+        else
+          result = {}
+          container1.keys.each do |k|
+            v = container1[k]
+            result[k] = [v, container2[k]]
+          end
+          result
+        end
+      end
+
+    forthic_word :ZIP_WITH, "( container1:any[] container2:any[] forthic:string -- result:any[] )", "Zip two arrays with combining function", "ZIP-WITH"
+      def ZIP_WITH(container1, container2, forthic)
+        string_location = interp.get_string_location
+
+        container1 ||= []
+        container2 ||= []
+
+        if container2.is_a?(Array)
+          result = []
+          container1.each_with_index do |item, i|
+            value2 = i < container2.length ? container2[i] : nil
+            interp.stack_push(item)
+            interp.stack_push(value2)
+            interp.run(forthic, string_location)
+            result << interp.stack_pop
+          end
+          result
+        else
+          result = {}
+          container1.keys.each do |k|
+            interp.stack_push(container1[k])
+            interp.stack_push(container2[k])
+            interp.run(forthic, string_location)
+            result[k] = interp.stack_pop
+          end
+          result
+        end
+      end
+
+    forthic_word :INDEX, "( items:any[] forthic:string -- indexed:any )", "Create index mapping from array indices to values"
+      def INDEX(items, forthic)
+        string_location = interp.get_string_location
+
+        unless items
+          interp.stack_push(items)
+          return nil
+        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] << item
+            else
+              result[lowercased_key] = [item]
+            end
+          end
+        end
+
+        result
+      end
+
+    forthic_direct_word :KEY_OF, "( container:any value:any -- key:any )", "Find key of value in container", "KEY-OF"
+      def KEY_OF(interp)
+        value = interp.stack_pop
+        container = interp.stack_pop
+
+        result = if !container
+                   nil
+                 elsif container.is_a?(Array)
+                   container.index(value)
+                 else
+                   found_key = nil
+                   container.keys.each do |key|
+                     if container[key] == value
+                       found_key = key
+                       break
+                     end
+                   end
+                   found_key
+                 end
+
+        interp.stack_push(result)
+      end
+
+      # Selection and filtering
+
+    forthic_word :SELECT, "( container:any forthic:string [options:WordOptions] -- filtered:any )", "Filter items with predicate. Options: with_key (bool)"
+      def SELECT(container, forthic, options = {})
+        string_location = interp.get_string_location
+
+        with_key = options[:with_key] || options['with_key']
+
+        unless container
+          interp.stack_push(container)
+          return nil
+        end
+
+        if container.is_a?(Array)
+          result = []
+          container.each_with_index do |item, i|
+            interp.stack_push(i) if with_key
+            interp.stack_push(item)
+            interp.run(forthic, string_location)
+            should_select = interp.stack_pop
+            result << item if should_select
+          end
+          result
+        else
+          result = {}
+          container.keys.each do |k|
+            v = container[k]
+            interp.stack_push(k) if with_key
+            interp.stack_push(v)
+            interp.run(forthic, string_location)
+            should_select = interp.stack_pop
+            result[k] = v if should_select
+          end
+          result
+        end
+      end
+
+      # Grouping operations
+
+    forthic_word :BY_FIELD, "( container:any[] field:string -- indexed:any )", "Index records by field value", "BY-FIELD"
+      def BY_FIELD(container, field)
+        container ||= []
+
+        values = if container.is_a?(Array)
+                   container
+                 else
+                   container.keys.map { |k| container[k] }
+                 end
+
+        result = {}
+        values.each do |v|
+          result[v[field]] = v if v
+        end
+
+        result
+      end
+
+    forthic_word :GROUP_BY_FIELD, "( container:any[] field:string -- grouped:any )", "Group records by field value", "GROUP-BY-FIELD"
+      def GROUP_BY_FIELD(container, field)
+        container ||= []
+
+        values = if container.is_a?(Array)
+                   container
+                 else
+                   container.keys.map { |k| container[k] }
+                 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] << v
+            end
+          else
+            result[field_val] ||= []
+            result[field_val] << v
+          end
+        end
+
+        result
+      end
+
+    forthic_word :GROUP_BY, "( items:any forthic:string [options:WordOptions] -- grouped:any )", "Group items by function result. Options: with_key (bool). Example: [5 15 25] '10 /' [.with_key TRUE] ~> GROUP-BY", "GROUP-BY"
+      def GROUP_BY(items, forthic, options = {})
+        _items = items || []
+
+        string_location = interp.get_string_location
+        with_key = options[:with_key] || options['with_key']
+
+        result = {}
+
+        process_item = lambda do |item, key = nil|
+          interp.stack_push(key) if with_key
+          interp.stack_push(item)
+          interp.run(forthic, string_location)
+          group_key = interp.stack_pop
+          # Convert group_key to string to match JavaScript behavior (object keys are always strings)
+          group_key_str = group_key.to_s
+          result[group_key_str] ||= []
+          result[group_key_str] << item
+        end
+
+        if _items.is_a?(Array)
+          _items.each_with_index do |item, i|
+            process_item.call(item, i)
+          end
+        else
+          _items.keys.each do |key|
+            process_item.call(_items[key], key)
+          end
+        end
+
+        result
+      end
+
+    forthic_word :GROUPS_OF, "( container:any[] n:number -- groups:any[] )", "Split array into groups of size n", "GROUPS-OF"
+      def GROUPS_OF(container, n)
+        raise "GROUPS-OF requires group size > 0" if n <= 0
+
+        container ||= []
+
+        group_items = lambda do |items, group_size|
+          items.each_slice(group_size).to_a
+        end
+
+        extract_rec = lambda do |record, keys|
+          result = {}
+          keys.each { |k| result[k] = record[k] }
+          result
+        end
+
+        if container.is_a?(Array)
+          group_items.call(container, n)
+        else
+          keys = container.keys
+          key_groups = group_items.call(keys, n)
+          key_groups.map { |ks| extract_rec.call(container, ks) }
+        end
+      end
+
+      # Iteration operations
+
+    forthic_word :FOREACH, "( items:any forthic:string [options:WordOptions] -- ? )", "Execute forthic for each item. Options: with_key (bool), push_error (bool). Example: ['a' 'b'] 'PROCESS' [.with_key TRUE] ~> FOREACH"
+      def FOREACH(items, forthic, options = {})
+        _items = items || []
+
+        string_location = interp.get_string_location
+
+        flags = {
+          with_key: options[:with_key] || options['with_key'],
+          push_error: options[:push_error] || options['push_error']
+        }
+
+        errors = []
+
+        execute_with_error = lambda do |forthic_str, location|
+          begin
+            interp.run(forthic_str, location)
+            nil
+          rescue => error
+            error
+          end
+        end
+
+        if _items.is_a?(Array)
+          _items.each_with_index do |item, i|
+            interp.stack_push(i) if flags[:with_key]
+            interp.stack_push(item)
+
+            if flags[:push_error]
+              error = execute_with_error.call(forthic, string_location)
+              errors << error
+            else
+              interp.run(forthic, string_location)
+            end
+          end
+        else
+          _items.keys.each do |k|
+            item = _items[k]
+            interp.stack_push(k) if flags[:with_key]
+            interp.stack_push(item)
+
+            if flags[:push_error]
+              error = execute_with_error.call(forthic, string_location)
+              errors << error
+            else
+              interp.run(forthic, string_location)
+            end
+          end
+        end
+
+        interp.stack_push(errors) if flags[:push_error]
+
+        nil
+      end
+
+    forthic_word :MAP, "( items:any forthic:string [options:WordOptions] -- mapped:any )", "Map function over items. Options: with_key (bool), push_error (bool), depth (num), push_rest (bool). Example: [1 2 3] '2 *' [.with_key TRUE] ~> MAP"
+      def MAP(items, forthic, options = {})
+        string_location = interp.get_string_location
+
+        flags = {
+          with_key: options[:with_key] || options['with_key'],
+          push_error: options[:push_error] || options['push_error'],
+          depth: options[:depth] || options['depth'] || 0,
+          push_rest: options[:push_rest] || options['push_rest']
+        }
+
+        map_word = MapWord.new(items, forthic, string_location, flags)
+        map_word.execute(interp)
+
+        nil # MapWord pushes result directly
+      end
+
+    forthic_direct_word :l_REPEAT, "( item:any forthic:string num_times:number -- )", "Repeat execution of forthic num_times", "<REPEAT"
+      def l_REPEAT(interp)
+        num_times = interp.stack_pop
+        forthic = interp.stack_pop
+        string_location = interp.get_string_location
+
+        num_times.times do
+          # Store item so we can push it back later
+          item = interp.stack_pop
+          interp.stack_push(item)
+
+          interp.run(forthic, string_location)
+          res = interp.stack_pop
+
+          # Push original item and result
+          interp.stack_push(item)
+          interp.stack_push(res)
+        end
+      end
+    end
+
+    # MapWord - Support class for MAP operation
+    class MapWord
+      def initialize(items, forthic, forthic_location, flags)
+        @forthic = forthic
+        @forthic_location = forthic_location
+        @items = items
+        @flags = flags
+
+        @depth = flags[:depth] || 0
+        @num_interps = flags[:interps] || 1
+        @push_error = flags[:push_error]
+        @with_key = flags[:with_key]
+
+        @result = []
+        @errors = []
+      end
+
+      def execute(interp)
+        normal_execute(interp)
+      end
+
+      private
+
+      def normal_execute(interp)
+        items = @items
+        unless items && (!items.is_a?(Array) || !items.empty?)
+          interp.stack_push(items)
+          return
+        end
+
+        @result = []
+        @errors = []
+
+        map(interp, items)
+
+        # Return results
+        interp.stack_push(@result)
+        interp.stack_push(@errors) if @push_error
+      end
+
+      def map(interp, items)
+        return unless items
+
+        # This maps the forthic over an item, storing errors if needed
+        map_value = lambda do |key, value, errors|
+          interp.stack_push(key) if @with_key
+          interp.stack_push(value)
+
+          if @push_error
+            begin
+              interp.run(@forthic, @forthic_location)
+            rescue => e
+              interp.stack_push(nil)
+              errors << e
+            else
+              errors << nil
+            end
+          else
+            interp.run(@forthic, @forthic_location)
+          end
+          interp.stack_pop
+        end
+
+        # This recursively descends a record structure
+        descend_record = nil
+        descend_record = lambda do |record, depth, accum, errors|
+          record.keys.each do |k|
+            item = record[k]
+            if depth > 0
+              if item.is_a?(Array)
+                accum[k] = []
+                descend_list.call(item, depth - 1, accum[k], errors)
+              else
+                accum[k] = {}
+                descend_record.call(item, depth - 1, accum[k], errors)
+              end
+            else
+              accum[k] = map_value.call(k, item, errors)
+            end
+          end
+          accum
+        end
+
+        # This recursively descends a list
+        descend_list = nil
+        descend_list = lambda do |items_arr, depth, accum, errors|
+          items_arr.each_with_index do |item, i|
+            if depth > 0
+              if item.is_a?(Array)
+                accum << []
+                descend_list.call(item, depth - 1, accum.last, errors)
+              else
+                accum << {}
+                descend_record.call(item, depth - 1, accum.last, errors)
+              end
+            else
+              accum << map_value.call(i, item, errors)
+            end
+          end
+          accum
+        end
+
+        errors = []
+        result = if items.is_a?(Array)
+                   descend_list.call(items, @depth, [], errors)
+                 else
+                   descend_record.call(items, @depth, {}, errors)
+                 end
+
+        @result = result
+        @errors = errors
+        [result, errors]
+      end
+    end
+  end
+end