The result of converting one of @Raynes #clojure logs into an ES _bulk import ready JSON file

2011-07-04.json

{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:03:35", "author": "lnostdal-laptop", "message": "ring seems to mess around with stdout (*out* ?) or something ..   debug output using println doesn't show up in slime here" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:04:03", "author": "lnostdal-laptop", "message": "..and exceptions end up in the terminal; where i started `lein swank'" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:04:20", "author": "lnostdal-laptop", "message": "..is there some way of fixing this? ..  i.e. println output should end up in slime, and exceptions also" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:05:56", "author": "hoeck", "message": "lnostdal-laptop: the server code runs in a different thread than the slime repl, and slime only redirects stdout of its own repl thread" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:06:55", "author": "lnostdal-laptop", "message": "ah,  i remember this being an issue with SBCL also .. there was a fix for it though .. hmm" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:07:18", "author": "lnostdal-laptop", "message": "(setf swank:*globally-redirect-io* t) ;; fixed it for SBCL" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:08:10", "author": "hoeck", "message": "for exceptions, you could wrap your handler bodies in (try (do ) catch Exception e (swap! *server-exceptions* conj e)) and then manually throw the last exception or so from the slime repl" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:08:45", "author": "hoeck", "message": "or mess with the default exception handler of the thread the ring handler is invoked in, probably by modifying some server config" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:11:40", "author": "hoeck", "message": "lnostdal-laptop: maybe (System/setOut *out*) works" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:15:46", "author": "lnostdal-laptop", "message": "(let [*out* *out*]  (defn handler [req] (binding [*out* *out*] ...)))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:15:49", "author": "lnostdal-laptop", "message": "seems to work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:16:02", "author": "lnostdal-laptop", "message": "..with regards to output and stuff" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:18:09", "author": "halfprogrammer", "message": "lnostdal-laptop: the stacktrace middleware prints the exception in *err* stream" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:19:00", "author": "halfprogrammer", "message": "that is why you see exception in lein repl" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:23:54", "author": "lnostdal-laptop", "message": "ok" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:24:00", "author": "lnostdal-laptop", "message": "i'm not using that middleware though" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:24:38", "author": "halfprogrammer", "message": "oh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:25:28", "author": "lnostdal-laptop", "message": "(..should i? .. i'm not sure what that middleware does; i thought it was used to display the stacktrace on the web page; which is not what i'm after..)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:28:17", "author": "lnostdal-laptop", "message": "is there a `break' ..for triggering an exception?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:29:55", "author": "halfprogrammer", "message": "lnostdal-laptop: as far as I remember it displays the stacktrace both on the web page and on the *err* stream." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:30:16", "author": "halfprogrammer", "message": "I am not getting what you mean by `break" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:31:03", "author": "lnostdal-laptop", "message": "like http://www.lispworks.com/documentation/HyperSpec/Body/f_break.htm" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:32:27", "author": "halfprogrammer", "message": "if you want to insert breakpoints you can use swank.core/break." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:33:00", "author": "lnostdal-laptop", "message": "using this Javaish thing seems to work: (throw (Exception. \"I got here\"))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:33:01", "author": "lnostdal-laptop", "message": "ah" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T04:33:12", "author": "halfprogrammer", "message": ":)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:45:18", "author": "peteriserins", "message": "I want to create a macro that serves as with-connection-to-my-database (with known credentials)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:46:08", "author": "peteriserins", "message": "(defmacro with-connection-to-mydb [db-spec & body] (let [credentials ..] (with-connection ~db-spec ~@body)))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:46:26", "author": "peteriserins", "message": "tried unquoting the let and it didn't work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:46:38", "author": "peteriserins", "message": "*backquoting" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:52:11", "author": "rlb", "message": "peteriserins: what are you trying to do?  i.e. when should credentials be  computed?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:52:45", "author": "peteriserins", "message": "rlb: compile time" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:52:58", "author": "rlb", "message": "So what didn't work?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:53:15", "author": "peteriserins", "message": "for starters, I need to have db-spec as a symbol" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:53:23", "author": "peteriserins", "message": "and I cannot find how to do that" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:55:09", "author": "rlb", "message": "Do you have an example of a form the expansion you'd like?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:56:13", "author": "peteriserins", "message": "(with-c-mydb db (print \"Credentials: \" db))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:59:35", "author": "peteriserins", "message": "rlb: I actually see now that the db parameter is redundant" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T05:59:45", "author": "peteriserins", "message": "rlb: it should just be [& body]" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T06:00:55", "author": "rlb", "message": "OK." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T06:01:48", "author": "peteriserins", "message": "rlb: OK, it works now" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T06:01:56", "author": "peteriserins", "message": "rlb: I surrounded everything with #" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T06:50:49", "author": "gfrlog", "message": "if I have a long (millions) seq of numbers, (apply + coll) and (reduce + coll) ought to perform equivalently, right?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:02:58", "author": "halfprogrammer", "message": "gfrlog: should it necessarily be the same?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:03:31", "author": "gfrlog", "message": "well I can't think of why it ought to be different. I only ask because it feels weird to call a function with millions of args." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:03:33", "author": "halfprogrammer", "message": "wont reduce take more time?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:05", "author": "gfrlog", "message": "you think + is optimized for lots of args?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:10", "author": "Chousuke", "message": "apply + calls reduce so no" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:32", "author": "gfrlog", "message": "ah yeah, I see that in the source now" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:37", "author": "halfprogrammer", "message": "hmmm" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:46", "author": "gfrlog", "message": "([x y & more] (reduce + (+ x y) more))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:50", "author": "Chousuke", "message": "in some cases apply is faster though" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:04:53", "author": "Chousuke", "message": "like apply str" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:05:07", "author": "gfrlog", "message": "StringBuilder" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:05:12", "author": "halfprogrammer", "message": "hmm" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:05:21", "author": "gfrlog", "message": "Chousuke: interesting, thanks" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:06:16", "author": "Chousuke", "message": "in general, if you expect that a function can do something smart if it controls what to do with more than two args, then use apply." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:06:20", "author": "Chousuke", "message": "otherwise, reduce is fine" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T07:30:30", "author": "archaic`", "message": "hi. anyone out there?, how come in compojure/ring? a route (GET \"/\" [] (println \"foo\")) will print foo twice whenever i refresh the browser at uri / ?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T08:30:05", "author": "msappler", "message": "hi" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T08:30:32", "author": "msappler", "message": "i want to share the source code of a clojure game I developed on google code ... what licence is appropriate?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T08:49:16", "author": "gfrlog", "message": "archaic`: you could use CURL to check if the repetition happens in the app or the browser" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:19:48", "author": "msappler", "message": "okay I open sourced my game under MIT: http://resatori.com/open-sourcing-cyber-dungeon-quest" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:33:56", "author": "ejackson", "message": "msappler: congrats !" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:35:56", "author": "cemerick", "message": "msappler: looks pretty fun — reminds me of gauntlet from my C64 days :-D" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:36:24", "author": "cemerick", "message": "you should put a new video up on the google code page — I had to hunt around for the one you did in March" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:37:23", "author": "msappler", "message": "thanks ... just have to find out how to put videos pictures on google code" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:37:46", "author": "cemerick", "message": "Or, just a permalink to it on your blog or something *shrug*" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:40:10", "author": "msappler", "message": "put the old video there :) https://code.google.com/p/clojure-rpg/" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T09:42:06", "author": "cemerick", "message": "nice; I'll tweet tomorrow when more people are around" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:08:58", "author": "matthias__", "message": ",(doc replicate)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:08:59", "author": "clojurebot", "message": "\"([n x]); Returns a lazy seq of n xs.\"" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:14:37", "author": "pcavs", "message": "What's the best way to test reading from standard input with clojure + leiningen?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:37:17", "author": "matthias__", "message": "someone should add a list of the most popular clojars to clojars.org" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:55:41", "author": "fliebel", "message": "What is \"the best\" was of serializing Clojure data structures? Just print and read, or is there something more advanced?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T10:55:49", "author": "fliebel", "message": "*way" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:06:27", "author": "rlb", "message": "fliebel: if you're just going to/from clojure, I'd think read/write unless you have special needs." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:06:45", "author": "rlb", "message": "fliebel: (for clojure s/write/pr/)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:22:55", "author": "fliebel", "message": "rlb: Okay, fine :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:26:10", "author": "mids", "message": "and if you need performance / compatibility probably thrift or protocol buffers" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:26:58", "author": "fliebel", "message": "mids: But then you'd need to specify the format beforehand, right? Or can you just say (thrift [\"aa\" 3])" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:28:01", "author": "mids", "message": "yes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:28:12", "author": "mids", "message": "err, yeah you need to specify the format beforehand" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:28:20", "author": "fliebel", "message": "I that case I'd rather use... the ztellman thing." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:29:15", "author": "fliebel", "message": "gloss" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:30:17", "author": "rlb", "message": "and if you need to speak to python, etc., perhaps json..." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:31:14", "author": "mids", "message": "or XML :P" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:41:38", "author": "babilen", "message": "technomancy: ping" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:47:53", "author": "ilyak", "message": "Thing I don't like about Clojure:" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:48:14", "author": "ilyak", "message": "Sometimes it treats java collections as first-class collections. Sometimes it doesn't." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:48:25", "author": "ilyak", "message": "It's not mentioned in docs and it's painful" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:48:36", "author": "ilyak", "message": "I guess I'll have to roll out some my own collection functions" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:48:59", "author": "ilyak", "message": ",(contains? (Collections/singleton 1) 1)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:48:59", "author": "clojurebot", "message": "false" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:49:09", "author": "ilyak", "message": "This sucks" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:53:42", "author": "gfrlog", "message": "that's funny it returns anything" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:53:53", "author": "gfrlog", "message": ",(contains? :foo :bar)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:53:53", "author": "clojurebot", "message": "false" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T11:53:59", "author": "gfrlog", "message": "weerd." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T12:25:40", "author": "agumonkey", "message": "hi all" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T12:29:25", "author": "agumonkey", "message": "anybody knows why jline fails when moving cursor or deleting/backspacing ?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T14:45:10", "author": "amalloy", "message": "&(java.util.Collections/singleton 1)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T14:45:10", "author": "sexpbot", "message": "⟹ #<SingletonSet [1]>" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T14:45:25", "author": "amalloy", "message": "&(java.util.Collections/singleton (into-array [1]))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T14:45:25", "author": "sexpbot", "message": "⟹ #<SingletonSet [[Ljava.lang.Integer;@72fd0e]>" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T14:45:39", "author": "amalloy", "message": "hm. well duh, of course that's not variadic. never mind :P" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:03:13", "author": "pcavs", "message": "How does one support default values in a idiomatic, succinct way? Does one have to use multimethods and then pass the default value to the expanded version of the function?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:06:19", "author": "amalloy", "message": "pcavs: your suggested solution doesn't make any sense as far as i can tell. by \"multimethod\" do you mean \"function with multiple arities/bodies\"?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:06:32", "author": "pcavs", "message": "yes, sorry" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:06:35", "author": "amalloy", "message": "if so, that's one common way to do it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:06:45", "author": "pcavs", "message": "alrighty, what's the other?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:06:57", "author": "amalloy", "message": "another is to use a map and destructure it with the :or key" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:07:41", "author": "amalloy", "message": "&((fn [& {:keys [a b] :or {b 10}}] [a b]) :a 9)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:07:41", "author": "sexpbot", "message": "⟹ [9 10]" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:23:07", "author": "amalloy", "message": "matthias__: btw, i've never used replicate. these days repeat does the same thing in fewer characters; i think replicate was probably written when repeat didn't take an N argument?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:23:33", "author": "davekong", "message": "I am getting the error:  Wrong number of args (1) passed to ... for a function that always takes one argument, any ideas what could be going on? I tested it in the repl and I don't get an error but within my program I do" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:24:03", "author": "matthias__", "message": ",(doc repeat)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:24:03", "author": "clojurebot", "message": "\"([x] [n x]); Returns a lazy (infinite!, or length n if supplied) sequence of xs.\"" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:24:40", "author": "amalloy", "message": "davekong: is it a macro?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:24:48", "author": "davekong", "message": "amalloy: no" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:26:13", "author": "gfrlog", "message": "davekong: is it a function you defined?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:26:22", "author": "davekong", "message": "gfrlog: yes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:27:08", "author": "davekong", "message": "The argument I am passing is a map if that is of significance" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:28:04", "author": "gfrlog", "message": "shouldn't be. For lack of any other ideas, could you show us the function definition and call?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:28:13", "author": "davekong", "message": "sure" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:31:14", "author": "davekong", "message": "http://codepad.org/h2RwYCif gfrlog , the call is on the line with the CALLE HERE comment, with-client-socket is a macro" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:38:11", "author": "Somelauw", "message": "Has cake, leininingen, emacs or anything an interactive mode? Does clojure-jack-in have a manual which possibly explains it?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:38:28", "author": "amalloy", "message": "emacs is one giant interactive mode" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:39:32", "author": "amalloy", "message": "davekong: fwiw, the (((game :rules) :max-raises) (betting-round game)) construct is confusing to me" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:40:14", "author": "amalloy", "message": "i'd probably write it as a get-in" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:41:22", "author": "davekong", "message": "amalloy: okay thanks, I'm I still pretty new to clojure" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:43:03", "author": "amalloy", "message": "davekong: i'm not sure if it's a common thing or just my personal preference, but (:foo m) feels a lot more natural to me than (m :foo), though the first only works for keywords" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:43:35", "author": "ibdknox", "message": "amalloy: I'm the same way" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:43:46", "author": "amalloy", "message": "but i'm afraid i don't see anything in your code that would throw the exception you're seeing" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:43:59", "author": "Somelauw", "message": "amalloy: what manual page of emacs should I read to learn about interactive mode?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:44:58", "author": "amalloy", "message": "Somelauw: if you have a version of clojure-mode that has jack-in, you should just be able to call it and it will start up a repl buffer. but ask technomancy, if that doesn't seem to work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:46:14", "author": "Somelauw", "message": "amalloy: that already works. But I have a file with code and want to test the code in that file." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:46:29", "author": "amalloy", "message": "C-c C-k compiles/runs the current file" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:46:42", "author": "Somelauw", "message": "So I want to make the functions in that file accesible from the repl." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:47:03", "author": "amalloy", "message": "C-c C-c compiles the top-level form you're currently pointing at; C-x C-e evaluates the form (not necessarily top-level) immediately before point" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:47:56", "author": "amalloy", "message": "there's http://www.pchristensen.com/slimecommands.pdf for a slime cheat sheet - clojure's swank doesn't support all of these yet, but you can try something and hope" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:48:29", "author": "Somelauw", "message": "Well thanks. C-k, C-k seems to work. Any good tutorial or reference since I want to learn more?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:49:02", "author": "Somelauw", "message": "Okay, thanks for slime-commands." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:49:11", "author": "amalloy", "message": "i bet technomancy's screencast covers this sort of thing" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:52:32", "author": "Somelauw", "message": "Which screencast do you mean?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:55:30", "author": "amalloy", "message": "http://technomancy.us/120 i think. i haven't watched it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T15:56:14", "author": "Somelauw", "message": "okay, thanks, I will take a look at it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:05:52", "author": "davekong", "message": "amalloy: I figured it out, the wrong number of args was to #(= \\r) not the function itself.. that should be #(= \\r) or using partial" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:06:17", "author": "amalloy", "message": "davekong: good lesson. always paste the stacktrace" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:06:43", "author": "amalloy", "message": "which would be pretty clear in your case" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:07:12", "author": "amalloy", "message": "wrong number of arguments (1) passed to my.game$legal-actions$fn__5786 or something" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:07:23", "author": "amalloy", "message": "rather than: wrong number of arguments (1) passed to my.game$legal-actions" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:07:36", "author": "davekong", "message": "amalloy: http://codepad.org/X1iawnyY" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:10:02", "author": "davekong", "message": "hopefully now that I understand the stack a little better I won't need to ask next time" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:10:10", "author": "davekong", "message": "stack trace" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:10:36", "author": "amalloy", "message": "davekong: in this case the thing that's useful is knowing how clojure creates classnames for functions" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:11:52", "author": "amalloy", "message": "actually i'm not sure why there's no numbers after the $fn in your example. but basically, each closure is named <enclosing-function-name>$fn__nnnn" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:12:08", "author": "amalloy", "message": "eg, ##(class (partial + 5))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:12:08", "author": "sexpbot", "message": "⟹ clojure.core$partial$fn__3678" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:12:46", "author": "davekong", "message": "##(class #(+ 5))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:12:46", "author": "sexpbot", "message": "⟹ sandbox10545$eval13084$fn__13085" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:13:57", "author": "davekong", "message": "##(class #(= \\r))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:13:57", "author": "sexpbot", "message": "⟹ sandbox10545$eval13093$fn__13094" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:14:00", "author": "davekong", "message": "hmm" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:14:15", "author": "amalloy", "message": "davekong: of course learning that you need to include % in the function is a good lesson, but i'd solve your problem by using a set as a function: (filter #{\\r} (round-actions game)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:14:58", "author": "gfrlog", "message": "davekong: sorry bout wandering off." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:15:09", "author": "davekong", "message": "np" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:15:41", "author": "amalloy", "message": "and you can do the same in the cond expression in play-game: (cond (nil? msg) game, (#{\\# \\;} (first msg)) (recur game))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:15:42", "author": "gfrlog", "message": "did it get sorted out? lotta stuff to read through..." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:15:47", "author": "amalloy", "message": "yeah" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:16:09", "author": "gfrlog", "message": "oh I see it was the anon function" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:16:20", "author": "gfrlog", "message": "those are fun" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:16:42", "author": "amalloy", "message": "gfrlog: today's lesson was for us to always demand a real stacktrace, not a summary" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:17:05", "author": "gfrlog", "message": "amalloy: could you repeat that as a stacktrace?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:17:19", "author": "amalloy", "message": "$kill gfrlog" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:17:19", "author": "sexpbot", "message": "KILL IT WITH FIRE!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:19:18", "author": "davekong", "message": "neat" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:19:37", "author": "davekong", "message": "I like how concise clojure can get" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:20:32", "author": "mrnex2010", "message": "What would be a simple way to execute code upon invoking lein repl? (edgar goncalves sais that since lein 1.3 u cant just put it in the project.clj)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:22:23", "author": "gfrlog", "message": "woah" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:22:36", "author": "gfrlog", "message": "I was gonna make a joke that you could make a user.clj and just stick your code in there" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:22:47", "author": "gfrlog", "message": "then I tried it and it worked" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:08", "author": "gfrlog", "message": "it worked...twice actually." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:33", "author": "davekong", "message": "Well I noticed core.clj gets loaded automatically?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:34", "author": "amalloy", "message": "i think user.clj is deprecated though" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:36", "author": "gfrlog", "message": "probably has something to do with that \"server listening...\"" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:44", "author": "gfrlog", "message": "oh does it?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:46", "author": "mrnex2010", "message": "da hell? if i have a user.clj in the project, it will execute that code?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:50", "author": "amalloy", "message": "or something like that" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:23:56", "author": "gfrlog", "message": "mrnex2010: did it for me" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:05", "author": "gfrlog", "message": "$ lein repl" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:05", "author": "gfrlog", "message": "USER" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:06", "author": "gfrlog", "message": "USER" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:06", "author": "gfrlog", "message": "REPL started; server listening on localhost:27883." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:08", "author": "gfrlog", "message": "user=>" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:18", "author": "gfrlog", "message": "where user.clj contains (println \"USER\")" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:38", "author": "mrnex2010", "message": "oh thats nice!!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:24:41", "author": "gfrlog", "message": "lemme def something and see if it's there..." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:25:09", "author": "gfrlog", "message": "that works too" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:25:25", "author": "amalloy", "message": "pft. you wish" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:25:43", "author": "mrnex2010", "message": "coz i wanna make something that imports all namespace in the project for developement purposes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:25:48", "author": "gfrlog", "message": "yeah core.clj don't work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:25:50", "author": "davekong", "message": "maybe it is only when you say it is main" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:26:17", "author": "gfrlog", "message": "davekong: confirmed" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:26:22", "author": "gfrlog", "message": "davekong: and once again it loads it twice" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:29:56", "author": "mrnex2010", "message": "thank you very much guyse" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:32:01", "author": "Somelauw", "message": "I think I really hate emacs, but like its interaction mode. So I will just program in vim and refresh the file in emacs whenever I want to test something." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:32:59", "author": "mrnex2010", "message": "srry gfrlog, where did you place the user.clj?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:33:09", "author": "gfrlog", "message": "mrnex2010: src/user.clj" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:33:20", "author": "mrnex2010", "message": "ty" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:33:45", "author": "mrnex2010", "message": "YaY!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:37:18", "author": "amalloy", "message": "Somelauw: a lot of the benefit comes from things like having documentation available while editing" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:37:53", "author": "amalloy", "message": "eg, start typing a function call and it gives you hints about what args it takes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:39:08", "author": "gfrlog", "message": "why nobody builds SLIMV?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:39:32", "author": "amalloy", "message": "gfrlog: you need it built for you?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:39:49", "author": "amalloy", "message": "i can't tell if you're punning or clueless; slimv does exist, though i assume slime is better" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:40:03", "author": "gfrlog", "message": "oh I'm clueless" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:40:36", "author": "gfrlog", "message": "I need to learn to google before I announce stuff I make up" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:41:55", "author": "gfrlog", "message": "man if this thing works halfway decently that might be the nail in the coffin of me learning emacs" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:42:17", "author": "amalloy", "message": "gfrlog: you should hang out in here when someone asks how to install slimv" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:42:48", "author": "amalloy", "message": "it's like having to invent the wheel every time you build a car. so many things to do" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:43:16", "author": "gfrlog", "message": "but every 5th question is about swank/slime" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:47:06", "author": "amalloy", "message": "gfrlog: right at the moment my slime is broken because i wanted to try out ritz. so i guess i'm not in a position to brag about slime's simplicity. although i did get it set up on a fresh ubuntu install in no time at all" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:48:32", "author": "gfrlog", "message": "what about SLIMW?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:49:00", "author": "gfrlog", "message": "(Word)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:49:26", "author": "gfrlog", "message": "sorry, I won't do it again..." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:52:38", "author": "amalloy", "message": "gfrlog: you should be able to put together a convincing demo of SLIMW by next april 1st" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:53:18", "author": "amalloy", "message": "or the conj. surely there's space for some comic relief" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:55:40", "author": "gfrlog", "message": "amalloy: if it didn't require mucking about in all that windows stuff I'd think about it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:55:58", "author": "amalloy", "message": "$google microsoft word apple osx" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:55:58", "author": "sexpbot", "message": "First out of 2600000 results is: Microsoft Office for Mac Downloads and Updates | Office For Mac" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:55:58", "author": "sexpbot", "message": "http://www.microsoft.com/mac/downloads" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:56:16", "author": "gfrlog", "message": "amalloy: half as gross" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:56:28", "author": "amalloy", "message": "*chuckle* sometimes you have to get your hands dirty for a laugh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:57:06", "author": "gfrlog", "message": "now with manual syntax-coloring!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:58:29", "author": "amalloy", "message": "heh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:59:11", "author": "amalloy", "message": "Clippy: It looks like you're trying to: call a function! Would you like me to insert the closing \")\" for you? Y/N" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T16:59:31", "author": "gfrlog", "message": "oh I know which letter I'm clicking" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:00:48", "author": "gfrlog", "message": "it's never been easier to export your .clj files to outlook!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:03:07", "author": "gfrlog", "message": "I wish I knew how to get jvisualvm to tell me the total executation time for the functions..." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:25:06", "author": "gfrlog", "message": "if (binding [*warn-on-reflection* true] ...) does not output any warnings, does that mean that there's no benefit to adding type hints to the code?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:49:04", "author": "__name__", "message": ".w abdicate" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:49:12", "author": "__name__", "message": "]dict abdicate" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:49:36", "author": "__name__", "message": "Gosh darned." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:49:45", "author": "__name__", "message": "Tabs are evil." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:00", "author": "__name__", "message": "How did I end up in this tab anyway?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:05", "author": "gfrlog", "message": "you mean that wasn't some strange invocation of sexpbot?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:05", "author": "__name__", "message": "I blame … GTK." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:21", "author": "__name__", "message": "No it was not." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:48", "author": "__name__", "message": "It was me being an idiot." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:50:55", "author": "gfrlog", "message": "it looks like vim?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:01", "author": "amalloy", "message": "$dict abdicate" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:01", "author": "sexpbot", "message": "amalloy: verb-transitive: To relinquish (power or responsibility) formally." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:04", "author": "__name__", "message": "That would be :" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:05", "author": "amalloy", "message": "(for what it's worth)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:21", "author": "gfrlog", "message": ":)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:24", "author": "__name__", "message": "I blame the time of day." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:27", "author": "amalloy", "message": "gfrlog: i don't expect the (binding) to have any effect at all" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:27", "author": "__name__", "message": "It's 1.51 AM." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:45", "author": "amalloy", "message": "you have to (set! *warn-on-reflection* true) before you compile the code" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:51:48", "author": "gfrlog", "message": "amalloy: this sounds like useful information" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:00", "author": "amalloy", "message": "because it's a flag that's checked at compile time" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:04", "author": "gfrlog", "message": "okay. So if I'm using lein, when does the code get compiled?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:15", "author": "amalloy", "message": "uhhh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:17", "author": "gfrlog", "message": "I guess \"lein compile\" would have to do it at some point" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:28", "author": "gfrlog", "message": "so then where should the (set! ...) go?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:33", "author": "gfrlog", "message": "in my user.clj? :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:52:50", "author": "amalloy", "message": "gfrlog: i usually set! it in the repl before require'ing my code" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:53:03", "author": "gfrlog", "message": "that sounds worth a try. I'ma do it." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:54:16", "author": "gfrlog", "message": "I think it worked." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:54:45", "author": "amalloy", "message": "gfrlog: $ cake check" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:54:48", "author": "gfrlog", "message": "okay, so back to the original question -- does a type hint only help in a situation that produces a reflection warning?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:54:52", "author": "amalloy", "message": "yes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:55:14", "author": "gfrlog", "message": "this is weird because I get almost none" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:55:25", "author": "gfrlog", "message": "the only warning is when I call (.join ...) on a thread" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:55:40", "author": "amalloy", "message": "okay...so don't add type hints?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:55:50", "author": "gfrlog", "message": "I guess so. :/" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:56:00", "author": "amalloy", "message": "you only need them if you're doing direct interop with (.foo) or really-really want to work with primitive numbers" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:56:06", "author": "gfrlog", "message": "I have some integer + :infinity arithmetic that I feel like is probably slower than it could be" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T17:56:23", "author": "amalloy", "message": "(and getting it right for primitives is a lot harder than you think)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T18:03:09", "author": "amalloy", "message": "gfrlog: but type-hinting can definitely help by getting you to work with primitives, even in the absence of reflection warnings" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T18:03:20", "author": "gfrlog", "message": "hmm :/" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T18:03:29", "author": "amalloy", "message": "it's just hard to do right" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T18:04:19", "author": "gfrlog", "message": "or I could use an array instead of a hash...." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T18:49:53", "author": "amalloy", "message": "gfrlog: i don't think i want to live in a universe where that suggestion makes sense" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:54:29", "author": "pcavs", "message": "Where's a good place to look (outside of the source) to see how Clojure implements its parallelism? I am under the impression that it is done automatically by the runtime + compiler, but maybe I am incorrect." }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:54:53", "author": "hiredman", "message": "you are" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:55:31", "author": "pcavs", "message": "incorrect?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:55:47", "author": "pcavs", "message": "Any places to look/read?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:55:51", "author": "hiredman", "message": "yes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T19:56:27", "author": "pcavs", "message": "http://clojure.org/concurrent_programming is the concurrency screencast good?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:08:49", "author": "pcavs", "message": "Is it possible to convert a string to a keyword?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:14:55", "author": "pcavs", "message": "sorry, stupid question" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:15:05", "author": "pcavs", "message": ",(keyword \"My answer is thus\")" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:15:05", "author": "clojurebot", "message": ":My answer is thus" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:16:27", "author": "amalloy", "message": "augh who put mixed tabs&spaces in clojure.xml?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:25:51", "author": "hiredman", "message": "must be clojure/core" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:34:03", "author": "technomancy", "message": "oops" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:34:04", "author": "technomancy", "message": "~guards" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:34:05", "author": "clojurebot", "message": "SEIZE HIM!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:36:54", "author": "seancorfield", "message": "quick Q... if i have a vector, is there a built in function to find the index of a given value?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:37:17", "author": "seancorfield", "message": "and what's the bot command to find functions based on arguments" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:37:19", "author": "hiredman", "message": ",(.indexOf [1 2 3] 1)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:37:19", "author": "clojurebot", "message": "0" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:37:42", "author": "seancorfield", "message": "oh.... a java method... that explains why i couldn't find it :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:38:42", "author": "seancorfield", "message": "i'm a bit surprised there isn't a clojure fn for that (but thank you hiredman )" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:40:10", "author": "seancorfield", "message": "what about finding the key in a map for which the value matches? (just curious now)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:08", "author": "hiredman", "message": "nope" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:25", "author": "seancorfield", "message": "ok, just checking" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:37", "author": "seancorfield", "message": "(again, just a bit surprised)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:39", "author": "technomancy", "message": "(zipmap (vals m) (keys m))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:55", "author": "hiredman", "message": ",(first (some (comp #{:a} second) {:z :a}))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:55", "author": "clojurebot", "message": "java.lang.IllegalArgumentException: Don't know how to create ISeq from: clojure.lang.Keyword" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:41:59", "author": "technomancy", "message": "rich doesn't like to expose things unless they're performant; see contains?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:42:01", "author": "hiredman", "message": "bleh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:42:13", "author": "seancorfield", "message": "(somefn map value) was what i was looking for" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:42:49", "author": "seancorfield", "message": "(first (vals (filter (fn [[k v]] (= v stuff)) map))) was what i came up with (for stuff in map)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:42:58", "author": "hiredman", "message": "technomancy: well, that is not a very performant solution" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:43:06", "author": "hiredman", "message": "creating a reverse map" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:43:21", "author": "hiredman", "message": "seancorfield: right" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:57:19", "author": "semperos", "message": "say I have an arbitrary map m which is {:a \"y\" :b \"z\"}, and I need to create (and (= \"y\" (:a m)) (= \"z\" (:b m))) to verify the values of the map" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:57:28", "author": "semperos", "message": "how would I go about generating that and expression?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:58:12", "author": "seancorfield", "message": "do you want to test the whole map or just some key/value pairs?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:58:20", "author": "semperos", "message": "whole map" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:59:19", "author": "seancorfield", "message": "so you can just test the whole map" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T20:59:39", "author": "seancorfield", "message": "(= {:a \"y\" :b \"z\"} other-map)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:00:12", "author": "semperos", "message": "I'm actually using it as part of a clojureql `select` function, which is generating a SQL query behind the scenes from this and expression" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:00:22", "author": "semperos", "message": "I've been able to generate the and expression using templating" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:00:55", "author": "semperos", "message": "https://gist.github.com/1064187" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:01:06", "author": "semperos", "message": "but I'm not sure what to do with it, and was hoping there was some other way" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:13:27", "author": "pcavs", "message": "Hey, I'm trying to represent a 2D game-map. I was thinking of going with a vector of vectors, does that sound like a good idea? If so, what's the best way to define such a thing? The game-map is generated, so there's a variable number of rows and cols" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:28:45", "author": "amalloy", "message": "$findfn [1 2 3] 1 0" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:28:46", "author": "sexpbot", "message": "[]" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:29:00", "author": "amalloy", "message": "seancorfield: ^ would get your answer if it were a plain function" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:29:43", "author": "seancorfield", "message": "thanx amalloy" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:30:07", "author": "amalloy", "message": "semperos: there's no way that gist makes any sense. you're not unquoting inside the for" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:30:23", "author": "seancorfield", "message": "$findfn [1 2 3] 2 2" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:30:24", "author": "sexpbot", "message": "[clojure.core/max-key clojure.core/cond clojure.core/dosync clojure.core/sync clojure.core/char-escape-string clojure.core/with-loading-context clojure.core/*clojure-version* clojure.core/case clojure.core/min-key clojure.core/and clojure.core/locking clojure.core/c... http://gist.github.com/1064215" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:30:26", "author": "seancorfield", "message": ":)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:30:44", "author": "seancorfield", "message": "*clojure-version*... interesting match :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:31:05", "author": "amalloy", "message": "seancorfield: ##({:k :v} :whatever 2)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:31:05", "author": "sexpbot", "message": "⟹ 2" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:31:11", "author": "amalloy", "message": "but yes, clearly silly" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:33:31", "author": "amalloy", "message": "semperos: clojure.core/and is, guaranteed, not the thing you want to be using here. i'd guess you want every?, but your gist doesn't really make it clear what your intent is if you don't like seancorfield's solution, so i can't solve it \"for\" you" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:33:49", "author": "semperos", "message": "amalloy: yeah, I realized it didn't make much sense" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:33:55", "author": "semperos", "message": "shouldn't tinker while watching movies with family :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:34:08", "author": "semperos", "message": "not looking for anyone to solve it for me" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:34:17", "author": "semperos", "message": "using clojureql.core/select to do a query of a database" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:34:35", "author": "semperos", "message": "I want to be able to have a map/record with certain keys that match column names in a database table" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:35:10", "author": "semperos", "message": "and write a function where I pass in this map/record and use all of the entries to fill out the \"where\" clause of the select function" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:35:45", "author": "semperos", "message": "basic use looks like (clojureql.core/select (table :foo) (where (= :id (:id my-map))))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:36:33", "author": "amalloy", "message": "blugh. iirc clojureql has a lot of macro stuff, which makes this not easy" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:45:51", "author": "semperos", "message": "turns our clojureql's `where` macro for which I was trying to do this just puts together a WHERE clause as a string" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:46:13", "author": "semperos", "message": "since I already wrote code to mangle that with some functions for clojure.contrib.sql with strings, this is a non-issue" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:56:44", "author": "seancorfield", "message": "it's pretty easy to do that with clojure.java.jdbc already" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:57:39", "author": "seancorfield", "message": "https://gist.github.com/1064231" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:57:56", "author": "seancorfield", "message": "q and qi and naming strategies" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:58:22", "author": "seancorfield", "message": "updated gist with those" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:58:43", "author": "semperos", "message": "seancorfield: thanks for sharing" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:10", "author": "semperos", "message": "still using 1.2 myself, but that all makes sense" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:10", "author": "seancorfield", "message": "that's from our production code (hence ws/worldsingles-db-readonly)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:17", "author": "semperos", "message": "yeah" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:40", "author": "seancorfield", "message": "naming strategies are new in c.j.j (compared to c.c.sql) but the rest should work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:48", "author": "semperos", "message": "yep" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T21:59:58", "author": "seancorfield", "message": "you know you can depend on c.j.j 0.0.3 even tho' you're on clojure 1.2?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:00:09", "author": "seancorfield", "message": "the new clojure contrib libs work with 1.2" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:00:53", "author": "amalloy", "message": "seancorfield: i know some of them do, but i'm a little surprised to hear that all of them do" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:01:11", "author": "seancorfield", "message": "it's a requirement: new contrib must support clojure 1.2" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:01:17", "author": "amalloy", "message": "cool" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:01:19", "author": "semperos", "message": "yeah, I had read that some featured compatibility with both, forgotten frankly" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:01:34", "author": "seancorfield", "message": "i didn't know until i fell foul of it with c.j.j and accidentally made it 1.3 only :(" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:01:45", "author": "seancorfield", "message": "that nice mr bedra corrected me :)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:02:08", "author": "glitch83", "message": "Hey everyone - I've got a quick test I've been trying to perform with clojure - I want to save a lambda for use later" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:02:30", "author": "glitch83", "message": "I used the readObject / writeObject on the lambda to save it out but when I load it back in - it gives me a NO_SOURCE exception" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:02:38", "author": "sean_corfield", "message": "time to move to the TV room and kick back" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:02:46", "author": "glitch83", "message": "any thoughts?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:03:13", "author": "semperos", "message": "sean_corfield: enjoy, thanks for your feedback" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:03:39", "author": "technomancy", "message": "glitch83: lambdas aren't serializable by default" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:03:43", "author": "technomancy", "message": "you can cheat with this:" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:03:46", "author": "technomancy", "message": "clojurebot: serializable-fn" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:03:46", "author": "clojurebot", "message": "serializable-fn is a hack for preserving source of a compiled function: https://github.com/technomancy/serializable-fn" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:04:06", "author": "technomancy", "message": "that's somewhat half-baked though" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:04:27", "author": "glitch83", "message": "hm yeah I have thought about the limitations - it's not an easy problem but let me give this a shot" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:06:36", "author": "glitch83", "message": "This looks sufficient enough for some basics - now I'm thinking how to dynamically load clj files - I assume (load-file <filename>) ?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:07:04", "author": "technomancy", "message": "glitch83: yup" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:07:20", "author": "technomancy", "message": "you shouldn't use that for your project's source, but for arbitrary files on disk it's fine" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:07:23", "author": "glitch83", "message": "sweet - I think this is enough :-) thanks all!" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:09:06", "author": "schnorrer", "message": "hi, has anyone had troubles with \"lein ring server\" and Unicode on web pages (lots of \"????????\")?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:09:38", "author": "schnorrer", "message": "a war generated with \"lein ring war\" works fine if deployed on a 'standalone' jetty" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:11:11", "author": "schnorrer", "message": "looks like it has something to do with misconfiguration of the embedded jetty, but I have no idea how to fix it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:12:04", "author": "tomoj", "message": "the charset is UTF-8 in both cases?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:12:23", "author": "tomoj", "message": "but one has garbage that's not actually utf-8?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:12:49", "author": "schnorrer", "message": "well, the data pulled from DB are definitely utf-8" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:13:00", "author": "tomoj", "message": "I mean in the http response" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:13:06", "author": "schnorrer", "message": "ah, yes" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:13:24", "author": "tomoj", "message": "no clue then :(" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:13:40", "author": "schnorrer", "message": "sighs" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:13:55", "author": "tomoj", "message": "I don't think I've ever had any of that NOT use utf-8 without me asking" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:15:09", "author": "hiredman", "message": "MacRoman is innocent" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:15:28", "author": "technomancy", "message": "you're getting him confused with Bill Stickers" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:15:53", "author": "technomancy", "message": "http://www.snapbuzz.com/images/resized/Bill_Stickers_is_innocent6956.jpg" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:21:49", "author": "schnorrer", "message": "tomoj: oh, my bad :( 'ring server' indeed returns ISO-8859-1 charset" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:22:24", "author": "schnorrer", "message": "how can I explicitly set the charset anyway?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:23:20", "author": "amalloy", "message": "schnorrer: add a Content-Encoding header?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:23:45", "author": "amalloy", "message": "though i'd guess utf8 is the default anyway" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:25:56", "author": "tomoj", "message": "I think you want to add '; charset=utf-8' to the end of your content-type header" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:26:00", "author": "schnorrer", "message": "amalloy: somehow it's not" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:29:43", "author": "schnorrer", "message": "nope, seems not working: I'm still getting  a page with <meta content=\"text/html; charset=UTF-8\" http-equiv=\"Content-Type\" /> but with ISO-8859-1 in the header" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:30:17", "author": "tomoj", "message": "are you rendering out that meta tag?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:30:41", "author": "tomoj", "message": "or actually setting the content-type header in your ring response, which somehow comes out as a meta tag instead of a header..?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:30:56", "author": "schnorrer", "message": "wait" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:31:17", "author": "schnorrer", "message": "I'm rendering it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:31:29", "author": "schnorrer", "message": "with hiccup's [:meta {:http-equiv \"Content-Type\" :content \"text/html; charset=UTF-8\"}]" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:31:50", "author": "schnorrer", "message": "unsurprisingly, it doesn't work" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:32:58", "author": "amalloy", "message": "ew. don't add http-equiv tags if you control the http transport" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:34:57", "author": "tomoj", "message": "schnorrer: do you just return a string now?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:35:15", "author": "tomoj", "message": "like, maybe you just the output from hiccup directly to ring?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:35:22", "author": "tomoj", "message": "s/just the/just return the/" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:36:39", "author": "schnorrer", "message": "tomoj: I return hiccup output to ring" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:37:03", "author": "tomoj", "message": "see hello world in ring readme" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:37:04", "author": "schnorrer", "message": "not directly though (via compojure routes)" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:37:20", "author": "tomoj", "message": "for example of map to return with explicit http headers" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:38:27", "author": "schnorrer", "message": "tomoj: uh-huh, got it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:39:07", "author": "tomoj", "message": "hmm.. is being able to return a string something compojure adds or is it in ring?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:39:20", "author": "tomoj", "message": "if in ring, is it a middleware that converts strings to response maps, I wonder..?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:42:29", "author": "amalloy", "message": "tomoj: i think it's probably compojure" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:43:58", "author": "amalloy", "message": "looks like it's in compojure.reponse$Renderable, at first glance" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:44:19", "author": "tomoj", "message": "what is that $" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:44:31", "author": "tomoj", "message": "oh found it" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:44:42", "author": "tomoj", "message": "good" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:44:43", "author": "amalloy", "message": "well, i meant to imply an inner class, but i think that was a wrong implication" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:45:14", "author": "tomoj", "message": "kinda bothered me that that would be added to all ring handlers by default when it should be a middleware" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:45:34", "author": "amalloy", "message": "yes. given ring's minimalistic approach it would be very surprising if it included that" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:45:58", "author": "schnorrer", "message": "speaking of compojure, the most straightforward way to set the response header I see is to wrap the (defroutes) handler in a middleware, right?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:46:36", "author": "amalloy", "message": "schnorrer: yeah, just squeeze a middleware in there somewhere" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:46:57", "author": "tomoj", "message": "see ring.middleware.content-type/wrap-content-type" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:47:07", "author": "tomoj", "message": "eh" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:47:08", "author": "amalloy", "message": "you can't wrap the (defroutes) form, but you can wrap the var it produces, or (def my-rountes (wrap-content-type ... (routes ...)))" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:47:40", "author": "tomoj", "message": "wrap-content-type doesn't add the charset bit, though, does it?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:48:29", "author": "amalloy", "message": "no, you can't use the one from ring for that. it's only intended for serving static files" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:48:48", "author": "tomoj", "message": "oh you need the extension" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:49:08", "author": "amalloy", "message": "yeah" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:49:49", "author": "tomoj", "message": "what would it do, just add charset to specific detected content types?" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:50:11", "author": "tomoj", "message": "like some other middleware sets text/html, then something notices it and adds utf-8? or you just special case wrap text/html+utf-8" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:51:12", "author": "amalloy", "message": "too many pronouns. none of those \"it\"s are clearly bound" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:51:39", "author": "tomoj", "message": "first it is a hypothetical middleware to add utf-8 charset" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:51:58", "author": "amalloy", "message": "k" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:51:58", "author": "tomoj", "message": "second it is text/html in :headers->\"Content-Type\"" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:52:30", "author": "amalloy", "message": "i'd probably special-case-wrap" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:52:50", "author": "amalloy", "message": "but that may not be a good solution *shrug*" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:58:45", "author": "schnorrer", "message": "I'm trying to figure out if it's possible to set embedded's jetty defaults, but the middleware workaround is fine too" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T22:58:48", "author": "schnorrer", "message": "thank you guys" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T23:07:49", "author": "amalloy", "message": "schnorrer: probably a good idea to use the middleware anyway rather than trying to configure jetty" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T23:08:03", "author": "amalloy", "message": "you might want to deploy on tomcat sometime, for example" }
{ "index" : { "_index" : "irc.freenode.clojure", "_type" : "message" } }
{ "datestamp": "2011-07-04T23:14:19", "author": "schnorrer", "message": "amalloy: most likely, but in this case I'd rather choose the less invasive way" }