Here is a graphical example where you can see the difference in speed. <br><br>The life-bitblt-slower.ss requires matrix-slower.ss (with -&gt;d and no bounds checking in the body of the code) and is really slow.<br><br>The life-bitblt-faster.ss requires matrix-faster.ss (with -&gt; and bounds checking in the body of the code) and performs okay.<br>
<br>Other than the contract and the corresponding presence or ansence of bounds checking (to give the same functionality), the code is identical. [The only difference between life-bitblt-slower.ss and life-bitblt-faster.ss is the require statement.]<br>
<br>
The life-bitblt-vector.ss version does the matrix abstraction
internally (using a vector) and doesn&#39;t use any external module (or contracts) at all. It is by far the fastest, but
it&#39;s kind of an apples and oranges comparison with the others. I&#39;m not sure how much of the speedup is due to the matrix abstraction into a module or the contracts.<br>
<br>
They all do better compiled. But it interesting to see the speed difference.<br>
<br>Note that the code used the science and animated-canvas collections from PLaneT and will download them the first time any of them are run, which takes some time.<br><br>Doug<br><br><div class="gmail_quote">On Sat, Apr 11, 2009 at 1:55 PM, Robby Findler <span dir="ltr">&lt;<a href="mailto:robby@eecs.northwestern.edu" target="_blank">robby@eecs.northwestern.edu</a>&gt;</span> wrote:<br>

<blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;">-&gt;d actually evaluates the expressions (and/c<br>
exact-nonnegative-integer? (&lt;/c (matrix-rows matrix))) each time you<br>
call the function, and that evaluation involves building up a contract<br>
combinator (and doing various error checking) before actually checking<br>
the contract. That&#39;s where the extra overhead comes from. In<br>
comparison with the -&gt; contract, all of that work is done once, before<br>
the contract is even attached to the value. I have experimented with<br>
various optimizations to avoid this work, but there is a lot to do to<br>
make that happen.<br>
<br>
Robby<br>
<br>
On Sat, Apr 11, 2009 at 2:51 PM, Doug Williams<br>
<div><div></div><div>&lt;<a href="mailto:m.douglas.williams@gmail.com" target="_blank">m.douglas.williams@gmail.com</a>&gt; wrote:<br>
&gt; Yes, the -&gt; is fine. And, so is doing the same bounds check in my own<br>
&gt; procedure. I was surprised that the -&gt;d was so much slower. I use contracts<br>
&gt; regularly and was trying to expand my usage of them.<br>
&gt;<br>
&gt; On Sat, Apr 11, 2009 at 12:46 PM, Robby Findler<br>
&gt; &lt;<a href="mailto:robby@eecs.northwestern.edu" target="_blank">robby@eecs.northwestern.edu</a>&gt; wrote:<br>
&gt;&gt;<br>
&gt;&gt; -&gt;d is definitely substantially slower than the other because the<br>
&gt;&gt; wrappers are more complex. Are you finding the performance overhead of<br>
&gt;&gt; the ordinary -&gt; acceptable?<br>
&gt;&gt;<br>
&gt;&gt; Robby<br>
&gt;&gt;<br>
&gt;&gt; On Sat, Apr 11, 2009 at 1:17 PM, Doug Williams<br>
&gt;&gt; &lt;<a href="mailto:m.douglas.williams@gmail.com" target="_blank">m.douglas.williams@gmail.com</a>&gt; wrote:<br>
&gt;&gt; &gt; I would like to use -&gt;d to impose a precondition for a function.  For<br>
&gt;&gt; &gt; example:<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt;  (matrix-ref<br>
&gt;&gt; &gt;   (-&gt;d ((matrix matrix?)<br>
&gt;&gt; &gt;         (i (and/c exact-nonnegative-integer? (&lt;/c (matrix-rows<br>
&gt;&gt; &gt; matrix))))<br>
&gt;&gt; &gt;         (j (and/c exact-nonnegative-integer? (&lt;/c (matrix-cols<br>
&gt;&gt; &gt; matrix)))))<br>
&gt;&gt; &gt;        ()<br>
&gt;&gt; &gt;        (result any/c)))<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; or<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt;  (matrix-ref<br>
&gt;&gt; &gt;   (-&gt;d ((matrix matrix?)<br>
&gt;&gt; &gt;         (i exact-nonnegative-integer?)<br>
&gt;&gt; &gt;         (j exact-nonnegative-integer?))<br>
&gt;&gt; &gt;        ()<br>
&gt;&gt; &gt;        #:pre-cond (and (&lt; i (matrix-rows matrix))<br>
&gt;&gt; &gt;                        (&lt; j (matrix-cols matrix)))<br>
&gt;&gt; &gt;        (result any/c)))<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; instead of just<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt;  (matrix-ref<br>
&gt;&gt; &gt;   (-&gt; matrix? exact-nonnegative-integer? exact-nonnegative-integer?<br>
&gt;&gt; &gt; any/c))<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; The first two do work, but are really, really slow.<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; I like having the bounds check in the contract (as opposed to bounds<br>
&gt;&gt; &gt; check<br>
&gt;&gt; &gt; in the matrix-ref code, but can&#39;t accept the performance hit. Any ideas?<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; Doug<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt; _________________________________________________<br>
&gt;&gt; &gt;  For list-related administrative tasks:<br>
&gt;&gt; &gt;  <a href="http://list.cs.brown.edu/mailman/listinfo/plt-scheme" target="_blank">http://list.cs.brown.edu/mailman/listinfo/plt-scheme</a><br>
&gt;&gt; &gt;<br>
&gt;&gt; &gt;<br>
&gt;<br>
&gt;<br>
</div></div></blockquote></div><br>