One answer to my question would be to force Clojure to throw an exception
if querying a non-existant property on the data-structure...is that
possible? For example, in the following snippet, (t {:c 10}) would fail.
I assume a macro-or-something?
Clojure (defn t [a] (print (str (:b a
One answer to my question would be to force Clojure to throw an exception if
querying a non-existant property on the data-structure...is that possible?
For example, in the following snippet, (t {:c 10}) would fail. I assume a
macro-or-something?
Clojure (defn t [a] (print (str (:b a
Hi,
Baishampayan beat me to it. But to elaborate more:
You have to expose each contract up the function chain. Say it looks like
this:
(defn calculate-insurance
[ items]
{:pre [(every? #(contains? % :cost-replace-with-new) items)]}
...)
Then funcE and funcD have to check
Thanks both - DBC is one answer - yes. Very nice - I hadn't realised this
was there.
So this is the issue - funcD and funcE shouldn't know about the contract
because they have no requirement for :cost-replace-with-new - they are
simply wrappers for logging and performance monitoring for
As I understand the problem in your example, you do have a definition
for what an Insurable is, but it's implicit: there's no way to check
whether an object is insurable and thus no way to check which parts of
the code break when the notion of being Insurable changes. Luckily
Clojure provides us
This is very helpful. I think my false assumption was that structural
contracts weren't enforced, even with protocols. Your example is very
helpful.
On 30 January 2012 11:43, Timo Mihaljov t...@mihaljov.info wrote:
As I understand the problem in your example, you do have a definition
for
Hi, I want to change state of two refs, exchanging between them. Currently
this is what I do:
(dosync
(let [a (first @v)
b (second @v)]
(alter a assoc :color (:color @b))
(alter b assoc :color (:color @a
I wonder if there's a better approach,
Actually this is wrong, I bind the value of the :color of a first, before I
alter b
--
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
Hi,
a simple let does the trick, no?
(dosync
(let [av @a
bv @b]
(alter a assoc :color (:color bv))
(alter b assoc :color (:color av
Sincerely
Meikel
--
You received this message because you are subscribed to the Google
Groups Clojure group.
To post to this group, send
Yes, that's what I've been doing
What I want to know is if there's a single function that does this exchange
between refs.
--
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
Hi,
(defn exchange!
[a b {:keys [getter setter] {getter identity setter (fn [_ v] v)}}]
(let [av @a bv @b]
(alter a setter (getter bv))
(alter b setter (getter av
(defn exchange-color!
[a b]
(exchange! a b :getter :color :setter #(assoc %1 :color %2)))
(exchange-color! a b)
yes, that works!
thanks
--
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
Hi again,
or more like this:
(defn exchange!
[a b {:keys [f] {f (fn [_ v] v)}}]
(let [av @a bv @b]
(alter a f bv)
(alter b f av)))
(defn exchange-color!
[a b]
(exchange! a b :f #(assoc %1 :color (:color %2
(exchange-color! a b)
Sincerely
Meikel
--
You received this
Here's a bit more of playing around at the repl.
clojure.core= a b
#Atom@7b603522: {:color :blu}
#Atom@69408a75: {:color :red}
clojure.core= (for [[x y] [[a @b] [b @a]]] (swap! x assoc :color (:color y)))
({:color :red} {:color :blu})
clojure.core= a b
#Atom@7b603522: {:color :red}
On Sat, 2012-01-28 at 10:04 -0500, daly wrote:
On Sat, 2012-01-28 at 06:51 -0800, Folcon wrote:
Hi Tim,
Personally if you have done or would be interested in doing a quick
vid cast of how you progress through your workflow, I think that would
be very interesting.
Sort of extreme
Nice! I liked the use of *merge* , it seems even more semantic!
--
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
It works now, thank you, Jonas.
--
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
I'm dynamically generating images for a website and I'm hosting the content
using ring. Currently I use moustache for routing, where I have a handler
that returns a response map and the response map contains a
bytearrayinputstream. Currently I wrap the handler that makes the image
file with
Hmm I seemed to have figured it out. Calling memo-lru on the handler was
not a good idea since there are elements that change with each request,
therefore all calls were a cache miss. Also I, I can't wrap memo-lru on a
function that outputs a bytearrayinputstream since that object has state. I
19 matches
Mail list logo
