#clojure – 2008-07-15

2008-07-15

06:41	meredydd	Hmm...so, what happens when you invoke a (ref)?
08:14	mac__	meredydd: I guess the value of the ref gets treated as a function? So if you have something else than a function in it (like an integer) it will throw an exception. Not sure I understod the question
08:14	mac__	((ref 1)) -> error
08:14	mac__	((ref (fn [] "Hello World"))) -> works
08:15	rhickey	mac__: what question?
08:16	mac__	meredydd: Hmm...so, what happens when you invoke a (ref)?
08:17	mac__	asked almost 2 hours ago though, might not be here anymore?
08:17	rhickey	ah, I see it now at http://clojure-log.n01se.net/date/2008-07-15.html
08:18	rhickey	That behavior of refs is undocumented and subject to change
08:18	mac__	k
08:18	mac__	I just replied with what I observed :) good to know it could change
08:19	mac__	By the way, I'm a newbie lisp and functional programmer and I have a question of my own. I have a nasty loop from a java example I want to convert to clojure and I can't get my head around it...
08:19	rhickey	there was a time (prior to release) when vars and refs were the same thing, i.e. vars were transactional and you could dynamically rebind refs, but I found it to be too confusing
08:20	rhickey	mac__: shoot
08:20	rhickey	or maybe paste
08:20	mac__	ok, let me just paste the java code somewhere it
08:20	mac__	it's a nested loop
08:22	lisppaste8	mac__ pasted "nested loop" at http://paste.lisp.org/display/63725
08:24	mac__	tell me if you need more info there is some surrounding code too but that's the loop I'm having trouble with
08:25	mac__	util.join returns a java array with 1 or 2 shapes depending on if they could be joined or not
08:25	rhickey	mac__: nested fors map readily to Clojure's for...
08:25	mac__	sorry util.union I mean
08:25	rhickey	setting aside the fact that the body does its work by side effect...
08:26	rhickey	(for [i (range (.size shapes)) j (range 1 (.size shapes))] ...)
08:28	rhickey	one of the basic problems with imperative loops like that is that the logic is all gnarled up, difficult to read and understand...
08:28	rhickey	so splitting it up into steps is important...
08:28	rhickey	first step is making a list of items to keep/drop...
08:29	mac__	yeah tell me about it.. I spent a long time just looking at that before getting it. I've tried a few things but that innermost return haunts me
08:29	rhickey	then build a result set, which in Clojure you would do functionally, maybe with reduce, rather than mutating a collection in place
08:30	rhickey	or you could just reduce from the start...
08:31	mac__	yeah I've been trying some variants with reduce but never got it right, I just couldnt come up with something that combines every item with every other item in turn
08:31	mac__	I might just need more coffee :) right now I'm stuck
08:32	rhickey	the outer structure would look like:
08:32	rhickey	(reduce (fn [ret [i j]] ...) [] (map vector (range (.size shapes)) (range 1 (.size shapes))))
08:34	rhickey	oops, no, I see you need every combination, so for is better
08:35	mac__	ok, I've never used for, taking baby steps here :)
08:36	rhickey	try this to get a feel for it:
08:36	rhickey	(for [i (range 5) j (range 1 5)] [i j])
08:40	mac__	yeah that's nice, just the nested loop effect I need, but I'm a bit hung up on the return in the innermost loop still, how do I stop it if I find a shape union?
08:41	rhickey	if you do it in steps, you'll use the for just to return a sequence of those things you need to remove, then, after the for, you'll build a result
08:45	mac__	alright you've given me some ideas, I'm gonna try some stuff, will be back later. Thanks
08:59	cemerick	I saw the git mirror post on google groups -- FWIW, I'm very glad Rich is using svn at this point.
09:00	cemerick	We're idly watching mercurial bubble along, but really only because it's the only dvcs that has passable tooling in an environment we use (Netbeans).
09:05	rhickey	cemerick: exactly, I need something that works in IntelliJ
09:08	Chouser	huh, that's interesting. Well, it seems to be svn is a dead-end, but I guess it'll take a while for the tools to ramp up for its replacement.
09:08	Chouser	I'm entirely content using git locally talking to the svn server.
09:10	Chouser	s/seems to be/seems to me/
09:10	rhickey	meredydd: hey
09:10	meredydd	rhickey: See the {bug/extremely obscure, undocumented and dangerous feature} report on the list this morning?
09:10	rhickey	meredydd: fixed already
09:10	meredydd	sweet, thanks
09:11	rhickey	but the 'feature' is still undocumented, might go away in the future
09:11	meredydd	yeah...that part makes me nervous
09:11	meredydd	I only discovered it because I accidentally forgot to type a couple of @s in crucial places
09:12	cemerick	I'm incapable of using a vcs without a solid UI front end these days. A good sync/changes UI is a godsend compared to command-line diffing.
09:12	meredydd	and, as long as it doesn't throw an error, the unit tests don't catch anything
09:12	meredydd	so if that's not something to be relied upon, any chance you could explicitly break it?
09:13	meredydd	(or provide some sort of switch? Seems OTT.)
09:13	rhickey	meredydd: I haven't thought about it in a while, but if I do keep it I'll add the same capability to agents
09:14	meredydd	ooh, that'd be nice too.
09:14	rhickey	so the next step will either be to do that or remove it, but not break/flag it
09:14	meredydd	Okay, that's absolutely fine.
09:14	meredydd	(and when I said "break", I meant "remove")
09:15	rhickey	I'll be in the refs/agents soon as I intend to add consistency functions
09:15	rhickey	ptional validation fns to be run on change of state
09:15	cemerick	I know I've seen a function that, given a coll, returns pairs containing one item from coll and an index....can't find it now...
09:15	rhickey	optional
09:15	meredydd	Nice, rhickey...presumably just before a transaction commits?
09:16	rhickey	meredydd: right
09:16	meredydd	That would be awesome, yes.
09:16	rhickey	So transactions will be ACI_
09:16	rhickey	agents too
09:17	meredydd	Well, I saw a post this morning on the list about a web framework, which mentioned a transaction macro which adds the "D" too...
09:17	rhickey	meredydd: without cooperation from the transaction infrastructure, I don't see how
09:18	meredydd	rhickey: That puzzled me, as well. I had assumed there were some undocumented hooks he was using.
09:18	rhickey	cemerick: I don't know of one in boot.clj, but is the collection a vector?
09:19	meredydd	But if you're implementing generic pre-commit triggers which can abort a transaction, I'd imagine you can make a particular ref or agent 'D' very straightforwardly.
09:20	rhickey	meredydd: to be determined
09:20	rhickey	the focus is on validation
09:22	meredydd	Finally, have you considered adding some equivalent to my 'alter-map-val' to boot.clj?
09:22	meredydd	Reading and then re-(assoc)-ing map and vector values when altering refs is a PITA
09:23	rhickey	meredydd: heh, I've been waiting for people to start complaining about that...
09:23	meredydd	I've ended up doing:
09:24	rhickey	the general issue is nested 'change', I foresee a macro like -> but that flows back, maybe <- ?
09:24	meredydd	(alter my-map-ref alter-map-val :key #(do...something))
09:24	meredydd	(it's a poorly-named fn, it doesn't alter a ref)
09:25	meredydd	Like (alter), I use (apply) to chain through the other arguments
09:25	meredydd	so you can do something like:
09:25	rhickey	best to keep the altering separate, the need is a general one for functional nested map change
09:25	meredydd	(commute exam_marks alter-map-val "A-levels" alter-map-val "Meredydd Luff" + 5)
09:26	meredydd	It doesn't do an alter - it just returns its second arg, applying the given fn and args to the value at the given key
09:27	rhickey	meredydd: just thinking out loud
09:27	meredydd	(fn [map-val key alter-fn & args]
09:27	meredydd	(assoc map-val key (apply alter-fn (get map-val key) args))))
09:27	meredydd	Anyway, that's my version.
09:28	meredydd	(works for vectors too, of course - anyting (assoc)able)
09:29	rhickey	interesting, if a bit verbose
09:30	meredydd	And this is what I love about this language - it's created by a man who thinks that requiring one arg each for map and key is too verbose :)
09:30	meredydd	I'm sure you can do better - just wanted to plant an idea in your head (where it appears it had long since taken root)
09:31	rhickey	meredydd: thinking more about the name alter-map-val than the fn/key pair idea, which is good
09:32	Chouser	alter-map-val is more tied to 'assoc' then 'alter'
09:32	Chouser	meredydd: I guess you already mentioned that.
09:35	meredydd	although (<-) had damn well better be a fn rather than a macro
09:35	rhickey	meredydd: hmmm...
09:35	meredydd	else you won't be able to pass it to itself
09:35	rhickey	?
09:35	meredydd	(or, more likely, pass it inside something else that's expecting a function)
09:35	meredydd	rhickey: Imagine my original "alter" comment
09:35	rhickey	It's symmetrical with ->
09:36	meredydd	rhickey: Uhh...is it?
09:36	meredydd	What are you expecting that to expand to?
09:36	rhickey	left as exercise for the reader for now :)
09:37	cemerick	rhickey: not necessarily -- just seq-able. I could have sworn I saw such a function. Anyways, here's what I was thinking of:
09:37	cemerick	(defn enumerate [coll]
09:37	cemerick	(map #(vector %1 %2) coll (iterate inc 0)))
09:37	rhickey	just my intuition, I haven't written it, but it would be a macro
09:37	meredydd	my point is that it's not going to be as simple as the (->) macro
09:38	meredydd	because you have to use each argument twice: once to (get) the data, once to (assoc) it back onto the original collection
09:38	meredydd	so it's not going to be simply symmetrical to (->)
09:38	rhickey	meredydd: still, the associative things are consistent, so doable
09:38	meredydd	Oh, very much doable.
09:39	rhickey	meredydd: the symmetry is in the idea, walk the chain of associations, but in this case fold the last expression back into the structure
09:39	meredydd	I'm just making a case that it won't be so similar to (->), in advance of asking you to make (<-) a fn instead
09:39	meredydd	my reason being that you can then use (alter) on it
09:40	rhickey	what if the last call needs more args?
09:41	meredydd	Oh, arse. I see your point.
09:41	meredydd	(alter exam_marks <- exam_marks "A-levels" "Meredydd Luff" (+ 5)) won't fly, because the + gets evaluated too early.
09:41	meredydd	But equally, it gets cumbersome if you have to make the fn explicit, because you use up your #():
09:42	meredydd	(alter exam_marks #(<- "A-levels" "Meredydd Luff" #(...do something...)))
09:42	rhickey	if <- ends up being a macro, a <-@ macro is no big deal
09:42	cemerick	ah-ha -- my enumerate is seq-utils/indexed in clojure-contrib :-P
09:42	meredydd	(What would "<-@" be?)
09:42	meredydd	(auto-wrap with a (fn)?)
09:43	rhickey	(<-commute exam_marks "A-levels" "Meredydd Luff" (+ 5)) ?
09:44	rhickey	(<-alter exam_marks "A-levels" "Meredydd Luff" 42)
09:44	meredydd	Hmm...something in me regards it as icky to special-case both <-commute and <-alter
09:45	rhickey	oops, meant <-set
09:45	meredydd	and <-set, of course
09:45	rhickey	well, then you'll have to repeat exam-marls
09:45	rhickey	makrs
09:45	rhickey	marks
09:46	meredydd	not necessarily...you could do something like (warning, ugly alert):
09:46	meredydd	(some-macro-name alter exam_marks "A-levels" "Meredydd Luff" (+ 5))
09:47	rhickey	sure
09:47	meredydd	and that would work when substituting "set!" for "alter" and a value for (+ 5)
09:47	rhickey	gotta run
09:47	meredydd	ok
09:47	meredydd	cya
14:53	mac__	rhickey_: solved that problem I had before with the nested loop. It was part of a bigger mess so it took me a while but the for expression helped. Ended up doing something like (for [a (range 5) b (range (+ a 1) 5)] ...) so that each combination occurrs only once. Thanks for the pointer :)
14:54	rhickey_	mac__: great!
14:55	mac__	and thanks for clojure by the way, I started trying to learn common lisp but clojure hits a much sweeter spot being more functional and concurrent
14:55	rhickey_	you're welcome
15:48	cemerick	rhickey_: we had a brief data-modeling discussion some weeks back, where I was fiddling with various ideas to make a class as transparently usable from java and from clojure as possible, while keeping implementation in clojure as much as possible. Just on the face of it, what would you think of a defstruct variation that used gen-class to generate PersistentStructMap subclasses that had accessor methods for each of the privileged keys?
16:25	rhickey_	cemerick: would the keys be mutable?
16:25	cemerick	rhickey_: No.
16:27	rhickey_	cemerick: it might be interesting
16:27	cemerick	Yeah. I might give it a run next week. I'm under deadline for Friday, so all I've been able to do is think a bunch.
16:28	cemerick	I need to learn a little more about how the javabean mechanisms work, because I want the resulting classes to be bean-compatible (read-only)
16:29	cemerick	(ideally without blinding conforming to the getFoo convention :-/ )
16:29	rhickey_	cemerick: very easy to get if you follow the naming conventions
16:29	rhickey_	heh
16:29	cemerick	I hate getFoo.
16:30	cemerick	No-arg foo should have always been the accessor, n-arg foo the setter.
16:30	rhickey_	well, if the fields are immutable you can make them public and just define the methods for JavaBeans' sake
16:31	cemerick	Yeah, that's the fallback.
16:32	rhickey_	with BeanInfo you can do whatever mapping you want
16:32	cemerick	I think I can hang a beaninfo impl off of the gen-class class that will link things up to the simpler getters
16:32	cemerick	well, there you go :-)
17:24	meredydd	hey
17:25	meredydd	Is there a canonical way to load a file from a resource, like generated classes do?
17:29	meredydd	aha, never mind. Found it in -contrib.