   end
 
   # Get stack depth
-  def compute([ "DEPTH" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [ length(data_stack) | data_stack ], return_stack, dict)
-  end
-  def compute([ "depth" | remaining_input], data_stack, return_stack, dict) do
-    compute(remaining_input, [ length(data_stack) | data_stack ], return_stack, dict)
+  inanycase :depth, fn funcname ->
+    def compute([ unquote(funcname) | remaining_input], data_stack, return_stack, dict) do
+      compute(remaining_input, [ length(data_stack) | data_stack ], return_stack, dict)
+    end
   end
 
   # Abort
-  def compute(["ABORT\"" | remaining_input ], [0 | data_stack], return_stack, dict) do
-    {_discard, ["\"" | rest]} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
-    compute(rest, data_stack, return_stack, dict)
-  end
-  def compute(["abort\"" | remaining_input ], [0 | data_stack], return_stack, dict) do
-    {_discard, ["\"" | rest]} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
-    compute(rest, data_stack, return_stack, dict)
-  end
-  def compute(["ABORT\"" | remaining_input ], [_truthy | _data_stack], _return_stack, _dict) do
-    {to_print, _rest} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
-    err = Enum.join(to_print, " ")
-    IO.write("Error: " <> err)
-    raise err
-  end
-  def compute(["abort\"" | remaining_input ], [_truthy | _data_stack], _return_stack, _dict) do
-    {to_print, _rest} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
-    err = Enum.join(to_print, " ")
-    IO.write("Error: " <> err)
-    raise err
+  inanycase :"abort\"", fn funcname ->
+    def compute([ unquote(funcname) | remaining_input ], [0 | data_stack], return_stack, dict) do
+      {_discard, ["\"" | rest]} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
+      compute(rest, data_stack, return_stack, dict)
+    end
+  end
+  inanycase :"abort\"", fn funcname ->
+    def compute([ unquote(funcname) | remaining_input ], [_truthy | _data_stack], _return_stack, _dict) do
+      {to_print, _rest} = Enum.split_while(remaining_input, fn(ins) -> ins != "\"" end)
+      err = Enum.join(to_print, " ")
+      IO.write("Error: " <> err)
+      raise err
+    end
   end
 
   # Dictionary and variable definition lookup

    compute(remaining_input, data_stack, [x, %{if: if_instructions, else: [in_else_clause | else_instructions]} | return_stack], dict)
  end

  def compute([ "ELSE" | remaining_input ], data_stack, [x, %{if: if_stack} | return_stack], dict) do
    compute(remaining_input, data_stack, [x, %{if: if_stack, else: []} | return_stack], dict)
  end
  def compute([ "else" | remaining_input ], data_stack, [x, %{if: if_stack} | return_stack], dict) do
    compute(remaining_input, data_stack, [x, %{if: if_stack, else: []} | return_stack], dict)
  end

  def compute([ in_if_clause | remaining_input ], data_stack, [x, %{if: if_instructions} | return_stack], dict) do

  end

  # note: allowing these conflicts with integer-only arithmetic
  # Whenever I build out a floating-point stack, it should probably end up there
  inanycase :pi, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], data_stack, return_stack, dict) do
      compute(remaining_input, [:math.pi | data_stack], return_stack, dict)
    end
  end

  inanycase :sin, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | data_stack], return_stack, dict) do
      compute(remaining_input, [:math.sin(x) | data_stack], return_stack, dict)
    end
  end

  inanycase :cos, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | data_stack], return_stack, dict) do
      compute(remaining_input, [:math.cos(x) | data_stack], return_stack, dict)
    end
  end

  inanycase :tan, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | data_stack], return_stack, dict) do
      compute(remaining_input, [:math.tan(x) | data_stack], return_stack, dict)
    end
  end

  inanycase :sqrt, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | data_stack], return_stack, dict) do
      compute(remaining_input, [:math.sqrt(x) | data_stack], return_stack, dict)
    end
  end

  inanycase :drop, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [_ | data_stack], return_stack, dict) do
      compute(remaining_input, data_stack, return_stack, dict)
    end
  end

  inanycase :"2drop", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [_, _ | data_stack], return_stack, dict) do
      compute(remaining_input, data_stack, return_stack, dict)
    end
  end

  inanycase :dup, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | data_stack], return_stack, dict) do
      compute(remaining_input, [x, x | data_stack], return_stack, dict)
    end
  end

  inanycase :"2dup", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x, y | data_stack], return_stack, dict) do
      compute(remaining_input, [x, y, x, y | data_stack], return_stack, dict)
    end
  end

  inanycase :"?dup", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [0 | _] = data_stack, return_stack, dict) do
      compute(remaining_input, data_stack, return_stack, dict)
    end
  end

  inanycase :"?dup", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x | _] = data_stack, return_stack, dict) do
      compute(remaining_input, [x | data_stack], return_stack, dict)
    end
  end

  inanycase :swap, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [y, x | data_stack], return_stack, dict) do
      compute(remaining_input, [x, y | data_stack], return_stack, dict)
    end
  end

  inanycase :"2swap", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [w, x, y, z | data_stack], return_stack, dict) do
      compute(remaining_input, [y, z, w, x | data_stack], return_stack, dict)
    end
  end

  inanycase :over, fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x, y | data_stack], return_stack, dict) do
      compute(remaining_input, [y, x, y | data_stack], return_stack, dict)
    end
  end

  inanycase :"2over", fn funcname ->
    def compute([ unquote(funcname) | remaining_input], [x1, x2, y1, y2 | data_stack], return_stack, dict) do
      compute(remaining_input, [y1, y2, x1, x2, y1, y2 | data_stack], return_stack, dict)
    end
  end

  # In-place decrement
