missinglisp 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42f4de8720dddb978bf21be93ef48d8aab819a588ac139245dcbafd541251e32
+  data.tar.gz: e370720f4a3f0eadda1afa9f38fb371eb68be30b886e8274241786d0549dbda0
+SHA512:
+  metadata.gz: e15a0228df6251a9615609bafdf2f182193ac01b71ef840640e14690571d3309eefe791fa1a76cfdc20db972dbc674de9fb45a413782560ba5bbf1e2d1912e50
+  data.tar.gz: ca39b773ab93ad1e52a0867810faa28537761da5a7840988e9e8cf77f9cd17e1d8983147d3e320eb23748914e51878ae20f4e713742dcabb9971b5401d88908b

data/lib/missinglisp.rb

@@ -0,0 +1,174 @@
+class Lisp
+  def initial_env
+    {
+      car: ->(*ls) { ls[0][0] },
+      cdr: ->(*ls) { ls[0].drop 1 },
+      cons: ->(e, cell, *) { [e] + cell },
+      list: ->(*ls) { ls },
+      add: ->(*ls) { ls.sum },
+      sub: ->(hd, *tl) { tl.reduce(hd) { |sum, v| sum - v } },
+      mult: ->(*ls) { ls.reduce(:*) },
+      div: ->(hd, *tl) { tl.reduce(hd) { |sum, v| sum / v } },
+
+      eq: ->(a, b, *) { a == b },
+      lt: ->(a, b, *) { a < b },
+      leq: ->(a, b, *) { a <= b },
+      gt: ->(a, b, *) { a > b },
+      geq: ->(a, b, *) { a >= b },
+
+      p: ->(*ls) { p ls },
+
+      nil: []
+    }
+  end
+
+  def eval(exp, env)
+    return exp if exp.is_a? Numeric
+    return env[exp] if exp.is_a? Symbol
+
+    # list
+    # Special forms
+    if exp[0] == :quote
+      return exp[1..]
+    elsif exp[0] == :if
+      _, test, e1, e2 = exp
+      test = self.eval(test, env)
+      return self.eval(e1, env) if test.is_a?(Array) && !test.empty?
+      return self.eval(e1, env) unless test.is_a?(Array) || !test
+
+      return self.eval(e2, env)
+    elsif exp[0] == :define
+      _, var, e = exp
+      env[var] = self.eval(e, env)
+      return []
+    elsif exp[0] == :lambda
+      _, params, e = exp
+      return ->(*args) { self.eval(e, env.merge(Hash[params.zip(args)])) }
+    end
+
+    args = exp[1..].map { |c| self.eval(c, env) }
+    env[exp.first]
+      .call(*args)
+  end
+
+  def parse(program)
+    tokens = tokenize program
+    _parse tokens
+  end
+
+  def _parse(tokens)
+    return if tokens.empty?
+
+    token = tokens.shift
+
+    case token
+    when :L
+      list = []
+
+      while tokens.first != :J
+        raise 'unexpected end of input' if tokens.empty?
+
+        list << _parse(tokens)
+      end
+      tokens.shift
+
+      list
+    when :J
+      raise 'unexpected \'J\''
+    else
+      token
+    end
+  end
+
+  def tokenize(s)
+    res = []
+    cur = ''
+    is_reading_digit = false
+    s.each_char do |c|
+      case c
+      when '_'
+        if cur != ''
+          if is_reading_digit
+            res.push cur.to_i
+          else
+            res.push cur.to_sym
+          end
+
+          cur = ''
+          is_reading_digit = false
+        end
+      when 'L'
+        if cur != ''
+          if is_reading_digit
+            res.push cur.to_i
+            cur = ''
+            is_reading_digit = false
+            res.push :L
+            next
+          end
+
+          cur += 'L' and next
+        end
+
+        res.push :L
+      when 'J'
+        if cur != ''
+          if is_reading_digit
+            res.push cur.to_i
+            cur = ''
+            is_reading_digit = false
+            res.push :J
+            next
+          end
+
+          cur += 'J' and next
+        end
+
+        res.push :J
+      when '0'..'9'
+        cur += c and next if cur != ''
+
+        is_reading_digit = true
+        cur = c
+      else
+        if is_reading_digit
+          res.push cur.to_i
+          cur = ''
+          is_reading_digit = false
+        end
+
+        cur += c
+      end
+    end
+
+    res.push cur.to_sym if cur != ''
+
+    res
+  end
+end
+
+module Kernel
+  # For irb
+  WHITE_LIST = %I[gets to_ary to_io to_str to_hash translate]
+  alias_method :base_method_missing, :method_missing
+
+  def eval_lisp(s)
+    @l ||= Lisp.new
+    @e ||= @l.initial_env
+    @l.eval(@l.parse(s), @e)
+  end
+
+  def method_missing(m, *args, &block)
+    if WHITE_LIST.include? m
+      base_method_missing(m, args, block)
+    end
+
+    eval_lisp m.to_s
+  end
+end
+
+class Object
+  def self.const_missing(id)
+    eval_lisp id.to_s
+  end
+end

metadata

@@ -0,0 +1,39 @@
+--- !ruby/object:Gem::Specification
+name: missinglisp
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Yajima Soichi
+bindir: bin
+cert_chain: []
+date: 2025-05-10 00:00:00.000000000 Z
+dependencies: []
+email: jajima.jp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/missinglisp.rb
+homepage: https://github.com/jajimajp/missinglisp
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Lisp in Ruby variable names
+test_files: []