> With a total of around 590 unique functions7 in the Clojure core library alone that can be quite daunting when compared to C or Java which only range from around 30 to 50 keywords.
I count 19 special forms, 71 macros [1], 444 functions, and 29 variables in clojure.core. I don't think we should count functions or variables because these are like library functions and members (methods and fields) in other languages. But both special forms and macros are special in that they can't be passed around in the executing code. There's 90 of those, which is comparable to Java's 50-something keywords, or C#'s 70-something.
[1] excluding the 4 special forms `let`, `fn`, `letfn`, and `loop` which are also macros
Yeah, ok, I see what you are getting at with the macros not being the same as a function that can be passed. I used the wrong word when I said special forms, I was referring to "unusul syntax" stuff like #(), [], {}, anything that isn't just a list. You are right though, while I found the clojure special forms much more regular than Java's keywords and therefore much easier to learn, since they sometimes defer evaluation, they should probably be treated as a separate case.
The other thing that bugs me about a count like this as a metric, is it doesn't speak at all to the complexity of the keywords. For example, think of how complex the extends keyword is in Java/C#. Just that one keyword represents usually one of the hardest things to learn about Java. Or the defmacro special form in Clojure. Macros are a huge area of confusion when learning a language. The count metric makes very little sense in explaining the difficultly to learn a language.
Agreed, counting keywords in Java or macros in Clojure core isn't comparable. For example, keywords such as `:when`, `:while`, and `:let` inside a Clojure `for` macro support the macro name, perhaps in the same way `extends` supports the `class` or `interface` keywords in Java. It would even be possible to have only one publicly visible macro in Clojure with keywords in 2nd position to chose the behavior, e.g. `(macro :defn myfn [a] (print a))`.
I count 19 special forms, 71 macros [1], 444 functions, and 29 variables in clojure.core. I don't think we should count functions or variables because these are like library functions and members (methods and fields) in other languages. But both special forms and macros are special in that they can't be passed around in the executing code. There's 90 of those, which is comparable to Java's 50-something keywords, or C#'s 70-something.
[1] excluding the 4 special forms `let`, `fn`, `letfn`, and `loop` which are also macros