Why does Clojure have "keywords" in addition to "symbols"?

Here's the Clojure documentation for Keywords and Symbols.

Keywords are symbolic identifiers that evaluate to themselves. They provide very fast equality tests...

Symbols are identifiers that are normally used to refer to something else. They can be used in program forms to refer to function parameters, let bindings, class names and global vars...

Keywords are generally used as lightweight "constant strings", e.g. for the keys of a hash-map or the dispatch values of a multimethod. Symbols are generally used to name variable and functions and it's less common to manipulate them as objects directly except in macros and such. But there's nothing stopping you from using a symbol everywhere you use a keyword (if you don't mind quoting them all the time).

The easiest way to see the difference is to read Keyword.java and Symbol.java in the Clojure source. There are a few obvious implementation differences. For example a Symbol in Clojure can have metadata and a Keyword can't.

In addition to single-colon syntax, you can use a double-colon to make a namespace-qualified keyword.

user> :foo
:foo
user> ::foo
:user/foo

Common Lisp has keywords, as do Ruby and other languages. They are slightly different in those languages of course. Some differences between Common Lisp keywords and Clojure keywords:

1. Keywords in Clojure are not Symbols.

   user> (symbol? :foo)  
   false
   

2. Keywords don't belong to any namespace unless you specifically qualify them:

   user> (namespace :foo)
   nil
   user> (namespace ::foo)
   "user"
   

(Thanks Rainer Joswig for giving me ideas of things to look at.)

Common Lisp has keyword symbols.

Keywords are symbols, too.

(symbolp ':foo) -> T

What makes keywords special:

• :foo is parsed by the Common Lisp reader as the symbol keyword::foo
• keywords evaluate to themselves: :foo -> :foo
• the home package of keyword symbols is the KEYWORD package: keyword:foo -> :foo
• keywords are exported from the package KEYWORD
• keywords are constants, it is not allowed to assign a different value

Otherwise keywords are ordinary symbols. So keywords can name functions or have property lists.

Remember: in Common Lisp symbols belong to a package. This can be written as:

• foo, when the symbol is accessible in the current package
• foo:bar, when the symbol FOO is exported from the package BAR
• foo::bar, when the symbol FOO is in the package BAR

For keyword symbols that means that :foo, keyword:foo and keyword::foo are all the same symbol. Thus the latter two notations are usually not used.

So :foo is just parsed to be in the package KEYWORD, assuming that giving no package name before the symbol name means by default the KEYWORD package.

Keywords are symbols that evaluate to themselves, so you don't have to remember to quote them.

:keywords are also treated specially by many of the collections, allowing for some really convenient syntax.

(:user-id (get-users-map))

is the same as

((get-users-map) :user-id)

this makes things just a little more flexable