lisp-interpreter 0.1.0

data/lib/lisp/interpreter/functional.rb

@@ -0,0 +1,272 @@
+# Optimization module
+module Optimize
+  def fold_values_helper(other)
+    other = other.map { |t| find_list_function_value [t] }
+    (equalize_lists other).transpose
+  end
+
+  def get_fold_values(other)
+    values = find_all_values other
+    raise 'Incorrect number of arguments' if values.empty?
+    x = values[0]
+    y = fold_values_helper values[1..-1]
+    [x, y]
+  end
+
+  def rm_from_in_scope(scope, idx, def_vars)
+    i = find_bracket_idx scope, idx
+    def_vars[scope[idx + 2].to_s] = scope[idx + 3..i - 1]
+    scope.slice!(idx..i)
+    [i + 1, scope, def_vars]
+  end
+
+  def inner_scope_replace(scope, vars)
+    scope.each_with_index do |t, i|
+      scope[i] = vars[t.to_s] if vars.key? t.to_s
+    end
+    scope.flatten
+  end
+
+  def fetch_inner_scope(scope, idx = 0, def_vars = {})
+    until idx >= scope.size
+      if scope[idx] == 'define'
+        idx, scope, def_vars = rm_from_in_scope scope, idx - 1, def_vars
+      else
+        idx += 1
+      end
+    end
+    inner_scope_replace scope, def_vars
+  end
+
+  def filter_helper(func, values)
+    result =
+      if func.is_a? Proc
+        values.select { |t| func.call(*t) == '#t' }
+      else
+        values.select { |t| (send func, [t]) == '#t' }
+      end
+    build_list result
+  end
+
+  def apply_helper(func, values)
+    return func.call(*values) if func.is_a? Proc
+    send func, values
+  end
+
+  def call_compose(other)
+    tmp = ['(', *other[1..-1]]
+    idx = find_bracket_idx tmp, 0
+    funcs = find_all_values tmp[1..idx - 1]
+    value, = find_next_value tmp[idx + 1..-1]
+    funcs.reverse.each do |t|
+      value = calc_input_val ['(', t, value.to_s, ')']
+    end
+    value
+  end
+
+  def build_compose_expr(funcs)
+    expr = ['(', 'x', ')']
+    funcs.each do |f|
+      expr << '('
+      expr << f
+    end
+    expr << 'x'
+    funcs.size.times { expr << ')' }
+    expr
+  end
+
+  def do_not_call_compose(other)
+    funcs = find_all_values other
+    raise 'Incorrect data type' if funcs.any? { |t| t.to_s.number? }
+    expr = build_compose_expr funcs
+    proc_lambda expr
+  end
+end
+
+# FunctionalScheme helper
+module FunctionalSchemeHelper
+  include Optimize
+  def foldl_helper(func, accum, lst)
+    return accum if lst.empty?
+    value = func.call(*lst[0], accum.to_s) if func.is_a? Proc
+    value = send func, [*lst[0], accum] if value.nil?
+    foldl_helper func, value.to_s, lst[1..-1]
+  end
+
+  def foldr_helper(func, accum, lst)
+    return accum if lst.empty?
+    value = foldr_helper func, accum, lst[1..-1]
+    return func.call(*lst[0], value.to_s) if func.is_a? Proc
+    send func, [*lst[0], value.to_s]
+  end
+
+  def equalize_lists(other)
+    min = other.map(&:size).min
+    other.map { |t| t[0..min - 1] }
+  end
+
+  def member_helper(to_check, values)
+    return '#f' unless values.include? to_check
+    idx = values.index(to_check)
+    build_list values[idx..-1]
+  end
+
+  def find_params_lambda(other)
+    raise 'Unbound symbol ' + other.to_s if other[0] != '('
+    idx = find_bracket_idx other, 0
+    [other[1..idx - 1], other[idx + 1..-1]]
+  end
+
+  def eval_lambda(other)
+    idx = find_bracket_idx other.unshift('('), 0
+    to_eval = other[1..idx - 1]
+    (proc_lambda to_eval).call(*other[idx + 1..-1])
+  end
+
+  def proc_lambda_helper(other, params, args)
+    args = arg_finder args
+    raise 'Incorrect number of arguments' unless params.size == args.size
+    define_func_helper other.dup, params.dup, args
+  end
+
+  def proc_lambda(other)
+    params, other = find_params_lambda other
+    other = fetch_inner_scope other
+    to_return = other[0..1].join == '(compose' && params.empty?
+    return calc_input_val other if to_return
+    proc = proc do |*args|
+      proc_lambda_helper other, params, args
+    end
+    proc
+  end
+
+  def fetch_define(other)
+    if other[0] == '('
+      define_function other
+    else
+      define_var other[0].to_s, (find_all_values other[1..-1])
+    end
+  end
+
+  def define_var(var, values)
+    raise 'Incorrect number of arguments' if values.size != 1
+    raise 'Invalid variable name' unless valid_var_name var
+    set_var_helper var, values[0]
+  end
+
+  def set_values_define(other, params, args)
+    args = [args] unless args.is_a? Array
+    other.each_with_index do |t, idx|
+      if params.include? t
+        i = params.index t
+        other[idx] = args[i]
+      end
+    end
+    other
+  end
+
+  def define_func_helper(other, params, args)
+    temp = set_values_define other, params, args
+    calc_input_val temp
+  end
+
+  def arg_finder_helper(name, args)
+    if !name.nil?
+      args = args[1..-1]
+      [name, args]
+    else
+      find_next_value args
+    end
+  end
+
+  def arg_finder(args)
+    result = []
+    until args.empty?
+      name = predefined_method_caller [args[0]]
+      temp, args = arg_finder_helper name, args
+      result << temp
+    end
+    result
+  end
+
+  def define_function(other)
+    idx = find_bracket_idx other, 0
+    name, *params = other[1..idx - 1]
+    build_fn = ['(', 'lambda', '(', *params, ')', *other[idx + 1..-1], ')']
+    define_var name, (find_all_values build_fn)
+  end
+end
+
+# Functional programming main functions
+module FunctionalScheme
+  include FunctionalSchemeHelper
+  def foldl(other)
+    raise 'Incorrect number of parameters' if other.size < 2
+    func, other = valid_function other
+    val_one, val_two = get_fold_values other
+    foldl_helper func, val_one, val_two
+  end
+
+  def foldr(other)
+    raise 'Incorrect number of parameters' if other.size < 2
+    func, other = valid_function other
+    val_one, val_two = get_fold_values other
+    foldr_helper func, val_one, val_two
+  end
+
+  def filter(other)
+    raise 'Incorrect number of parameters' if other.size < 2
+    func, other = valid_function other
+    raise 'Incorrect number of parameters' if other.empty?
+    values = find_all_values other
+    values = find_list_function_value [values[0]]
+    filter_helper func, values
+  end
+
+  def member(other)
+    raise 'Incorrect number of arguments' unless other.size == 2
+    to_check = other[0]
+    split_val = split_list_string other[1]
+    raise 'Invalid argument' unless split_val.pair? || split_val.list?
+    values = find_all_values split_val[2..-2]
+    member_helper to_check, values
+  end
+
+  def remove(other)
+    raise 'Incorrect number of arguments' unless other.size == 2
+    to_remove = other[0]
+    values = find_list_function_value [other[1]]
+    values.delete_at(values.index(to_remove) || values.length)
+    build_list values
+  end
+
+  def apply(other)
+    raise 'Incorrect number of arguments' if other.nil? || other.empty?
+    func, other = valid_function other
+    values = find_all_values other
+    *vs, lst = values
+    raise 'Incorrect data type' unless lst.list?
+    (find_list_function_value [lst]).each { |t| vs << t }
+    apply_helper func, vs
+  end
+
+  def compose(other)
+    if other[0] != 'compose'
+      do_not_call_compose other
+    else
+      call_compose other
+    end
+  end
+
+  def lambda(other)
+    if other[0] == 'lambda'
+      eval_lambda other[1..-1]
+    else
+      proc_lambda other
+    end
+  end
+
+  def define(other)
+    fetch_define other
+  end
+end

data/lib/lisp/interpreter/list.rb

@@ -0,0 +1,162 @@
+# Helper functions for SchemeLists
+module SchemeListsHelper
+  def evaluate_list(tokens, no_quotes)
+    find_all_values_list_evaluate tokens, no_quotes
+  end
+
+  def no_eval_list(tokens, no_quotes = false)
+    result = []
+    until tokens.empty?
+      value, tokens = build_next_value_as_string tokens
+      value = value[1..-2] if no_quotes && (check_for_string value.to_s)
+      result << value
+    end
+    result
+  end
+
+  def find_to_evaluate_or_not(tokens, no_quotes = false)
+    if tokens[0..1].join == '(list'
+      evaluate_list tokens[2..-2], no_quotes
+    elsif tokens[0..1].join == '(cons'
+      result = cons tokens[2..-2]
+      result[2..-2].split(' ')
+    else
+      no_eval_list tokens[2..-2], no_quotes
+    end
+  end
+
+  def find_idx_for_list(tokens)
+    if tokens[0] == '('
+      find_bracket_idx tokens, 0
+    elsif tokens[1] == '('
+      find_bracket_idx tokens, 1
+    end
+  end
+
+  def find_all_values_list_evaluate(tokens, no_quotes = false)
+    result = []
+    until tokens.empty?
+      x, tokens = find_next_value tokens
+      x = x[1..-2] if no_quotes && (check_for_string x.to_s)
+      result << x
+    end
+    result
+  end
+
+  def build_list(values)
+    '\'(' + values.join(' ') + ')'
+  end
+
+  def build_cons_from_list(values)
+    spacer = values[1].size == 3 ? '' : ' '
+    values[0].to_s + spacer + values[1][2..-2].to_s
+  end
+
+  def cons_helper(values)
+    result =
+      if values[1].to_s[0..1] == '\'('
+        build_cons_from_list values
+      else
+        values[0].to_s + ' . ' + values[1].to_s
+      end
+    '\'(' + result + ')'
+  end
+
+  def get_cons_values(tokens)
+    result = get_k_arguments tokens, false, 2
+    raise 'Too little arguments' if result.size != 2
+    result
+  end
+
+  def split_list_string(list)
+    result = list.split(/(\(|\)|\.)|\ /)
+    result.delete('')
+    result
+  end
+
+  def find_list_function_value(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    raise 'Invalid data type' unless other[0].list?
+    split_list_as_string other[0].to_s
+  end
+
+  def split_list_as_string(list_as_string)
+    split_value = split_list_string list_as_string.to_s
+    no_eval_list split_value[2..-2]
+  end
+
+  def car_cdr_values(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    return find_list_function_value other if other[0].list?
+    (split_list_string other[0].to_s)[2..-2] if other[0].pair?
+  end
+
+  def map_helper(lst, func)
+    return lst.map { |t| func.call(*t) } if func.is_a? Proc
+    lst.map { |t| send func, t }
+  end
+end
+
+# Scheme lists module
+module SchemeLists
+  include SchemeListsHelper
+  def cons(other)
+    raise 'Incorrect number of arguments' if other.size != 2
+    cons_helper other
+  end
+
+  def list(other)
+    build_list other
+  end
+
+  def car(other)
+    value = car_cdr_values other
+    raise 'Cannot apply car on ' + other[0].to_s if value.nil? || value.empty?
+    value.shift
+  end
+
+  def cdr(other)
+    value = car_cdr_values other
+    raise 'Cannot apply cdr on ' + other[0].to_s if value.nil? || value.empty?
+    idx = value[1] == '.' ? 2 : 1
+    build_list value[idx..-1]
+  end
+
+  def list?(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    other[0].to_s.list? ? '#t' : '#f'
+  end
+
+  def pair?(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    other[0].to_s.pair? ? '#t' : '#f'
+  end
+
+  def null?(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    return '#f' unless other[0].to_s.list?
+    other[0].to_s.size == 3 ? '#t' : '#f'
+  end
+
+  def length(other)
+    (find_list_function_value other).size
+  end
+
+  def reverse(other)
+    value = find_list_function_value other
+    build_list value.reverse
+  end
+
+  def map(other)
+    func, other = valid_function other
+    lst = find_all_values other
+    lst = lst.map { |t| find_list_function_value [t] }
+    lst = (equalize_lists lst).transpose
+    build_list map_helper lst, func
+  end
+
+  def shuffle(other)
+    values = find_list_function_value other
+    build_list values.shuffle
+  end
+end

data/lib/lisp/interpreter/numbers.rb

@@ -0,0 +1,161 @@
+# Helper functions for SchemeNumbers
+module SchemeNumbersHelper
+  def get_one_arg_function(other)
+    raise 'Incorrect number of arguments' if other.size != 1
+    raise 'Invalid data type' unless check_for_number other[0]
+    other[0].to_num
+  end
+
+  def find_idx_numerators(other)
+    other[0] == '(' ? (find_bracket_idx other, 0) + 1 : 1
+  end
+
+  def num_denom_helper(other)
+    raise 'Incorrect number of arguments' if other.empty?
+    if other.size == 1
+      other = other[0].split('/')
+    else
+      _, temp = find_next_value other
+      raise 'Incorrect number of arguments' unless temp[0] == '/' || temp.empty?
+      i = find_idx_numerators other
+      other.delete_at(i)
+    end
+    other
+  end
+
+  def get_num_denom(other)
+    num, other = find_next_value other
+    raise 'Invalid data type' unless check_for_number num
+    return [num, 1] if other.empty?
+    denom, other = find_next_value other
+    raise 'Incorrect number of arguments' unless other.empty?
+    [num, denom]
+  end
+
+  def compare_value_arithmetic(other, oper)
+    raise 'Incorrect number of arguments' if other.size < 2
+    other = convert_to_num other
+    result = other.each_cons(2).all? { |x, y| x.public_send oper, y }
+    result ? '#t' : '#f'
+  end
+
+  def convert_to_num(other)
+    other.each do |t|
+      raise 'Invalid data type' unless check_for_number t
+    end
+    other.map(&:to_num)
+  end
+
+  def divide_special_convert(other)
+    other = convert_to_num other
+    return [0] if other.size == 1 && other[0] == 0.0
+    other
+  end
+
+  def divide_number(a, b)
+    return a / b if (a / b).to_i.to_f == a / b.to_f
+    a / b.to_f
+  end
+end
+
+# Scheme numbers module
+module SchemeNumbers
+  include SchemeNumbersHelper
+
+  def <(other)
+    compare_value_arithmetic other, '<'
+  end
+
+  def >(other)
+    compare_value_arithmetic other, '>'
+  end
+
+  def <=(other)
+    compare_value_arithmetic other, '<='
+  end
+
+  def >=(other)
+    compare_value_arithmetic other, '>='
+  end
+
+  def +(other)
+    other = convert_to_num other
+    other.reduce(0, :+)
+  end
+
+  def -(other)
+    return 0 if other.empty?
+    other = convert_to_num other
+    return -other[0] if other.size == 1
+    other[0] + other[1..-1].reduce(0, :-)
+  end
+
+  def *(other)
+    other = convert_to_num other
+    other.reduce(1, :*)
+  end
+
+  def /(other)
+    raise 'Incorrect number of arguments' if other.empty?
+    other = divide_special_convert other
+    return (divide_number 1, other[0].to_num) if other.size == 1
+    other[1..-1].inject(other[0]) { |res, t| divide_number res, t }
+  end
+
+  def quotient(other)
+    raise 'Incorrect number of arguments' if other.size != 2
+    x, y = convert_to_num other
+    result = divide_number x, y
+    result < 0 ? result.ceil : result.floor
+  end
+
+  def remainder(other)
+    raise 'Incorrect number of arguments' if other.size != 2
+    x, y = convert_to_num other
+    (x.abs % y.abs) * (x / x.abs)
+  end
+
+  def modulo(other)
+    raise 'Incorrect number of arguments' if other.size != 2
+    x, y = convert_to_num other
+    x.modulo y
+  end
+
+  def numerator(other)
+    other = num_denom_helper other
+    result = (get_num_denom other)[0]
+    raise 'Invalid data type' unless check_for_number result
+    result.to_num
+  end
+
+  def denominator(other)
+    other = num_denom_helper other
+    result = (get_num_denom other)[1]
+    raise 'Invalid data type' unless check_for_number result
+    result.to_num
+  end
+
+  def abs(other)
+    (get_one_arg_function other).abs
+  end
+
+  def add1(other)
+    (get_one_arg_function other) + 1
+  end
+
+  def sub1(other)
+    (get_one_arg_function other) - 1
+  end
+
+  def min(other)
+    raise 'Incorrect number of arguments' if other.empty?
+    other = convert_to_num other
+    other.min
+  end
+
+  def max(other)
+    raise 'Incorrect number of arguments' if other.empty?
+    other = convert_to_num other
+    other.max
+  end
+end