Exploring Clojure in the REPL
Tags: Clojure, REPL
When I first learned Linux, my friend taught me a few commands. How to to list files, how to change directories and see your current directory, how to run things, how to ask a program what parameters it takes, and how to look at a file (ls, cd, pwd, ./foo or /usr/bin/foo or foo, foo --help, cat foo or more foo). After that I just... ran a lot of stuff. I eventually discovered 'man' -- but going through /bin and running ALL the commands was really educational.
Let's get some basic tools to do that with the Clojure REPL! The major things we want to do are find things (mostly functions), and then learn all about them individually.
Finding Things
So Clojure has namespaces, which are kinda like directories, using "." as a way to indicate nesting. Vars (and thereby named functions) are kinda like files. So the full "path" to a var looks like "clojure.string/split" where "clojure.string" is the namespace and "split" is the function.
First let's get a list of all the loaded namespaces. The "ns-all" gives us this, but we want a nice sorted printout, so we'll add a bit of fancy.
user=> (doseq n (sort (map ns-name (all-ns))) (println n))
**... trimmed ...
clojure.core
clojure.core.protocols
clojure.inspector
; ... trimmed ...
clojure.repl
clojure.set
clojure.stacktrace
clojure.string
clojure.template
clojure.test
clojure.tools.cli
clojure.tools.nrepl
; ... trimmed ...
user
Use "dir" to look at all the exposed vars from a namespace
<code clojure-repl>
user=> (dir clojure.string)
blank?
capitalize
escape
join
lower-case
re-quote-replacement
replace
replace-first
reverse
split
split-lines
trim
trim-newline
triml
trimr
upper-case
Search for functions with "split" in their name. There is also "apropos" but it doesn't show namespaces -- "apropos-better" does, and "find-name" is an alias of that, so is better.
user=> (find-name "split")
(split-at split-with clojure.string/split clojure.string/split-lines net.cgrand.parsley.grammar/split-empty-prods)
You can also use a regex! Not sure how useful this is... but here we are getting all the functions that start with an "s" and in with a "t".
<code clojure-repl>
user=> (find-name #"^s.*t$")
(set short sort sorted-set spit split-at struct clojure.set/select clojure.string/split clojure.test/set-test net.cgrand.sjacket/shift net.cgrand.sjacket/shift-right net.cgrand.sjacket/str-pt net.cgrand.sjacket/subedit)
Learning About Things
Once you've found your function, you'll want to learn more about it and maybe give it a try.
"doc" can be used to get the documentation associated with a function. This is pretty cool! It shows the full name of the function, its signature, and it's documentation.
user=> (doc print)
clojure.core/print
(& more)
Prints the object(s) to the output stream that is the current value
of out. print and println produce output for human consumption.
Note that you can tab-complete
<code clojure-repl>
user=> (doc print<tab>
print print-ctor print-dup print-method print-simple print-str
printf println println-str
If you don't know what you're looking for, you can also try find-doc. This will search both the name and the documentation itself for your string or regex.
user=> (find-doc "split")
; ..... too long to include ;)
THE ULTIMATE:** Get the source for a function!
<code clojure-repl>
user=> (source print)
(defn print
"Prints the object(s) to the output stream that is the current value
of *out*. print and println produce output for human consumption."
{:added "1.0"
:static true}
[& more]
(binding [*print-readably* nil]
(apply pr more)))
Not everything is a function. Heck, sometimes you might not know what sort of thing you're looking at. But we can find out.
user=> (type 5)
java.lang.Long
user=> (type 5.2)
java.lang.Double
user=> (type "hello")
java.lang.String
user=> (type 'hello)
clojure.lang.Symbol
user=> (type {:a 5, 6})
clojure.lang.PersistentArrayMap
user=> (type 1 2 3)
clojure.lang.PersistentVector
user=> (type type)
clojure.core$type
user=> (type dir)
CompilerException java.lang.RuntimeException: Can't take value of a macro: #'clojure.repl/dir, compiling:(/tmp/form-init5987247545872948247.clj:1:1)
user=> (type clojure.string/split)
clojure.string$split
user=> (defn say-hi (println "hi!"))
#'user/say-hi
user=> (type say-hi)
user$say_hi
## Getting GUI
Clojure comes with clojure.inspector, which gives some Swing GUI for exporing data structures.
<code clojure-repl>
user=> (use 'clojure.inspector)
user=> (inspect-tree {:a 1 :b 2 :c [1 2 3 {:d 4 :e 5 :f [6 7 8]}]})
NOTE: I had to do this to get jdk-1.7 swing apps to display while using xmonad (and other tiling window managers I guess). I now dropped this in my ~/.zshrc. Uhg.
export _JAVA_AWT_WM_NONREPARENTING=1
## Doing Horrible Things
So let's have some fun. First, let's get all the string function names. "dir-fn" is like dir, but returns the results instead of printing them.
<code clojure-repl>
user=> (def string-funcs (clojure.repl/dir-fn 'clojure.string))
Let's turn them into their actual functions.
user=> (def real-string-funcs (map #(resolve (symbol (str "clojure.string/" %))) string-funcs))
Given a function, here is how to tell how many parameters it takes (well... it might take more or less than this, but this will tell us how many params for the first definition. Good enough).
<code clojure-repl>
user=> (defn arg-count [f] (count (first (:arglists (meta f)))))
Here is a handy thing that tells us if the given function can deal with a single arg.
user=> (defn single-arg? f (= 1 (arg-count f)))
Now let's filter our string functions down to the ones that just take one argument.
<code clojure-repl>
user=> (def one-arg-funcs (filter single-arg? real-string-funcs))
So. We if have a one-argument function in the clojure.string namespace, let's assume it takes a string and pass in a string to it :) . The "pr-str" bit is so that we can pretty-print this with escaped newlines and such later.
user=> (defn one-arg-result f (pr-str (apply f "Hello\nworld\n")))
Now let's try this on all the one-argument string functions, printing out the function name and the result pretty like.
<code clojure-repl>
user=> (map #(println (:name (meta %)) "\"Hello\\nworld\\n\" ->" (one-arg-result %)) one-arg-funcs)
blank? "Hello\nworld\n" -> false
capitalize "Hello\nworld\n" -> "Hello\nworld\n"
join "Hello\nworld\n" -> "Hello\nworld\n"
lower-case "Hello\nworld\n" -> "hello\nworld\n"
re-quote-replacement "Hello\nworld\n" -> "Hello\nworld\n"
reverse "Hello\nworld\n" -> "\ndlrow\nolleH"
split-lines "Hello\nworld\n" -> ["Hello" "world"]
trim "Hello\nworld\n" -> "Hello\nworld"
trim-newline "Hello\nworld\n" -> "Hello\nworld"
triml "Hello\nworld\n" -> "Hello\nworld\n"
trimr "Hello\nworld\n" -> "Hello\nworld"
upper-case "Hello\nworld\n" -> "HELLO\nWORLD\n"
Woo!