Pretty up #to_s for DEFN'd procs.

lib/boot.rg

@@ -19,7 +19,8 @@
             elements))
 
 (defmacro defn [name args & body]
-  `(def ~name (fn ~args ~@body)))
+  (let [fn-name (.intern (.join [(.name (.ns (context))) (.name name)] "/"))]
+    `(def ~name (fn ~(ruby/Rouge.Symbol. fn-name) ~args ~@body))))
 
 (defmacro when [cond & body]
   `(if ~cond

lib/rouge/builtins.rb

@@ -50,7 +50,7 @@ def _compile_quote(ns, lexicals, form)
 
   def fn(context, *args)
     if args[0].is_a? Rouge::Symbol
-      name = args.shift.name
+      name = args.shift.nice_name
     end
 
     argv, *body = args
@@ -102,7 +102,7 @@ def fn(context, *args)
     }
 
     if name
-      fn.define_singleton_method(:name) { name }
+      fn.define_singleton_method(:to_s) { name }
     end
 
     fn

lib/rouge/symbol.rb

@@ -57,8 +57,12 @@ def self.[](inner)
     c
   end
 
+  def nice_name
+    :"#{@ns ? "#@ns/" : ""}#@name"
+  end
+
   def inspect
-    "Rouge::Symbol[#{:"#{@ns ? "#@ns/" : ""}#@name".inspect}]"
+    "Rouge::Symbol[#{nice_name.inspect}]"
   end
 
   def to_s; inspect; end

spec/builtins_spec.rb

@@ -119,7 +119,7 @@
     describe "storing its own name" do
       let(:fn) { context.readeval('(fn lmnop [])') }
 
-      it { fn.name.should eq :lmnop }
+      it { fn.to_s.should eq :lmnop }
     end
 
     it "should compile with names bound" do

spec/symbol_spec.rb

@@ -3,33 +3,32 @@
 require 'rouge'
 
 describe Rouge::Symbol do
-  describe "the lookup" do
-    it "should return true, false and nil" do
-      Rouge::Symbol[:true].should be true
-      Rouge::Symbol[:false].should be false
-      Rouge::Symbol[:nil].should be nil
-    end
+  describe "lookup" do
+    it { Rouge::Symbol[:true].should be true }
+    it { Rouge::Symbol[:false].should be false }
+    it { Rouge::Symbol[:nil].should be nil }
   end
 
-  describe "the constructor" do
-    it "should return new objects every time" do
-      Rouge::Symbol[:a].should_not be Rouge::Symbol[:a]
-      # but:
-      Rouge::Symbol[:a].should eq Rouge::Symbol[:a]
-    end
+  describe ".[]" do
+    it { Rouge::Symbol[:a].should_not be Rouge::Symbol[:a] }
+    # but:
+    it { Rouge::Symbol[:a].should eq Rouge::Symbol[:a] }
   end
 
-  describe "the name and ns methods" do
-    it "should return the parts of the symbol" do
-      Rouge::Symbol[:abc].ns.should be_nil
-      Rouge::Symbol[:abc].name.should eq :abc
-      Rouge::Symbol[:"abc/def"].ns.should eq :abc
-      Rouge::Symbol[:"abc/def"].name.should eq :def
-      Rouge::Symbol[:/].ns.should be_nil
-      Rouge::Symbol[:/].name.should eq :/
-      Rouge::Symbol[:"rouge.core//"].ns.should eq :"rouge.core"
-      Rouge::Symbol[:"rouge.core//"].name.should eq :/
-    end
+  describe "#ns, #name" do
+    it { Rouge::Symbol[:abc].ns.should be_nil }
+    it { Rouge::Symbol[:abc].name.should eq :abc }
+    it { Rouge::Symbol[:"abc/def"].ns.should eq :abc }
+    it { Rouge::Symbol[:"abc/def"].name.should eq :def }
+    it { Rouge::Symbol[:/].ns.should be_nil }
+    it { Rouge::Symbol[:/].name.should eq :/ }
+    it { Rouge::Symbol[:"rouge.core//"].ns.should eq :"rouge.core" }
+    it { Rouge::Symbol[:"rouge.core//"].name.should eq :/ }
+  end
+
+  describe "#nice_name" do
+    it { Rouge::Symbol[:boo].nice_name.should eq :boo }
+    it { Rouge::Symbol[:"what/nice"].nice_name.should eq :"what/nice" }
   end
 end