>Some may say that Rails is a poor example of a DSL. While that may be, it raises the question: are there better examples out there?

You are understanding DSL as "ok, let's import this library that defines a DSL".

In the Lisp world, one favored approach is to express the problem in the most natural way possible (i.e. like if describing the problem in english, or in any case, in your dsl language that best suits the problem.) Then, you use Lisp macros and implement this DSL. This has the side effect of making your program work, and thus, your problem to be solved. And, thus, the problem itself is specified in a high-level DSL, where it's more easy to understand and modify.

Note, also, that on a Lisp-family language, creating a DSL is very easy, since metaprogramming is very very similar to regular programming. (In Lisp, metaprogramming is not some advanced topic; quite the opposite, is taught to beginners as well.)

So, for example, if i want to create myself a library that outputs HTML, i define my DSL, which can be something like:

   (with-html-output
      (:html
         (:head
            (:title my-page-title))))

or perhaps

   (do-html-output
      (do-html-head :title my-page-title
                    :includes js-include-list))

Then, later, i'll create the functions and macros that make my language work. This solves my problem.

As you can see, anybody who knows about the problem domain of "let's do HTML output", will easily understand this DSL. In any case, if you are importing a library that defines a DSL, if the library is good, then by definition the DSL expresses the problem in the clearest way possible, and thus, it should be an easy library to use.

Perhaps it has something to do with the syntax? In Lisp, the syntax is very uniform (s-expressions) while Ruby has a far greater variety of symbols and constructs.