G'day.
I have problem that I have been thrashing back and forth over the best
design of for a week now, and I can't work out the nicest way to
handle it. Specifically, I have a collection of functions that return
a primary result, and might also return a secondary "annotation" about
that result.
The current implementation is:
(fn [] true) ; primary only
(fn [] (annotated-return true {:foo 12})) ; with annotation
`annotated-return` actually wraps a record, and then the handling code
can determine if the result is specifically that type, or if it is
anything else, to select between the two cases.
In a bunch of other languages I would use a `pair` or `tuple`, but
Clojure doesn't have a native type that maps closely to that. Worse,
though, it doesn't have a native type that isn't a valid return from
one of these methods. (Set, Vector, List, and Map are all used. :)
The alternatively I can think of are limited: I don't like the idea of
guessing based on a two element vector return or so, since I want this
to be pretty much impossible to accidentally break.
I considered using meta-data, but that can't attach to a primitive
value, and those are definitely valid results.
So, is there a better way to do this? At this point I am tempted to
step aside from functional code, and use stateful mutation of some
sort to maintain the annotations:
(fn [] (annotate-by-side-effort {:foo 12}) true)
Daniel
--
♲ Made with 100 percent post-consumer electrons
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
