Question

can i somehow find all functions/macros that take a specific type of parameter ?

for example, what function accepts a Namespace object as parameter ?

(this is because i can create a namespace and store it in a var, but i don’t know where i could use that var; what function might i pass that var to ?)

here is some code:

user=> (def working-namespace (create-ns 'my-namespace))
#'user/working-namespace
;i created a namspace and want to use it later

user=> (class working-namespace)
clojure.lang.Namespace
; out of curiosity i found out that "working-namespace" is a Namespace object

user=> (ns working-namespace)
nil
working-namespace=>
; but how do i switch to it ? this didn't do what i wanted...

user=> (refer working-namespace)
java.lang.ClassCastException: clojure.lang.Namespace cannot be cast to clojure.lang.Symbol (NO_SOURCE_FILE:0)
; this did not work either as my expectations

user=> (the-ns working-namespace)
#<Namespace my-namespace>
user=> (class (the-ns working-namespace))
clojure.lang.Namespace
; great, this gave me the same thing, a Namespace

hence the question: how do i use it dynamically (that’s why i had put my namespace into a var) ? how do i get something useful for me from a var that points to a namespace ?

i can try look around for functions that make use of a Namespace object or that convert it to something else. i did and only found “intern”. searching by hand not seems not that promising

what if i have this problem a million time ? is there an automated way to get me what i’m looking for without having to ask around each time ?

Answer 1

In Clojure 1.2 and previous function arguments dont have types. every function argument is an object. So the question really becomes “how do i find functions that will cast the object I pass them into this type. so searching for type hints will find some of them, though it wont get you everything. I wish it where more possible to answer this in general.

starting with 1.3 (current dev branch 9/2010) function paramerters and return types can have a defined type and will be passed/returned as that type instead of being cast to object and then cast on the other side. This drops one of the zeros from the exacution time of numerical functions with the important limitation that it only works for :static functions and only with direct calls (ie: not through map/reduce/filter/etc.) There is not a lot published on this change yet though it has the important breaking change that integers are no longer boxed by default and integer (actually Long) overflow throws an exception. you can read more here

(defn ^:static fib ^long [^long n]
  (if (<= n 1)
    1
    (+ (fib (dec n)) (fib (- n 2)))))

so after 1.3 is released and widely adopted you will see code with more commonly defined types because they will offer a big speed benefit and then you will be able to find more functions by argument type though still not all of them.

At the same lecture where I learned about function argument types, Rich mentioned plans in the distant Clojure future (after ‘Clojure in Clojure’) about better support for exposing the compiler internals to tools such as IDEs. So there is hope that someday you will get a real answer to this question.
Dynamic languages make this slightly more difficult in practice and a lot harder in theory.