After a few months of learning about and  playing with lisps, both CL and a bit of Clojure, I'm still not seeing a compelling reason to write anything in it instead of C#.

I would really like some compelling reasons, or for someone to point out that I'm **missing something *really big***.

The strengths of a Lisp (per my research):

 - Compact, expressive notation - More so than C#, yes... but I seem to be able to express those ideas in C# too.
 - Implicit support for functional programming - C# with LINQ extension methods: 
  - mapcar = .Select( lambda )
  - mapcan = .Select( lambda ).Aggregate( (a,b) => a.Union(b) )
  - car/first = .First()
  - cdr/rest = .Skip(1) .... etc.
 - Lambda and higher-order function support - C# has this, and the syntax is arguably simpler:
  - "(lambda (x) ( body ))" versus "x => ( body )"
   - "#(" with "%", "%1", "%2" is nice in Clojure
 - Method dispatch separated from the objects - C# has this through extension methods
 - Multimethod dispatch - C# does not have this natively, but I could implement it as a function call in a few hours
 - Code is Data (and Macros) - Maybe I haven't "gotten" macros, but I haven't seen a single example where the idea of a macro couldn't be implemented as a function; it doesn't change the "language", but I'm not sure that's a strength
 - DSLs - Can only do it through function composition... but it works
 - Untyped "exploratory" programming - for structs/classes, C#'s autoproperties and "object" work quite well, and you can easily escalate into stronger typing as you go along
 - Runs on non-Windows hardware - Yeah, so?  Outside of college, I've only known one person who doesn't run Windows at home, or at least a VM of Windows on *nix/Mac. (Then again, maybe this is more important than I thought and I've just been brainwashed...)
 - The REPL for bottom-up design - Ok, I admit this is really really nice, and I miss it in C#.

Things I'm missing in a Lisp (due to a mix of C#, .NET, Visual Studio, Resharper):

 - Namespaces.  Even with static methods, I like to tie them to a "class" to categorize their context (Clojure seems to have this, CL doesn't seem to.)
 - Great compile and design-time support
  - the type system allows me to determine "correctness" of the datastructures I pass around
  - anything misspelled is underlined realtime; I don't have to wait until runtime to know
  - code improvements (such as using an FP approach instead of an imperative one) are autosuggested
 - GUI development tools: WinForms and WPF (I know Clojure has access to the Java GUI libraries, but they're entirely foreign to me.)
 - GUI Debugging tools: breakpoints, step-in, step-over, value inspectors (text, xml, custom), watches, debug-by-thread, conditional breakpoints, call-stack window with the ability to jump to the code at any level in the stack 
   - (To be fair, my stint with Emacs+Slime seemed to provide some of this, but I'm partial to the VS GUI-driven approach)


I really like the hype surrounding Lisps and I gave it a chance.

But is there anything I can do in a Lisp that I can't do as well in C#?  It might be a bit more verbose in C#, but I also have autocomplete.

What am I missing? Why should I use Clojure/CL?