ruby: use pattern matching, remove double negations, simplify try*

asarhaddon · Aug 5, 2024 · ecdd391 · ecdd391
1 parent fb7effe
commit ecdd391
Show file tree

Hide file tree

Showing 9 changed files with 168 additions and 235 deletions.
diff --git a/impls/ruby/step2_eval.rb b/impls/ruby/step2_eval.rb
@@ -13,28 +13,26 @@ def EVAL(ast, env)
     #puts "EVAL: #{_pr_str(ast, true)}"
 
     case ast
-        when Symbol
+    in Symbol
             raise "'" + ast.to_s + "' not found" if not env.key? ast
             return env[ast]
-        when List   
-        when Vector
+    in Vector
             return Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
+    in Hash
             new_hm = {}
             ast.each{|k,v| new_hm[k] = EVAL(v, env)}
             return new_hm
-        else 
-            return ast
-    end
 
     # apply list
-    if ast.empty?
-        return ast
-    end
 
-    f = EVAL(ast[0], env)
-    args = ast.drop(1)
-    return f[*args.map{|a| EVAL(a, env)}]
+    in [a0, *]
+        f = EVAL(a0, env)
+        args = ast.drop(1)
+        return f[*args.map{|a| EVAL(a, env)}]
+
+    else                        # Empty list or scalar
+      return ast
+    end
 end
 
 # print

diff --git a/impls/ruby/step3_env.rb b/impls/ruby/step3_env.rb
@@ -16,38 +16,32 @@ def EVAL(ast, env)
     end
 
     case ast
-        when Symbol
+    in Symbol
             return env.get(ast)
-        when List   
-        when Vector
+    in Vector
             return Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
+    in Hash
             new_hm = {}
             ast.each{|k,v| new_hm[k] = EVAL(v, env)}
             return new_hm
-        else 
-            return ast
-    end
 
     # apply list
-    if ast.empty?
-        return ast
-    end
 
-    a0,a1,a2,a3 = ast
-    case a0
-    when :def!
+    in :def!, a1, a2
         return env.set(a1, EVAL(a2, env))
-    when :"let*"
+    in :"let*", a1, a2
         let_env = Env.new(env)
         a1.each_slice(2) do |a,e|
             let_env.set(a, EVAL(e, let_env))
         end
         return EVAL(a2, let_env)
-    else
+    in [a0, *]
         f = EVAL(a0, env)
         args = ast.drop(1)
         return f[*args.map{|a| EVAL(a, env)}]
+
+    else                        # Empty list or scalar
+      return ast
     end
 end
 

diff --git a/impls/ruby/step4_if_fn_do.rb b/impls/ruby/step4_if_fn_do.rb
@@ -17,53 +17,46 @@ def EVAL(ast, env)
     end
 
     case ast
-        when Symbol
+    in Symbol
             return env.get(ast)
-        when List   
-        when Vector
+    in Vector
             return Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
+    in Hash
             new_hm = {}
             ast.each{|k,v| new_hm[k] = EVAL(v, env)}
             return new_hm
-        else 
-            return ast
-    end
 
     # apply list
-    if ast.empty?
-        return ast
-    end
 
-    a0,a1,a2,a3 = ast
-    case a0
-    when :def!
+    in :def!, a1, a2
         return env.set(a1, EVAL(a2, env))
-    when :"let*"
+    in :"let*", a1, a2
         let_env = Env.new(env)
         a1.each_slice(2) do |a,e|
             let_env.set(a, EVAL(e, let_env))
         end
         return EVAL(a2, let_env)
-    when :do
+    in [:do, *]
         ast[1..-2].map{|a| EVAL(a, env)}
-        return EVAL(ast[-1], env)
-    when :if
+        return EVAL(ast.last, env)
+    in [:if, a1, a2, *]
         cond = EVAL(a1, env)
-        if not cond
-            return nil if a3 == nil
-            return EVAL(a3, env)
-        else
+        if cond
             return EVAL(a2, env)
+        else
+            return EVAL(ast[3], env)
         end
-    when :"fn*"
+    in :"fn*", a1, a2
         return lambda {|*args|
             EVAL(a2, Env.new(env, a1, List.new(args)))
         }
-    else
+    in [a0, *]
         f = EVAL(a0, env)
         args = ast.drop(1)
         return f[*args.map{|a| EVAL(a, env)}]
+
+    else                        # Empty list or scalar
+      return ast
     end
 end
 

diff --git a/impls/ruby/step5_tco.rb b/impls/ruby/step5_tco.rb
@@ -19,51 +19,41 @@ def EVAL(ast, env)
     end
 
     case ast
-        when Symbol
+    in Symbol
             return env.get(ast)
-        when List   
-        when Vector
+    in Vector
             return Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
+    in Hash
             new_hm = {}
             ast.each{|k,v| new_hm[k] = EVAL(v, env)}
             return new_hm
-        else 
-            return ast
-    end
 
     # apply list
-    if ast.empty?
-        return ast
-    end
 
-    a0,a1,a2,a3 = ast
-    case a0
-    when :def!
+    in :def!, a1, a2
         return env.set(a1, EVAL(a2, env))
-    when :"let*"
+    in :"let*", a1, a2
         let_env = Env.new(env)
         a1.each_slice(2) do |a,e|
             let_env.set(a, EVAL(e, let_env))
         end
         env = let_env
         ast = a2 # Continue loop (TCO)
-    when :do
+    in [:do, *]
         ast[1..-2].map{|a| EVAL(a, env)}
         ast = ast.last # Continue loop (TCO)
-    when :if
+    in [:if, a1, a2, *]
         cond = EVAL(a1, env)
-        if not cond
-            return nil if a3 == nil
-            ast = a3 # Continue loop (TCO)
-        else
+        if cond
             ast = a2 # Continue loop (TCO)
+        else
+            ast = ast[3] # Continue loop (TCO)
         end
-    when :"fn*"
+    in :"fn*", a1, a2
         return Function.new(a2, env, a1) {|*args|
             EVAL(a2, Env.new(env, a1, List.new(args)))
         }
-    else
+    in [a0, *]
         f = EVAL(a0, env)
         args = ast.drop(1)
         if f.class == Function
@@ -73,6 +63,9 @@ def EVAL(ast, env)
         else
             return f[*args.map{|a| EVAL(a, env)}]
         end
+
+    else                        # Empty list or scalar
+      return ast
     end
 
     end

diff --git a/impls/ruby/step6_file.rb b/impls/ruby/step6_file.rb
@@ -19,51 +19,41 @@ def EVAL(ast, env)
     end
 
     case ast
-        when Symbol
+    in Symbol
             return env.get(ast)
-        when List   
-        when Vector
+    in Vector
             return Vector.new ast.map{|a| EVAL(a, env)}
-        when Hash
+    in Hash
             new_hm = {}
             ast.each{|k,v| new_hm[k] = EVAL(v, env)}
             return new_hm
-        else 
-            return ast
-    end
 
     # apply list
-    if ast.empty?
-        return ast
-    end
 
-    a0,a1,a2,a3 = ast
-    case a0
-    when :def!
+    in :def!, a1, a2
         return env.set(a1, EVAL(a2, env))
-    when :"let*"
+    in :"let*", a1, a2
         let_env = Env.new(env)
         a1.each_slice(2) do |a,e|
             let_env.set(a, EVAL(e, let_env))
         end
         env = let_env
         ast = a2 # Continue loop (TCO)
-    when :do
+    in [:do, *]
         ast[1..-2].map{|a| EVAL(a, env)}
         ast = ast.last # Continue loop (TCO)
-    when :if
+    in [:if, a1, a2, *]
         cond = EVAL(a1, env)
-        if not cond
-            return nil if a3 == nil
-            ast = a3 # Continue loop (TCO)
-        else
+        if cond
             ast = a2 # Continue loop (TCO)
+        else
+            ast = ast[3] # Continue loop (TCO)
         end
-    when :"fn*"
+    in :"fn*", a1, a2
         return Function.new(a2, env, a1) {|*args|
             EVAL(a2, Env.new(env, a1, List.new(args)))
         }
-    else
+    in [a0, *]
         f = EVAL(a0, env)
         args = ast.drop(1)
         if f.class == Function
@@ -73,6 +63,9 @@ def EVAL(ast, env)
         else
             return f[*args.map{|a| EVAL(a, env)}]
         end
+
+    else                        # Empty list or scalar
+      return ast
     end
 
     end