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

I have a passing knowledge of other Lisps (particularly Scheme) from way back. Recently I've been reading about Clojure. I see that it has both "symbols" and "keywords". Symbols I'm familiar with, but not with keywords.

Do other Lisps have keywords? How are keywords different from symbols other than having different notation (ie: colons)?

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

For keywords, hash values are calculated and cached when the keyword is first constructed. When looking up a keyword as a hash key, it simply returns the precomputed hashed value. For strings and symbols, the hash is recalculated on every lookup.

The why same named keywords are always identical, they contains their own hash values. As search in maps and sets are made from hash keys this envolves better search efficiency in case of numerous searches, not in the search itself.

Keywords are global, symbols are not.

This example is written in JavaScript, but I hope it helps to carry the point across.

const foo = Symbol.for(":foo") // this will create a keyword
const foo2 = Symbol.for(":foo") // this will return the same keyword
const foo3 = Symbol(":foo") // this will create a new symbol
foo === foo2 // true
foo2 === foo3 // false

When you construct a symbol using the Symbol function you get a distinct/private symbol every time. When you ask for a symbol via the Symbol.for function, you will get back the same symbol every time.

(println :foo) ; Clojure

System.out.println(RT.keyword(null, "foo")) // Java

console.log(System.for(":foo")) // JavaScript

These are all the same.

---

Function argument names are local. i.e. not keywords.

(def foo (fn [x] (println x))) ; x is a symbol
(def bar (fn [x] (println x))) ; not the same x (different symbol)