Question

When I write a function call like this (my-function [a b c]) in Clojure. How does Clojure find my-function? Does it perform a lookup from global/per-namespace symbol table?

I’m assuming the symbol table is implemented as a hashtable which provides O(1) time complexity for lookup. It also needs to compare the function name as a string with the symbol from the table which should take O(n) time (n is the length of the symbol). It means the longer of the symbol the slower the name resolution would be. Is it correct?

Answer 1

namespaces indeed behave as maps and you can look at them directly with the ns-map function:

autotestbed.core> (pprint (take 5 (ns-map *ns*)))
nil
([sorted-map                                                                                               
  #<Var@6899a7ce:                                                                                          
    #<core$sorted_map clojure.core$sorted_map@5875c014>>]                                                  
 [read-line                                                                                                
  #<Var@1de9e86e: #<core$read_line clojure.core$read_line@57c00972>>]                                      
 [re-pattern                                                                                               
  #<Var@74064c7b:                                                                                          
    #<core$re_pattern clojure.core$re_pattern@37d02427>>]                                                  
 [keyword?                                                                                                 
  #<Var@4798088a:                                                                                          
    #<core$keyword_QMARK_ clojure.core$keyword_QMARK_@630b813f>>]                                          
 [hta-deploy-cmd                                                                                           
  #<Var@7a7bce95:                                                                                          
    #<core$hta_deploy_cmd autotestbed.core$hta_deploy_cmd@6a6a782d>>])

more specifically they map vars to objects.

if you really do want a function to be looked up in it’s var so changes propagate through your program instantly you can call the var instead of the function that was contained in the var at compile time, which results in a lookup on every call:

(#'foo 4) looks the function up in the var every time
(foo 4) looks it up in the map once when it's compiled.