2010-12-05T19:27:28Z http://downgra.de Rico Schiekel blog@downgra.de 2009-04-04T00:00:00Z 2009/04/04/blog-renewal <div class="post"> <h1>blog renewal</h1> <span class="date">2009-04-04</span> <span class="post-topics"> <a href="http://downgra.de/2009/04/04/blog-renewal#disqus_thread">comments</a> | growl, python, programming </span> <div> <p>after long time of inactivity I decide to revive my blog. but I no longer want to go with <a href="http://nanoblogger.sourceforge.net/">nanoblogger</a> for several personal reasons.</p> <p>I looked around and some time I stumbled over <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll</a>. a really nice piece of work. but after some fuckup trying to get <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll's</a> dependency gems installed and mucking around with the <a href="http://pygments.org/" title="pygments">pygments</a> integration, I found more and more odds and ends which prevent me to use <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll</a> for my blog. ok, I must admit, I'm also not a really big fan of <a href="http://www.ruby-lang.org/" title="ruby">ruby</a>. ;)</p> <p><a href="http://github.com/lakshmivyas/hyde/tree/master" title="hyde">hyde</a>, the "evil Python transformation" of <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll</a>, is imho a bit to over-engineered. I personally miss the simplicity of <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll</a>.</p> <p>so what to do?</p> <p>I decide to reinvent the wheel again and implement a brand new <a href="http://www.python.org/" title="python">python</a> based static site generator. I think <a href="http://github.com/mojombo/jekyll/tree/master" title="jekyll">jekyll</a> and <a href="http://github.com/lakshmivyas/hyde/tree/master" title="hyde">hyde</a> are both very good implementations. so I shameless stole as much as I can. (on the other side I'm really really lazy guy)</p> <p>thanks a lot to all those people.</p> <p>at the moment you are looking on the output from the <a href="http://github.com/xfire/growl/tree/master" title="growl">fruits</a> of my work. <a href="http://github.com/xfire/growl/tree/master" title="growl">growl</a> is now in a useable and hopefull more or less bugfree state. so feel free to experiment with it, and let me know if you like it.</p> <p>hth</p> <h3>features</h3> <p>my favourite features are:</p> <ul> <li><p>minimal dependencies</p> <p>you only need a standard <a href="http://www.python.org/" title="python">python</a> install and the <a href="http://www.yaml.org/">python-yaml</a> package. all other is optional. </p> <p>nevertheless I recomment <a href="http://jinja.pocoo.org/2/">jinja2</a>. but you are free to use <a href="http://www.djangoproject.com/">django templates</a>, <a href="http://www.makotemplates.org/">mako</a>, <a href="http://www.cheetahtemplate.org/">cheetah</a> or whatever you like.</p> <p><a href="http://daringfireball.net/projects/markdown/">markdown</a> and <a href="http://www.textism.com/tools/textile/">textile</a> are also supported out of the box like <a href="http://jinja.pocoo.org/2/">jinja2</a>, if the corresponding <a href="http://www.python.org/" title="python">python</a> packages are installed.</p></li> <li><p>easy to install (and use?) ;)</p> <p>simply install the few needed python packages and then use <code>growl.py</code> directly, or copy the file to a directory in your <code>$PATH</code>. thats all.</p></li> <li><p>easy to extend</p> <p>using hooks, you can use other template engines, add support for other markup syntax or add metadata to your site context. and all with only a few lines of <a href="http://www.python.org/" title="python">python</a> code.</p></li> </ul> <h3>code, examples</h3> <p>take a look at <a href="http://github.com/xfire/growl/tree/master">growl</a> and as example the <a href="http://github.com/xfire/downgrade/tree/master">code</a> of this site.</p> <h3>bugs</h3> <p>please report any bugs you may discover <a href="http://http://bugs.projects.spamt.net/cgi-bin/bugzilla3/enter_bug.cgi?product=growl">here</a>.</p> <h3>license</h3> <p>the license is <a href="http://www.gnu.org/licenses/gpl-2.0.html">GPLv2</a>.</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'blog-renewal'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-04-06T00:00:00Z 2009/04/06/960-css-framework <div class="post"> <h1>960 css framework</h1> <span class="date">2009-04-06</span> <span class="post-topics"> <a href="http://downgra.de/2009/04/06/960-css-framework#disqus_thread">comments</a> | css </span> <div> <p>doing website layouts using css can sometimes be a real <a href="http://en.wiktionary.org/wiki/pain_in_the_ass" title="pain in the ass">pita</a>. there are a lot of css frameworks out in the wild. the one which impresse me the most because of its simplicity is the <a href="http://960.gs/" title="960 grid system">960 grid system</a>.</p> <p>the <a href="http://960.gs/" title="960 grid system">960 grid system</a> defines a 960 pixel wide content pane and offer 12 or 16 columns, which can be used separately or in tandem. the site content can now be spanned in those columns. the only rule is, that each row must be completely defined.</p> <p>setting up your layout is done by creating <code>&lt;div&gt;</code> tags with the correct css classes.</p> <p>this may look like this:</p> <div class="codehilite"><pre><code><span class="nt">&lt;div</span> <span class="na">class=</span><span class="s">&quot;container_12&quot;</span><span class="nt">&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;header&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_12&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;sidebar&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_3&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;content&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_9&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;footer&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_12&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;/div&gt;</span> </code></pre></div> <p>with this you got an header and footer going over the complete available width of <code>960px</code>. between you got a sidebar alongside the content pane. since we used the 12 column container, the sidebar is <code>3 * (60px + 2 * 10px)</code> = <code>240px</code> wide, the content pane <code>9 * (60px + 2 * 10px)</code> = <code>720px</code>. now you may ask, what these <code>2 * 10px</code> are. each column in a 12 column grid has a width of <code>60px</code> with <code>10px</code> margin on the left and right. on a 16 column grid, a column is <code>40px</code> wide, also with <code>10px</code> margin on the left and right.</p> <p>you can also nest your div's, but now those <code>10px</code> margins get in the way. to solve this, you can specify a <code>alpha</code> and a <code>omega</code> class to the first and last div. e.g.</p> <div class="codehilite"><pre><code><span class="nt">&lt;div</span> <span class="na">class=</span><span class="s">&quot;container_12&quot;</span><span class="nt">&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;header&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_12&quot;</span><span class="nt">&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;title&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_4 alpha&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;empty&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_4&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;info&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_4 omega&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;sidebar&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_3&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;content&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_9&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;div</span> <span class="na">id=</span><span class="s">&quot;footer&quot;</span> <span class="na">class=</span><span class="s">&quot;grid_12&quot;</span><span class="nt">&gt;</span>...<span class="nt">&lt;/div&gt;</span> <span class="nt">&lt;/div&gt;</span> </code></pre></div> <p>ah, one thing you should mind is, that you don't define a padding or margin for a div which already has a <code>grid_??</code> class set. use a second, nested div to achieve this.</p> <p>imho all really easy. best you play a bit around and look at some <a href="http://github.com/xfire/downgrade/tree/master">examples</a>.</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = '960-css-framework'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-04-07T00:00:00Z 2009/04/07/release-jitertools-1.1 <div class="post"> <h1>release jitertools version 1.1</h1> <span class="date">2009-04-07</span> <span class="post-topics"> <a href="http://downgra.de/2009/04/07/release-jitertools-1.1#disqus_thread">comments</a> | java, python, programming </span> <div> <p><a href="http://github.com/xfire/jitertools/tree/v1.1" title="jitertools 1.1 - github">version 1.1</a> of the <a href="http://github.com/xfire/jitertools/tree/" title="jitertools - github">jitertools</a> is released. this is the first public release and hopefully this little pet project is usefull for you.</p> <p>for details, look at the <code>README</code> in the <a href="http://github.com/xfire/jitertools/tree/" title="jitertools - github">project root</a>.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'release-jitertools-version-11'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-04-21T00:00:00Z 2009/04/21/release-jitertools-1.2 <div class="post"> <h1>release jitertools version 1.2</h1> <span class="date">2009-04-21</span> <span class="post-topics"> <a href="http://downgra.de/2009/04/21/release-jitertools-1.2#disqus_thread">comments</a> | java, python, programming </span> <div> <p>I just released <a href="http://github.com/xfire/jitertools/tree/v1.2" title="jitertools 1.2 - github">version 1.2</a> of the <a href="http://github.com/xfire/jitertools/tree/" title="jitertools - github">jitertools</a> library. this release adds new functions (tabulate, nth and consume) and fixes some minor bugs.</p> <p>also I manage issues now directly on <a href="http://github.com/xfire/jitertools/issues">github</a>.</p> <p>for details, look at the <code>README</code> in the <a href="http://github.com/xfire/jitertools/tree/" title="jitertools - github">project root</a>.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'release-jitertools-version-12'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-05-07T00:00:00Z 2009/05/07/release-growl-0.3 <div class="post"> <h1>release growl version 0.3</h1> <span class="date">2009-05-07</span> <span class="post-topics"> <a href="http://downgra.de/2009/05/07/release-growl-0.3#disqus_thread">comments</a> | growl, python, programming </span> <div> <p>I just released <a href="http://github.com/xfire/growl/tree/v0.3" title="growl 0.3 - github">version 0.3</a> of <a href="http://github.com/xfire/growl/tree/master" title="growl - github">growl</a>. this release adds a better deploying facility (<code>--deploy</code> and <code>post.publish</code>) and simplifies the <code>wrap()</code> helper function.</p> <p>also I manage issues now directly on <a href="http://github.com/xfire/growl/issues">github</a>.</p> <p>for details, look at the <code>README</code> in the <a href="http://github.com/xfire/growl/tree/master" title="growl - github">project root</a>.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'release-growl-version-03'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-05-16T00:00:00Z 2009/05/16/python-monkey-patching <div class="post"> <h1>python monkey patching</h1> <span class="date">2009-05-16</span> <span class="post-topics"> <a href="http://downgra.de/2009/05/16/python-monkey-patching#disqus_thread">comments</a> | python, programming </span> <div> <p>to support an easy and <a href="http://en.wikipedia.org/wiki/KISS_principle" title="Keep it Simple, Stupid">kiss</a> way for <a href="http://github.com/xfire/growl/tree/master" title="growl - github">growl</a> hooks to extend the existing classes, I wrote a <code>wrap()</code> decorator, which overwrite an existing class method. the overwritten, original method will be passed as parameter to the new method.</p> <div class="codehilite"><pre><code><span class="k">def</span> <span class="nf">wrap</span><span class="p">(</span><span class="n">orig_func</span><span class="p">):</span> <span class="sd">&quot;&quot;&quot; decorator to wrap an existing method of a class.</span> <span class="sd"> e.g.</span> <span class="sd"> @wrap(Post.write)</span> <span class="sd"> def verbose_write(forig, self):</span> <span class="sd"> print &#39;generating post: %s (from: %s)&#39; % (self.title,</span> <span class="sd"> self.filename)</span> <span class="sd"> return forig(self)</span> <span class="sd"> the first parameter of the new function is the the original,</span> <span class="sd"> overwritten function (&#39;forig&#39;).</span> <span class="sd"> &quot;&quot;&quot;</span> <span class="c"># har, some funky python magic NOW!</span> <span class="nd">@functools.wraps</span><span class="p">(</span><span class="n">orig_func</span><span class="p">)</span> <span class="k">def</span> <span class="nf">outer</span><span class="p">(</span><span class="n">new_func</span><span class="p">):</span> <span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span> <span class="k">return</span> <span class="n">new_func</span><span class="p">(</span><span class="n">orig_func</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span> <span class="k">if</span> <span class="n">inspect</span><span class="o">.</span><span class="n">ismethod</span><span class="p">(</span><span class="n">orig_func</span><span class="p">):</span> <span class="nb">setattr</span><span class="p">(</span><span class="n">orig_func</span><span class="o">.</span><span class="n">im_class</span><span class="p">,</span> <span class="n">orig_func</span><span class="o">.</span><span class="n">__name__</span><span class="p">,</span> <span class="n">wrapper</span><span class="p">)</span> <span class="k">return</span> <span class="n">wrapper</span> <span class="k">return</span> <span class="n">outer</span> </code></pre></div> <p>the example from the doc-string is imho meaningful enough. more examples can be found in the <a href="http://github.com/xfire/growl/tree/master/_hooks" title="growl - github">hooks directory</a> of growl.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'python-monkey-patching'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2009-06-19T00:00:00Z 2009/06/19/soups <div class="post"> <h1>soups</h1> <span class="date">2009-06-19</span> <span class="post-topics"> <a href="http://downgra.de/2009/06/19/soups#disqus_thread">comments</a> | web </span> <div> <p><a href="http://blog.copton.net">copton</a>, a friend of me showed me some time ago a nice site to easily gather urls, images, texts and other web related stuff.</p> <p>so here it is, my <a href="http://soup.downgra.de">soup</a> (<a href="http://www.soup.io">http://www.soup.io</a>)...</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'soups'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-02-11T00:00:00Z 2010/02/11/playing-with-scala-enumeration <div class="post"> <h1>playing with scala&#39;s enumerations</h1> <span class="date">2010-02-11</span> <span class="post-topics"> <a href="http://downgra.de/2010/02/11/playing-with-scala-enumeration#disqus_thread">comments</a> | scala, programming </span> <div> <p>I lately wonder, if I can use special values with scala's <a href="http://www.scala-lang.org/archives/beta-api/scala/Enumeration.html" title="Enumeration">Enumeration</a> class. this is my attempt to get it:</p> <div class="codehilite"><pre><code><span class="k">object</span> <span class="nc">Planet</span> <span class="k">extends</span> <span class="nc">Enumeration</span> <span class="o">{</span> <span class="k">case</span> <span class="k">class</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="n">name</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="n">mass</span><span class="k">:</span> <span class="kt">Double</span><span class="o">,</span> <span class="n">radius</span><span class="k">:</span> <span class="kt">Double</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">Val</span><span class="o">(</span><span class="n">name</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// universal gravitational constant (m3 kg-1 s-2)</span> <span class="k">val</span> <span class="n">G</span> <span class="k">=</span> <span class="mf">6.67300E-11</span> <span class="k">val</span> <span class="n">surfaceGravity</span> <span class="k">=</span> <span class="n">G</span> <span class="o">*</span> <span class="n">mass</span> <span class="o">/</span> <span class="o">(</span><span class="n">radius</span> <span class="o">*</span> <span class="n">radius</span><span class="o">)</span> <span class="k">def</span> <span class="n">surfaceWeight</span><span class="o">(</span><span class="n">otherMass</span><span class="k">:</span> <span class="kt">Double</span><span class="o">)</span> <span class="k">=</span> <span class="n">otherMass</span> <span class="o">*</span> <span class="n">surfaceGravity</span> <span class="o">}</span> <span class="k">val</span> <span class="nc">MERCURY</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Mercury&quot;</span><span class="o">,</span> <span class="mf">3.303e+23</span><span class="o">,</span> <span class="mf">2.4397e6</span><span class="o">)</span> <span class="k">val</span> <span class="nc">VENUS</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Venus&quot;</span><span class="o">,</span> <span class="mf">4.869e+24</span><span class="o">,</span> <span class="mf">6.0518e6</span><span class="o">)</span> <span class="k">val</span> <span class="nc">EARTH</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Earth&quot;</span><span class="o">,</span> <span class="mf">5.976e+24</span><span class="o">,</span> <span class="mf">6.37814e6</span><span class="o">)</span> <span class="k">val</span> <span class="nc">MARS</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Mars&quot;</span><span class="o">,</span> <span class="mf">6.421e+23</span><span class="o">,</span> <span class="mf">3.3972e6</span><span class="o">)</span> <span class="k">val</span> <span class="nc">JUPITER</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Jupiter&quot;</span><span class="o">,</span> <span class="mf">1.9e+27</span><span class="o">,</span> <span class="mf">7.1492e7</span><span class="o">)</span> <span class="k">val</span> <span class="nc">SATURN</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Saturn&quot;</span><span class="o">,</span> <span class="mf">5.688e+26</span><span class="o">,</span> <span class="mf">6.0268e7</span><span class="o">)</span> <span class="k">val</span> <span class="nc">URANUS</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Uranus&quot;</span><span class="o">,</span> <span class="mf">8.686e+25</span><span class="o">,</span> <span class="mf">2.5559e7</span><span class="o">)</span> <span class="k">val</span> <span class="nc">NEPTUNE</span> <span class="k">=</span> <span class="nc">PlanetVal</span><span class="o">(</span><span class="s">&quot;Neptune&quot;</span><span class="o">,</span> <span class="mf">1.024e+26</span><span class="o">,</span> <span class="mf">2.4746e7</span><span class="o">)</span> <span class="c1">// needed I think because Enumeration.elements is final and return the invariant </span> <span class="c1">// type Enumeration.Value :|</span> <span class="k">implicit</span> <span class="k">def</span> <span class="n">valueToPlanet</span><span class="o">(</span><span class="n">v</span><span class="k">:</span> <span class="kt">Value</span><span class="o">)</span><span class="k">:</span> <span class="kt">PlanetVal</span> <span class="o">=</span> <span class="n">v</span><span class="o">.</span><span class="n">asInstanceOf</span><span class="o">[</span><span class="kt">PlanetVal</span><span class="o">]</span> <span class="o">}</span> <span class="k">object</span> <span class="nc">EnumMain</span> <span class="o">{</span> <span class="k">def</span> <span class="n">main</span><span class="o">(</span><span class="n">args</span><span class="k">:</span> <span class="kt">Array</span><span class="o">[</span><span class="kt">String</span><span class="o">])</span> <span class="o">{</span> <span class="k">if</span> <span class="o">(</span><span class="n">args</span><span class="o">.</span><span class="n">length</span> <span class="o">&lt;</span> <span class="mi">1</span><span class="o">)</span> <span class="o">{</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;Usage: scala Planet &lt;earth_weight&gt;&quot;</span><span class="o">)</span> <span class="o">}</span> <span class="k">else</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">Planet._</span> <span class="k">val</span> <span class="n">earthWeight</span> <span class="k">=</span> <span class="n">args</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span> <span class="n">toInt</span> <span class="k">val</span> <span class="n">mass</span> <span class="k">=</span> <span class="n">earthWeight</span> <span class="o">/</span> <span class="nc">EARTH</span><span class="o">.</span><span class="n">surfaceGravity</span> <span class="nc">Planet</span><span class="o">.</span><span class="n">foreach</span><span class="o">(</span> <span class="n">p</span> <span class="k">=&gt;</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;Your weight on %s is %f&quot;</span><span class="o">.</span><span class="n">format</span><span class="o">(</span><span class="n">p</span><span class="o">,</span> <span class="n">p</span><span class="o">.</span><span class="n">surfaceWeight</span><span class="o">(</span><span class="n">mass</span><span class="o">)))</span> <span class="o">)</span> <span class="o">}</span> <span class="o">}</span> <span class="o">}</span> </code></pre></div> <p>maybe someone can explain me why I need to use an explicit cast in the <code>valueToPlanet</code> function. why can't I say something like this?</p> <div class="codehilite"><pre><code><span class="k">implicit</span> <span class="k">def</span> <span class="n">valueToPlanet</span><span class="o">(</span><span class="n">v</span><span class="k">:</span> <span class="kt">Value</span><span class="o">)</span><span class="k">:</span> <span class="kt">PlanetVal</span> <span class="o">=</span> <span class="n">v</span> </code></pre></div> <p>using the code above, the program compiles, but then hangs while executing.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'playing-scalas-enumerations'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-02-14T00:00:00Z 2010/02/14/scalatest-with-sbt-and-scala-2.8.beta1 <div class="post"> <h1>scalatest with sbt and scala 2.8.beta1</h1> <span class="date">2010-02-14</span> <span class="post-topics"> <a href="http://downgra.de/2010/02/14/scalatest-with-sbt-and-scala-2.8.beta1#disqus_thread">comments</a> | scala, programming </span> <div> <p>To get scalatest working for scala 2.8.Beta1 under <a href="http://code.google.com/p/simple-build-tool/" title="simple-build-tool">sbt</a> you need the following configuration:</p> <div class="codehilite"><pre><code><span class="k">import</span> <span class="nn">sbt._</span> <span class="k">class</span> <span class="nc">MyProject</span><span class="o">(</span><span class="n">info</span><span class="k">:</span> <span class="kt">ProjectInfo</span><span class="o">)</span> <span class="k">extends</span> <span class="nc">DefaultProject</span><span class="o">(</span><span class="n">info</span><span class="o">)</span> <span class="o">{</span> <span class="c1">// External dependencies</span> <span class="k">val</span> <span class="n">scalaToolsRepo</span> <span class="k">=</span> <span class="s">&quot;Scala-Tools Maven Repository&quot;</span> <span class="n">at</span> <span class="s">&quot;http://nexus.scala-tools.org/content/repositories/snapshots/&quot;</span> <span class="k">val</span> <span class="n">scalatest</span> <span class="k">=</span> <span class="s">&quot;org.scalatest&quot;</span> <span class="o">%</span> <span class="s">&quot;scalatest&quot;</span> <span class="o">%</span> <span class="s">&quot;1.0.1-for-scala-2.8.0.Beta1-RC7-with-test-interfaces-0.3-SNAPSHOT&quot;</span> <span class="o">%</span> <span class="s">&quot;test&quot;</span> <span class="o">}</span> </code></pre></div> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'scalatest-sbt-and-scala-28beta1'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-06-21T00:00:00Z 2010/06/21/haskell-like-type-classes-in-scala <div class="post"> <h1>haskell like type classes in scala</h1> <span class="date">2010-06-21</span> <span class="post-topics"> <a href="http://downgra.de/2010/06/21/haskell-like-type-classes-in-scala#disqus_thread">comments</a> | scala, haskell, programming </span> <div> <p>we all surely know how type classes in <a href="http://www.haskell.org/" title="haskell">haskell</a> work and how to use them. ;)</p> <p>maybe a bit like this:</p> <div class="codehilite"><pre><code><span class="kr">class</span> <span class="p">(</span><span class="kt">Show</span> <span class="n">a</span><span class="p">)</span> <span class="ow">=&gt;</span> <span class="kt">MyTypeClass</span> <span class="n">a</span> <span class="kr">where</span> <span class="n">absFunc</span> <span class="ow">::</span> <span class="n">a</span> <span class="ow">-&gt;</span> <span class="kt">String</span> <span class="n">concFunc</span> <span class="ow">::</span> <span class="n">a</span> <span class="ow">-&gt;</span> <span class="kt">String</span> <span class="n">concFunc</span> <span class="n">a</span> <span class="ow">=</span> <span class="s">&quot;concrete(&quot;</span> <span class="o">++</span> <span class="n">show</span> <span class="n">a</span> <span class="o">++</span> <span class="s">&quot;)&quot;</span> <span class="kr">data</span> <span class="kt">FooBar</span> <span class="ow">=</span> <span class="kt">FooBar</span> <span class="p">{</span> <span class="n">foo</span> <span class="ow">::</span> <span class="kt">String</span><span class="p">,</span> <span class="n">bar</span> <span class="ow">::</span> <span class="kt">String</span> <span class="p">}</span> <span class="kr">deriving</span> <span class="p">(</span><span class="kt">Show</span><span class="p">)</span> <span class="nf">printIt</span> <span class="ow">::</span> <span class="p">(</span><span class="kt">MyTypeClass</span> <span class="n">a</span><span class="p">)</span> <span class="ow">=&gt;</span> <span class="n">a</span> <span class="ow">-&gt;</span> <span class="kt">String</span> <span class="nf">printIt</span> <span class="n">a</span> <span class="ow">=</span> <span class="n">absFunc</span> <span class="n">a</span> <span class="o">++</span> <span class="s">&quot; &quot;</span> <span class="o">++</span> <span class="n">concFunc</span> <span class="n">a</span> <span class="kr">instance</span> <span class="kt">MyTypeClass</span> <span class="kt">FooBar</span> <span class="kr">where</span> <span class="n">absFunc</span> <span class="p">(</span><span class="kt">FooBar</span> <span class="n">f</span> <span class="n">b</span><span class="p">)</span> <span class="ow">=</span> <span class="s">&quot;foo(&quot;</span> <span class="o">++</span> <span class="n">show</span> <span class="n">f</span> <span class="o">++</span> <span class="s">&quot;), bar(&quot;</span> <span class="o">++</span> <span class="n">show</span> <span class="n">b</span> <span class="o">++</span> <span class="s">&quot;)&quot;</span> <span class="nf">main</span><span class="ow">::</span><span class="kt">IO</span><span class="nb">()</span> <span class="nf">main</span> <span class="ow">=</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">printIt</span> <span class="o">$</span> <span class="kt">FooBar</span> <span class="s">&quot;hallo&quot;</span> <span class="s">&quot;welt&quot;</span> </code></pre></div> <p>this example generates an output like this:</p> <div class="codehilite"><pre><code>&gt; runhaskell typeClass.hs foo<span class="o">(</span><span class="s2">&quot;hallo&quot;</span><span class="o">)</span>, bar<span class="o">(</span><span class="s2">&quot;welt&quot;</span><span class="o">)</span> concrete<span class="o">(</span>FooBar <span class="o">{</span><span class="nv">foo</span> <span class="o">=</span> <span class="s2">&quot;hallo&quot;</span>, <span class="nv">bar</span> <span class="o">=</span> <span class="s2">&quot;welt&quot;</span><span class="o">})</span> </code></pre></div> <p>with <a href="http://www.scala-lang.org/" title="scala">scala</a> it is also possible to define and use type classes using <code>implicits</code>.</p> <p>here's a simple example which has the advantage over <a href="http://www.haskell.org/" title="haskell">haskell</a>, that the type instances only apply to the surrounding scope, where the <a href="http://www.haskell.org/" title="haskell">haskell</a> type instances are global. (please correct me if I'm wrong)</p> <div class="codehilite"><pre><code><span class="k">trait</span> <span class="nc">MyTypeClass</span><span class="o">[</span><span class="kt">T</span><span class="o">]</span> <span class="o">{</span> <span class="k">def</span> <span class="n">absFunc</span><span class="o">(</span><span class="n">a</span><span class="k">:</span> <span class="kt">T</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="k">def</span> <span class="n">concFunc</span><span class="o">(</span><span class="n">a</span><span class="k">:</span> <span class="kt">T</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="s">&quot;concrete(%s)&quot;</span><span class="o">.</span><span class="n">format</span><span class="o">(</span><span class="n">a</span><span class="o">)</span> <span class="o">}</span> <span class="k">def</span> <span class="n">printIt</span><span class="o">[</span><span class="kt">T:</span> <span class="kt">MyTypeClass</span><span class="o">](</span><span class="n">t</span><span class="k">:</span> <span class="kt">T</span><span class="o">)</span> <span class="k">=</span> <span class="n">implicitly</span><span class="o">[</span><span class="kt">MyTypeClass</span><span class="o">[</span><span class="kt">T</span><span class="o">]].</span><span class="n">absFunc</span><span class="o">(</span><span class="n">t</span><span class="o">)</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span> <span class="n">implicitly</span><span class="o">[</span><span class="kt">MyTypeClass</span><span class="o">[</span><span class="kt">T</span><span class="o">]].</span><span class="n">concFunc</span><span class="o">(</span><span class="n">t</span><span class="o">)</span> <span class="k">class</span> <span class="nc">FooBar</span><span class="o">(</span><span class="k">val</span> <span class="n">foo</span><span class="k">:</span> <span class="kt">String</span><span class="o">,</span> <span class="k">val</span> <span class="n">bar</span><span class="k">:</span> <span class="kt">String</span><span class="o">)</span> <span class="k">object</span> <span class="nc">MyInstance</span> <span class="o">{</span> <span class="k">implicit</span> <span class="k">object</span> <span class="nc">FooBarTypeClass</span> <span class="k">extends</span> <span class="nc">MyTypeClass</span><span class="o">[</span><span class="kt">FooBar</span><span class="o">]</span> <span class="o">{</span> <span class="k">def</span> <span class="n">absFunc</span><span class="o">(</span><span class="n">a</span><span class="k">:</span> <span class="kt">FooBar</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">a._</span> <span class="s">&quot;foo(%s), bar(%s)&quot;</span><span class="o">.</span><span class="n">format</span><span class="o">(</span><span class="n">foo</span><span class="o">,</span> <span class="n">bar</span><span class="o">)</span> <span class="o">}</span> <span class="o">}</span> <span class="o">}</span> <span class="k">val</span> <span class="n">fb1</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">FooBar</span><span class="o">(</span><span class="s">&quot;hallo&quot;</span><span class="o">,</span> <span class="s">&quot;welt&quot;</span><span class="o">)</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">MyInstance._</span> <span class="n">println</span><span class="o">(</span><span class="n">printIt</span><span class="o">(</span><span class="n">fb1</span><span class="o">))</span> <span class="o">}</span> <span class="k">object</span> <span class="nc">MySpecialInstance</span> <span class="o">{</span> <span class="k">implicit</span> <span class="k">object</span> <span class="nc">FooBarSpecialTypeClass</span> <span class="k">extends</span> <span class="nc">MyTypeClass</span><span class="o">[</span><span class="kt">FooBar</span><span class="o">]</span> <span class="o">{</span> <span class="k">def</span> <span class="n">absFunc</span><span class="o">(</span><span class="n">a</span><span class="k">:</span> <span class="kt">FooBar</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">a._</span> <span class="s">&quot;FOO =&gt; %s, BAR =&gt; %s&quot;</span><span class="o">.</span><span class="n">format</span><span class="o">(</span><span class="n">foo</span><span class="o">,</span> <span class="n">bar</span><span class="o">)</span> <span class="o">}</span> <span class="k">override</span> <span class="k">def</span> <span class="n">concFunc</span><span class="o">(</span><span class="n">a</span><span class="k">:</span> <span class="kt">FooBar</span><span class="o">)</span><span class="k">:</span> <span class="kt">String</span> <span class="o">=</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">a._</span> <span class="s">&quot;concrete(%s, %s)&quot;</span><span class="o">.</span><span class="n">format</span><span class="o">(</span><span class="n">foo</span><span class="o">,</span> <span class="n">bar</span><span class="o">)</span> <span class="o">}</span> <span class="o">}</span> <span class="o">}</span> <span class="o">{</span> <span class="k">import</span> <span class="nn">MySpecialInstance._</span> <span class="n">println</span><span class="o">(</span><span class="n">printIt</span><span class="o">(</span><span class="n">fb1</span><span class="o">))</span> <span class="o">}</span> </code></pre></div> <p>the output should look like this:</p> <div class="codehilite"><pre><code>&gt; scala typeClasses.scala foo<span class="o">(</span>hallo<span class="o">)</span>, bar<span class="o">(</span>welt<span class="o">)</span> concrete<span class="o">(</span>Main<span class="nv">$$</span>anon<span class="nv">$1$FooBar</span>@fcfa52<span class="o">)</span> <span class="nv">FOO</span> <span class="o">=</span>&gt; hallo, <span class="nv">BAR</span> <span class="o">=</span>&gt; welt concrete<span class="o">(</span>hallo, welt<span class="o">)</span> </code></pre></div> <p>please note, that scala 2.8 is needed.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'haskell-like-type-classes-in-scala'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-07-07T00:00:00Z 2010/07/07/functors_in_scala_and_haskell_part_1 <div class="post"> <h1>functors in scala and haskell part 1</h1> <span class="date">2010-07-07</span> <span class="post-topics"> <a href="http://downgra.de/2010/07/07/functors_in_scala_and_haskell_part_1#disqus_thread">comments</a> | scala, haskell, functors, programming </span> <div> <p>today I post some <a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functor</a> examples to show how to use them in <a href="http://www.haskell.org/" title="haskell">haskell</a> and in <a href="http://www.scala-lang.org/" title="scala">scala</a>. </p> <p><a href="http://www.haskell.org/" title="haskell">haskell</a> functors are available in the <code>Control.Monad</code> and the <code>Control.Monad.Instances</code> module.</p> <p>I won't reinvent the wheel so I use the <a href="http://code.google.com/p/scalaz/" title="scalaz">scalaz</a> library. This cool library provides a lot of handy features like functors, applicative functors or monads.</p> <p>a good description what <a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functors</a> are, is the following sentence:</p> <blockquote> <p>Functors are structure-preserving maps between categories.</p> </blockquote> <p>so, here is a example which should illustrate this behavior.</p> <p>first haskell:</p> <div class="codehilite"><pre><code><span class="c1">-- the simple tree datastructure</span> <span class="kr">data</span> <span class="kt">Tree</span> <span class="n">a</span> <span class="ow">=</span> <span class="kt">Node</span> <span class="n">a</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="o">|</span> <span class="kt">Empty</span> <span class="kr">deriving</span> <span class="p">(</span><span class="kt">Show</span><span class="p">)</span> <span class="c1">-- we need a functor instance for our Tree</span> <span class="kr">instance</span> <span class="kt">Functor</span> <span class="kt">Tree</span> <span class="kr">where</span> <span class="n">fmap</span> <span class="n">f</span> <span class="kt">Empty</span> <span class="ow">=</span> <span class="kt">Empty</span> <span class="n">fmap</span> <span class="n">f</span> <span class="p">(</span><span class="kt">Node</span> <span class="n">v</span> <span class="n">l</span> <span class="n">r</span><span class="p">)</span> <span class="ow">=</span> <span class="kt">Node</span> <span class="p">(</span><span class="n">f</span> <span class="n">v</span><span class="p">)</span> <span class="p">(</span><span class="n">fmap</span> <span class="n">f</span> <span class="n">l</span><span class="p">)</span> <span class="p">(</span><span class="n">fmap</span> <span class="n">f</span> <span class="n">r</span><span class="p">)</span> <span class="c1">-- our sample data</span> <span class="nf">sampleTree</span> <span class="ow">::</span> <span class="kt">Tree</span> <span class="kt">String</span> <span class="nf">sampleTree</span> <span class="ow">=</span> <span class="kt">Node</span> <span class="s">&quot;Foo&quot;</span> <span class="p">(</span><span class="kt">Node</span> <span class="s">&quot;Bar&quot;</span> <span class="kt">Empty</span> <span class="p">(</span><span class="kt">Node</span> <span class="s">&quot;BlubBlub&quot;</span> <span class="kt">Empty</span> <span class="kt">Empty</span><span class="p">))</span> <span class="kt">Empty</span> <span class="nf">main</span><span class="ow">::</span><span class="kt">IO</span><span class="nb">()</span> <span class="nf">main</span> <span class="ow">=</span> <span class="kr">do</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="n">sampleTree</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="n">length</span> <span class="n">sampleTree</span> </code></pre></div> <p>generating the following output:</p> <div class="codehilite"><pre><code>&gt; runhaskell functorTree.hs Node <span class="s2">&quot;Foo&quot;</span> <span class="o">(</span>Node <span class="s2">&quot;Bar&quot;</span> Empty <span class="o">(</span>Node <span class="s2">&quot;BlubBlub&quot;</span> Empty Empty<span class="o">))</span> Empty Node 3 <span class="o">(</span>Node 3 Empty <span class="o">(</span>Node 8 Empty Empty<span class="o">))</span> Empty </code></pre></div> <p>you see, the sample tree containing the strings is mapped to a new tree containing the length of the several strings. the structure of the tree remain intact.</p> <p>now scala using <a href="http://code.google.com/p/scalaz/" title="scalaz">scalaz</a>:</p> <div class="codehilite"><pre><code><span class="k">import</span> <span class="nn">Scalaz._</span> <span class="c1">// the simple tree datastructure</span> <span class="k">sealed</span> <span class="k">abstract</span> <span class="k">class</span> <span class="nc">Tree</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="nc">case</span> <span class="k">class</span> <span class="nc">Empty</span><span class="o">[</span><span class="kt">Any</span><span class="o">]()</span> <span class="k">extends</span> <span class="nc">Tree</span><span class="o">[</span><span class="kt">Any</span><span class="o">]</span> <span class="k">case</span> <span class="k">class</span> <span class="nc">Node</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">v</span><span class="k">:</span> <span class="kt">A</span><span class="o">,</span> <span class="n">l</span><span class="k">:</span> <span class="kt">Tree</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">r</span><span class="k">:</span> <span class="kt">Tree</span><span class="o">[</span><span class="kt">A</span><span class="o">])</span> <span class="k">extends</span> <span class="nc">Tree</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="c1">// we need a functor instance for our Tree</span> <span class="k">implicit</span> <span class="k">def</span> <span class="nc">TreeFunctor</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Functor</span><span class="o">[</span><span class="kt">Tree</span><span class="o">]</span> <span class="o">{</span> <span class="k">def</span> <span class="n">fmap</span><span class="o">[</span><span class="kt">A</span>, <span class="kt">B</span><span class="o">](</span><span class="n">t</span><span class="k">:</span> <span class="kt">Tree</span><span class="o">[</span><span class="kt">A</span><span class="o">],</span> <span class="n">f</span><span class="k">:</span> <span class="kt">A</span> <span class="o">=&gt;</span> <span class="n">B</span><span class="o">)</span><span class="k">:</span> <span class="kt">Tree</span><span class="o">[</span><span class="kt">B</span><span class="o">]</span> <span class="k">=</span> <span class="n">t</span> <span class="k">match</span> <span class="o">{</span> <span class="k">case</span> <span class="nc">Node</span><span class="o">(</span><span class="n">v</span><span class="o">,</span> <span class="n">l</span><span class="o">,</span> <span class="n">r</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="nc">Node</span><span class="o">(</span><span class="n">f</span><span class="o">(</span><span class="n">v</span><span class="o">),</span> <span class="n">fmap</span><span class="o">(</span><span class="n">l</span><span class="o">,</span> <span class="n">f</span><span class="o">),</span> <span class="n">fmap</span><span class="o">(</span><span class="n">r</span><span class="o">,</span> <span class="n">f</span><span class="o">))</span> <span class="k">case</span> <span class="nc">Empty</span><span class="o">()</span> <span class="k">=&gt;</span> <span class="nc">Empty</span><span class="o">()</span> <span class="o">}</span> <span class="o">}</span> <span class="c1">// our sample data</span> <span class="k">val</span> <span class="n">sampleTree</span><span class="k">:</span> <span class="kt">Tree</span><span class="o">[</span><span class="kt">String</span><span class="o">]</span> <span class="k">=</span> <span class="nc">Node</span><span class="o">(</span><span class="s">&quot;Foo&quot;</span><span class="o">,</span> <span class="nc">Node</span><span class="o">(</span><span class="s">&quot;Bar&quot;</span><span class="o">,</span> <span class="nc">Empty</span><span class="o">(),</span> <span class="nc">Node</span><span class="o">(</span><span class="s">&quot;BlubBlub&quot;</span><span class="o">,</span> <span class="nc">Empty</span><span class="o">(),</span> <span class="nc">Empty</span><span class="o">())),</span> <span class="nc">Empty</span><span class="o">())</span> <span class="n">println</span><span class="o">(</span><span class="n">sampleTree</span><span class="o">)</span> <span class="n">println</span><span class="o">(</span><span class="n">sampleTree</span> <span class="n">map</span> <span class="o">(</span><span class="n">_</span><span class="o">.</span><span class="n">length</span><span class="o">))</span> <span class="o">:::</span><span class="n">bash</span> <span class="o">&gt;</span> <span class="n">scala</span> <span class="n">functorTree</span><span class="o">.</span><span class="n">scala</span> <span class="nc">Node</span><span class="o">(</span><span class="nc">Foo</span><span class="o">,</span><span class="nc">Node</span><span class="o">(</span><span class="nc">Bar</span><span class="o">,</span><span class="nc">Empty</span><span class="o">(),</span><span class="nc">Node</span><span class="o">(</span><span class="nc">BlubBlub</span><span class="o">,</span><span class="nc">Empty</span><span class="o">(),</span><span class="nc">Empty</span><span class="o">())),</span><span class="nc">Empty</span><span class="o">())</span> <span class="nc">Node</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="nc">Node</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="nc">Empty</span><span class="o">(),</span><span class="nc">Node</span><span class="o">(</span><span class="mi">8</span><span class="o">,</span><span class="nc">Empty</span><span class="o">(),</span><span class="nc">Empty</span><span class="o">())),</span><span class="nc">Empty</span><span class="o">())</span> </code></pre></div> <p>these both examples show, that for own types like our tree, special <code>fmap</code> or rather functor instances must be written. most times this is done easily, but those instance must follow some simple rules:</p> <ul> <li>identity morphism: <code>fmap id = id</code></li> <li>composition morphism: <code>fmap (f . g) = fmap f . fmap g</code></li> </ul> <p>so <a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functors</a> are a awesome abstraction over data structures and a corner stone for <a href="http://en.wikipedia.org/wiki/Monad_(functional_programming)" title="monad">monads</a>.</p> <p>enough for now...</p> <p>hth</p> <p>ps: I'm in the beginning of understanding the <a href="http://en.wikipedia.org/wiki/Category_theory" title="category theory">category theory</a>, so please correct me if I'm wrong on something.</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'functors-in-scala-and-haskell-part-1'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-07-08T00:00:00Z 2010/07/08/functors_in_scala_and_haskell_part_2 <div class="post"> <h1>functors in scala and haskell part 2</h1> <span class="date">2010-07-08</span> <span class="post-topics"> <a href="http://downgra.de/2010/07/08/functors_in_scala_and_haskell_part_2#disqus_thread">comments</a> | scala, haskell, functors, programming </span> <div> <h6>history</h6> <ul> <li><a href="http://downgra.de/2010/07/07/functors_in_scala_and_haskell_part_1" title="functors in scala and haskell part 1">functors in scala and haskell part 1</a></li> </ul> <hr /> <p>this is part 2 of the <a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functor</a> survey with some fresh examples.</p> <p>first the haskell examples:</p> <div class="codehilite"><pre><code><span class="kr">import</span> <span class="nn">Control.Monad.Instances</span> <span class="c1">-- output</span> <span class="nf">main</span><span class="ow">::</span><span class="kt">IO</span><span class="nb">()</span> <span class="nf">main</span> <span class="ow">=</span> <span class="kr">do</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="n">replicate</span> <span class="mi">3</span><span class="p">)</span> <span class="p">[</span><span class="mi">1</span><span class="o">..</span><span class="mi">4</span><span class="p">]</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="n">replicate</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="kt">Just</span> <span class="mi">4</span><span class="p">)</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="n">replicate</span> <span class="mi">3</span><span class="p">)</span> <span class="kt">Nothing</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="n">replicate</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="kt">Right</span> <span class="s">&quot;foo&quot;</span><span class="p">)</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="n">replicate</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="kt">Left</span> <span class="s">&quot;foo&quot;</span><span class="p">)</span> </code></pre></div> <p>which generates the following output:</p> <div class="codehilite"><pre><code>&gt; runhaskell fmaps.hs <span class="o">[[</span>1,1,1<span class="o">]</span>,<span class="o">[</span>2,2,2<span class="o">]</span>,<span class="o">[</span>3,3,3<span class="o">]</span>,<span class="o">[</span>4,4,4<span class="o">]]</span> Just <span class="o">[</span>4,4,4<span class="o">]</span> Nothing Right <span class="o">[</span><span class="s2">&quot;foo&quot;</span>,<span class="s2">&quot;foo&quot;</span>,<span class="s2">&quot;foo&quot;</span><span class="o">]</span> Left <span class="s2">&quot;foo&quot;</span> </code></pre></div> <p>very readable and handy...</p> <p>instead of <a href="http://www.haskell.org/" title="haskell">haskell's</a> <code>fmap</code> function, <a href="http://code.google.com/p/scalaz/" title="scalaz">scalaz</a> enables the <code>map</code> function to do the same thing using implicit functor instances. (take a look at the <a href="http://scalaz.googlecode.com/svn/continuous/latest/browse.sxr/scalaz/Functor.scala.html">implementation</a> and my article about <a href="http://downgra.de/2010/06/21/haskell-like-type-classes-in-scala/">type classes</a> for more informations)</p> <div class="codehilite"><pre><code><span class="k">import</span> <span class="nn">Scalaz._</span> <span class="k">def</span> <span class="n">replicate</span><span class="o">[</span><span class="kt">A</span><span class="o">](</span><span class="n">num</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)(</span><span class="n">value</span><span class="k">:</span> <span class="kt">A</span><span class="o">)</span><span class="k">:</span> <span class="kt">List</span><span class="o">[</span><span class="kt">A</span><span class="o">]</span> <span class="k">=</span> <span class="n">value</span><span class="o">.</span><span class="n">replicate</span><span class="o">[</span><span class="kt">List</span><span class="o">](</span><span class="n">num</span><span class="o">)</span> <span class="n">assert</span><span class="o">((</span><span class="nc">List</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">4</span><span class="o">)</span> <span class="n">map</span> <span class="n">replicate</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="n">_</span><span class="o">)</span> <span class="o">===</span> <span class="nc">List</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="mi">1</span><span class="o">,</span><span class="mi">1</span><span class="o">),</span> <span class="nc">List</span><span class="o">(</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">),</span> <span class="nc">List</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">3</span><span class="o">),</span> <span class="nc">List</span><span class="o">(</span><span class="mi">4</span><span class="o">,</span><span class="mi">4</span><span class="o">,</span><span class="mi">4</span><span class="o">)))</span> <span class="n">assert</span><span class="o">((</span><span class="nc">Some</span><span class="o">(</span><span class="mi">4</span><span class="o">)</span> <span class="n">map</span> <span class="n">replicate</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="n">_</span><span class="o">)</span> <span class="o">===</span> <span class="nc">Some</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="mi">4</span><span class="o">,</span><span class="mi">4</span><span class="o">,</span><span class="mi">4</span><span class="o">)))</span> <span class="n">assert</span><span class="o">(((</span><span class="nc">None</span><span class="k">:</span> <span class="kt">Option</span><span class="o">[</span><span class="k">_</span><span class="o">])</span> <span class="n">map</span> <span class="n">replicate</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="n">_</span><span class="o">)</span> <span class="o">==</span> <span class="nc">None</span><span class="o">)</span> <span class="c1">// unlike haskell, Left and Right is handled the same</span> <span class="n">assert</span><span class="o">((</span><span class="nc">Right</span><span class="o">(</span><span class="s">&quot;foo&quot;</span><span class="o">).</span><span class="n">right</span> <span class="n">map</span> <span class="n">replicate</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="n">_</span><span class="o">).</span><span class="n">right</span> <span class="o">===</span> <span class="nc">Right</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="s">&quot;foo&quot;</span><span class="o">,</span> <span class="s">&quot;foo&quot;</span><span class="o">,</span> <span class="s">&quot;foo&quot;</span><span class="o">)).</span><span class="n">right</span><span class="o">)</span> <span class="n">assert</span><span class="o">((</span><span class="nc">Left</span><span class="o">(</span><span class="s">&quot;foo&quot;</span><span class="o">).</span><span class="n">left</span> <span class="n">map</span> <span class="n">replicate</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="n">_</span><span class="o">).</span><span class="n">left</span> <span class="o">===</span> <span class="nc">Left</span><span class="o">(</span><span class="nc">List</span><span class="o">(</span><span class="s">&quot;foo&quot;</span><span class="o">,</span> <span class="s">&quot;foo&quot;</span><span class="o">,</span> <span class="s">&quot;foo&quot;</span><span class="o">)).</span><span class="n">left</span><span class="o">)</span> </code></pre></div> <p>you can see, <a href="http://www.haskell.org/" title="haskell">haskell</a> and <a href="http://code.google.com/p/scalaz/" title="scalaz">scalaz</a> define a lot of functor instances for common data structures like Maybe / Option, Either or lists. </p> <p>not much stunning today, but maybe in the next part.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'functors-in-scala-and-haskell-part-2'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-07-13T00:00:00Z 2010/07/13/functors_in_scala_and_haskell_part_3 <div class="post"> <h1>functors in scala and haskell part 3</h1> <span class="date">2010-07-13</span> <span class="post-topics"> <a href="http://downgra.de/2010/07/13/functors_in_scala_and_haskell_part_3#disqus_thread">comments</a> | scala, haskell, functors, programming </span> <div> <h6>history</h6> <ul> <li><a href="http://downgra.de/2010/07/07/functors_in_scala_and_haskell_part_1" title="functors in scala and haskell part 1">functors in scala and haskell part 1</a></li> <li><a href="http://downgra.de/2010/07/08/functors_in_scala_and_haskell_part_2" title="functors in scala and haskell part 2">functors in scala and haskell part 2</a></li> </ul> <hr /> <p><a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functors</a> don't only work on data structures, but also on functions. so fmap'ing the function <code>(*3) :: (Num a) =&gt; a -&gt; a</code> over another function like <code>(+100) :: (Num a) =&gt; a -&gt; a</code> results in a new function which apply <code>(*3)</code> to the result of <code>(+100)</code>.</p> <p>this sounds like something we already know. yeah, function composition with the dot <code>(.)</code> function. therefore the functor instance for functions must be written like this:</p> <div class="codehilite"><pre><code><span class="kr">instance</span> <span class="kt">Functor</span> <span class="p">((</span><span class="ow">-&gt;</span><span class="p">)</span> <span class="n">r</span><span class="p">)</span> <span class="kr">where</span> <span class="n">fmap</span> <span class="ow">=</span> <span class="p">(</span><span class="o">.</span><span class="p">)</span> </code></pre></div> <p>this instance is defined in the <code>Control.Monad.Instances</code> module. here some examples</p> <div class="codehilite"><pre><code><span class="kr">import</span> <span class="nn">Control.Monad.Instances</span> <span class="nf">f1</span> <span class="ow">=</span> <span class="p">(</span><span class="mi">100</span> <span class="o">+</span><span class="p">)</span> <span class="nf">f2</span> <span class="ow">=</span> <span class="p">(</span><span class="mi">3</span><span class="o">*</span><span class="p">)</span> <span class="nf">f3</span> <span class="ow">=</span> <span class="n">fmap</span> <span class="p">(</span><span class="o">++</span> <span class="s">&quot;_FOO&quot;</span><span class="p">)</span> <span class="n">show</span> <span class="nf">main</span><span class="ow">::</span><span class="kt">IO</span><span class="nb">()</span> <span class="nf">main</span> <span class="ow">=</span> <span class="kr">do</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="n">f2</span> <span class="n">f1</span> <span class="mi">1</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="p">(</span><span class="o">*</span><span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="o">+</span><span class="mi">100</span><span class="p">)</span> <span class="mi">1</span> <span class="n">putStrLn</span> <span class="o">$</span> <span class="n">show</span> <span class="o">$</span> <span class="n">fmap</span> <span class="n">f3</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span><span class="mi">20</span><span class="p">,</span><span class="mi">30</span><span class="p">]</span> </code></pre></div> <p>resulting in the following output</p> <div class="codehilite"><pre><code>&gt; runhaskell fmaps2.hs 303 303 <span class="o">[</span><span class="s2">&quot;10_FOO&quot;</span>,<span class="s2">&quot;20_FOO&quot;</span>,<span class="s2">&quot;30_FOO&quot;</span><span class="o">]</span> </code></pre></div> <p>pretty cool imho. now the same in <a href="http://code.google.com/p/scalaz/" title="scalaz">scalaz</a>:</p> <div class="codehilite"><pre><code><span class="k">import</span> <span class="nn">Scalaz._</span> <span class="k">val</span> <span class="n">f1</span> <span class="k">=</span> <span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="mi">100</span> <span class="o">+</span> <span class="n">x</span> <span class="k">val</span> <span class="n">f2</span> <span class="k">=</span> <span class="o">(</span><span class="n">x</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">x</span> <span class="n">assert</span><span class="o">((</span><span class="n">f1</span> <span class="n">map</span> <span class="n">f2</span><span class="o">)(</span><span class="nc">Functor</span><span class="o">.</span><span class="nc">Function1Functor</span><span class="o">)(</span><span class="mi">1</span><span class="o">)</span> <span class="o">===</span> <span class="mi">303</span><span class="o">)</span> <span class="n">assert</span><span class="o">((</span><span class="n">f1</span> <span class="n">map</span> <span class="n">f2</span><span class="o">).</span><span class="n">apply</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="o">===</span> <span class="mi">303</span><span class="o">)</span> <span class="n">assert</span><span class="o">(((</span><span class="mi">1</span><span class="o">).</span><span class="n">pure</span><span class="o">[</span><span class="kt">Identity</span><span class="o">]</span> <span class="n">map</span> <span class="n">f1</span> <span class="n">map</span> <span class="n">f2</span><span class="o">)</span> <span class="o">===</span> <span class="mi">303</span><span class="o">)</span> <span class="n">assert</span><span class="o">(((</span><span class="mi">1</span><span class="o">).</span><span class="n">pure</span><span class="o">[</span><span class="kt">Identity</span><span class="o">]</span> <span class="n">map</span> <span class="o">(</span><span class="mi">100</span><span class="o">+)</span> <span class="n">map</span> <span class="o">(</span><span class="mi">3</span><span class="o">*))</span> <span class="o">===</span> <span class="mi">303</span><span class="o">)</span> <span class="n">assert</span><span class="o">((</span><span class="nc">List</span><span class="o">(</span><span class="mi">10</span><span class="o">,</span><span class="mi">20</span><span class="o">,</span><span class="mi">30</span><span class="o">)</span> <span class="n">map</span> <span class="o">(</span><span class="n">_</span><span class="o">.</span><span class="n">toString</span><span class="o">)</span> <span class="n">map</span> <span class="o">(</span><span class="k">_</span> <span class="o">++</span> <span class="s">&quot;_FOO&quot;</span><span class="o">))</span> <span class="o">===</span> <span class="nc">List</span><span class="o">(</span><span class="s">&quot;10_FOO&quot;</span><span class="o">,</span> <span class="s">&quot;20_FOO&quot;</span><span class="o">,</span> <span class="s">&quot;30_FOO&quot;</span><span class="o">))</span> </code></pre></div> <p>I think this is relative straight forward. one problem are the implicit parameters when we try to call the new mapped function. so best call the <code>apply(...)</code> function directly.</p> <p>another little problem is the need of the <code>pure</code> function on our sample value 1. <a href="http://www.scala-lang.org/" title="scala">scala</a> need this type lifting to <code>Identity</code> to get the map function ready for our value. maybe I'm wrong here and there is a better and simpler solution. any hint is welcome.</p> <p>so much for <a href="http://en.wikipedia.org/wiki/Category_theory#Functors_2" title="functors">functors</a> on functions.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'functors-in-scala-and-haskell-part-3'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-07-15T00:00:00Z 2010/07/15/scala_self-types <div class="post"> <h1>scala self-types</h1> <span class="date">2010-07-15</span> <span class="post-topics"> <a href="http://downgra.de/2010/07/15/scala_self-types#disqus_thread">comments</a> | programming, scala </span> <div> <p>instead of <a href="http://en.wikipedia.org/wiki/Multiple_inheritance" title="multiple inheritance">multiple inheritance</a>, <a href="http://www.scala-lang.org/" title="scala">scala</a> provide a <a href="http://www.scala-lang.org/node/117" title="scala mixin class composition">mixin-based composition mechanism</a>. this is usually done with traits, which is excellent for decoupling behaviours.</p> <p>but sometimes you want to restrict these behaviours to a special domain. this can be done with self-types. </p> <p>self-types are written as follows:</p> <div class="codehilite"><pre><code><span class="k">trait</span> <span class="nc">Foo</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">SomeType</span> <span class="o">=&gt;</span> <span class="o">...</span> <span class="o">}</span> </code></pre></div> <p><code>self</code> here refers to <code>this</code>, which can be very usefull in situations, where you can not easily access the particular <code>this</code> of the current context. <br /> also <code>self</code> can be extended with type bounds. in this example, the trait <code>Foo</code> can only be mixed in a class which also implements <code>SomeType</code>. you can use this feature to restrict behaviours to a special domain.</p> <p>I think the following examples are self-explanatory...</p> <div class="codehilite"><pre><code><span class="k">object</span> <span class="nc">SelfTypes</span> <span class="o">{</span> <span class="k">trait</span> <span class="nc">MustHave1</span> <span class="k">trait</span> <span class="nc">MustHave2</span> <span class="k">trait</span> <span class="nc">Independent</span> <span class="c1">// constrain the traits A, B and C</span> <span class="k">trait</span> <span class="nc">A</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">MustHave1</span> <span class="o">=&gt;</span> <span class="o">}</span> <span class="k">trait</span> <span class="nc">B</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">MustHave2</span> <span class="o">=&gt;</span> <span class="o">}</span> <span class="k">trait</span> <span class="nc">C</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">MustHave1</span> <span class="kt">with</span> <span class="kt">MustHave2</span> <span class="o">=&gt;</span> <span class="o">}</span> <span class="c1">// correct usage</span> <span class="k">class</span> <span class="nc">Test1</span> <span class="k">extends</span> <span class="nc">MustHave1</span> <span class="k">with</span> <span class="n">A</span> <span class="k">class</span> <span class="nc">Test2</span> <span class="k">extends</span> <span class="nc">MustHave2</span> <span class="k">with</span> <span class="n">B</span> <span class="k">class</span> <span class="nc">Test3</span> <span class="k">extends</span> <span class="nc">MustHave1</span> <span class="k">with</span> <span class="nc">MustHave2</span> <span class="k">with</span> <span class="n">C</span> <span class="k">class</span> <span class="nc">Test4</span> <span class="k">extends</span> <span class="nc">MustHave1</span> <span class="k">with</span> <span class="nc">Independent</span> <span class="k">with</span> <span class="n">A</span> <span class="k">class</span> <span class="nc">Test5</span> <span class="k">extends</span> <span class="nc">Test1</span> <span class="k">with</span> <span class="n">A</span> <span class="k">class</span> <span class="nc">Test6</span> <span class="k">extends</span> <span class="nc">Test3</span> <span class="k">with</span> <span class="n">A</span> <span class="k">with</span> <span class="n">B</span> <span class="c1">// -- these examples do not type check</span> <span class="c1">// class Wrong1 extends A</span> <span class="c1">// class Wrong2 extends A with Independent</span> <span class="c1">// class Wrong3 extends MustHave2 with A</span> <span class="c1">// class Wrong4 extends MustHave1 with C</span> <span class="c1">// mixing the behaviours Resize and ColorCount in our domain Image</span> <span class="k">case</span> <span class="k">class</span> <span class="nc">Image</span><span class="o">(</span><span class="n">width</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">height</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">buf</span><span class="k">:</span> <span class="kt">Array</span><span class="o">[</span><span class="kt">Byte</span><span class="o">])</span> <span class="k">trait</span> <span class="nc">Resize</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">Image</span> <span class="o">=&gt;</span> <span class="k">def</span> <span class="n">resize</span><span class="o">(</span><span class="n">newWidth</span><span class="k">:</span> <span class="kt">Int</span><span class="o">,</span> <span class="n">newHeight</span><span class="k">:</span> <span class="kt">Int</span><span class="o">)</span><span class="k">:</span> <span class="kt">Image</span> <span class="o">=</span> <span class="o">{</span> <span class="c1">// a really stupid implementation</span> <span class="nc">Image</span><span class="o">(</span><span class="n">newWidth</span><span class="o">,</span> <span class="n">newHeight</span><span class="o">,</span> <span class="n">buf</span><span class="o">.</span><span class="n">slice</span><span class="o">(</span><span class="mi">0</span><span class="o">,</span> <span class="n">newWidth</span> <span class="o">*</span> <span class="n">newHeight</span><span class="o">))</span> <span class="o">}</span> <span class="o">}</span> <span class="k">trait</span> <span class="nc">ColorCount</span> <span class="o">{</span> <span class="n">self</span><span class="k">:</span> <span class="kt">Image</span> <span class="o">=&gt;</span> <span class="k">def</span> <span class="n">count</span><span class="o">(</span><span class="n">color</span><span class="k">:</span> <span class="kt">Byte</span><span class="o">)</span> <span class="k">=</span> <span class="n">buf</span><span class="o">.</span><span class="n">foldLeft</span><span class="o">(</span><span class="mi">0</span><span class="o">)</span> <span class="o">{(</span><span class="n">a</span><span class="o">,</span> <span class="n">v</span><span class="o">)</span> <span class="k">=&gt;</span> <span class="k">if</span><span class="o">(</span><span class="n">v</span> <span class="o">==</span> <span class="n">color</span><span class="o">)</span> <span class="n">a</span> <span class="o">+</span> <span class="mi">1</span> <span class="k">else</span> <span class="n">a</span> <span class="o">}</span> <span class="o">}</span> <span class="k">def</span> <span class="n">main</span><span class="o">(</span><span class="n">args</span><span class="k">:</span> <span class="kt">Array</span><span class="o">[</span><span class="kt">String</span><span class="o">])</span> <span class="k">=</span> <span class="o">{</span> <span class="k">val</span> <span class="n">i</span> <span class="k">=</span> <span class="k">new</span> <span class="nc">Image</span><span class="o">(</span><span class="mi">5</span><span class="o">,</span> <span class="mi">3</span><span class="o">,</span> <span class="nc">Array</span><span class="o">(</span><span class="mi">1</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">1</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">3</span><span class="o">,</span><span class="mi">1</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">,</span><span class="mi">2</span><span class="o">))</span> <span class="k">with</span> <span class="nc">Resize</span> <span class="k">with</span> <span class="nc">ColorCount</span> <span class="k">val</span> <span class="n">n</span> <span class="k">=</span> <span class="n">i</span><span class="o">.</span><span class="n">resize</span><span class="o">(</span><span class="mi">3</span><span class="o">,</span> <span class="mi">1</span><span class="o">)</span> <span class="n">assert</span><span class="o">(</span><span class="n">n</span><span class="o">.</span><span class="n">width</span> <span class="o">==</span> <span class="mi">3</span><span class="o">)</span> <span class="n">assert</span><span class="o">(</span><span class="n">n</span><span class="o">.</span><span class="n">height</span> <span class="o">==</span> <span class="mi">1</span><span class="o">)</span> <span class="n">assert</span><span class="o">(</span><span class="n">n</span><span class="o">.</span><span class="n">buf</span><span class="o">.</span><span class="n">size</span> <span class="o">==</span> <span class="o">(</span><span class="n">n</span><span class="o">.</span><span class="n">width</span> <span class="o">*</span> <span class="n">n</span><span class="o">.</span><span class="n">height</span><span class="o">))</span> <span class="n">assert</span><span class="o">(</span><span class="n">i</span><span class="o">.</span><span class="n">count</span><span class="o">(</span><span class="mi">1</span><span class="o">)</span> <span class="o">==</span> <span class="mi">3</span><span class="o">)</span> <span class="n">assert</span><span class="o">(</span><span class="n">i</span><span class="o">.</span><span class="n">count</span><span class="o">(</span><span class="mi">2</span><span class="o">)</span> <span class="o">==</span> <span class="mi">8</span><span class="o">)</span> <span class="n">assert</span><span class="o">(</span><span class="n">i</span><span class="o">.</span><span class="n">count</span><span class="o">(</span><span class="mi">3</span><span class="o">)</span> <span class="o">==</span> <span class="mi">4</span><span class="o">)</span> <span class="o">}</span> <span class="o">}</span> </code></pre></div> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'scala-self-types'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-08-05T00:00:00Z 2010/08/05/scala_gotcha_blocks_and_functions <div class="post"> <h1>scala gotcha: blocks and functions</h1> <span class="date">2010-08-05</span> <span class="post-topics"> <a href="http://downgra.de/2010/08/05/scala_gotcha_blocks_and_functions#disqus_thread">comments</a> | scala, gotcha, programming </span> <div> <p>today I stumble over a nasty scala gotcha. most people think that a code block is the same as a function. this is not true. let's see why.</p> <p>first we define a function <code>f1</code> which take another function as parameter.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="k">def</span> <span class="n">f1</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=&gt;</span> <span class="nc">Int</span><span class="o">)</span> <span class="o">{</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&gt;&gt; f1&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">(</span><span class="mi">23</span><span class="o">))</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">(</span><span class="mi">42</span><span class="o">))</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&lt;&lt; f1&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="o">}</span> <span class="n">f1</span><span class="k">:</span> <span class="o">(</span><span class="kt">f:</span> <span class="o">(</span><span class="kt">Int</span><span class="o">)</span> <span class="o">=&gt;</span> <span class="kt">Int</span><span class="o">)</span><span class="nc">Unit</span> </code></pre></div> <p>now we call <code>f1</code> with a code block. I deliberately add an side-effect to show the (for most people including me) unexpected behaviour.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="n">f1</span> <span class="o">{</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; &gt;&gt; add 23&quot;</span><span class="o">);</span> <span class="k">_</span> <span class="o">+</span> <span class="mi">23</span> <span class="o">}</span> <span class="o">&gt;&gt;</span> <span class="n">add</span> <span class="mi">23</span> <span class="o">&gt;&gt;</span> <span class="n">f1</span> <span class="n">got</span> <span class="mi">46</span> <span class="n">got</span> <span class="mi">65</span> <span class="o">&lt;&lt;</span> <span class="n">f1</span> </code></pre></div> <p>here the code block will be executed and the last statement <code>_ + 23</code> will be passed to the function <code>f1</code>. the function <code>f1</code> expect a parameter of the type <code>Int =&gt; Int</code>, so the last parameter of the block need to be a function of this type. the code block is executed only <em>once</em>, and the function <code>f1</code> receive a function of type <code>Int =&gt; Int</code> which here add 23 to its parameter.</p> <p>here an example which show that <code>_ + 1</code> is of type <code>Function1</code> which is <code>Int =&gt; Int</code>.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="k">val</span> <span class="n">x</span><span class="k">:</span> <span class="kt">Int</span> <span class="o">=&gt;</span> <span class="nc">Int</span> <span class="k">=</span> <span class="k">_</span> <span class="o">+</span> <span class="mi">1</span> <span class="n">x</span><span class="k">:</span> <span class="o">(</span><span class="kt">Int</span><span class="o">)</span> <span class="o">=&gt;</span> <span class="nc">Int</span> <span class="k">=</span> <span class="o">&lt;</span><span class="n">function1</span><span class="o">&gt;</span> <span class="n">scala</span><span class="o">&gt;</span> <span class="n">f1</span><span class="o">(</span><span class="n">x</span><span class="o">)</span> <span class="o">&gt;&gt;</span> <span class="n">f1</span> <span class="n">got</span> <span class="mi">24</span> <span class="n">got</span> <span class="mi">43</span> <span class="o">&lt;&lt;</span> <span class="n">f1</span> </code></pre></div> <p>the function <code>f1</code> can also called with a normal function definition. calling <code>f1</code> this way, the side-effect is executed every time with the closure.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="n">f1</span> <span class="o">{</span> <span class="n">i</span> <span class="k">=&gt;</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; &gt;&gt; add 42&quot;</span><span class="o">);</span> <span class="n">i</span> <span class="o">+</span> <span class="mi">42</span> <span class="o">}</span> <span class="o">&gt;&gt;</span> <span class="n">f1</span> <span class="o">&gt;&gt;</span> <span class="n">add</span> <span class="mi">42</span> <span class="n">got</span> <span class="mi">65</span> <span class="o">&gt;&gt;</span> <span class="n">add</span> <span class="mi">42</span> <span class="n">got</span> <span class="mi">84</span> <span class="o">&lt;&lt;</span> <span class="n">f1</span> </code></pre></div> <p>special are functions which have no parameters. a way to express such a type is <code>() =&gt; Int</code>.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="k">def</span> <span class="n">f2</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="o">()</span> <span class="o">=&gt;</span> <span class="nc">Int</span><span class="o">)</span> <span class="o">{</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&gt;&gt; f2&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">())</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">())</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&lt;&lt; f2&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="o">}</span> <span class="n">f2</span><span class="k">:</span> <span class="o">(</span><span class="kt">f:</span> <span class="o">()</span> <span class="o">=&gt;</span> <span class="kt">Int</span><span class="o">)</span><span class="nc">Unit</span> <span class="n">scala</span><span class="o">&gt;</span> <span class="n">f2</span> <span class="o">{</span><span class="mi">42</span><span class="o">}</span> <span class="c1">// won&#39;t compile</span> <span class="o">&lt;</span><span class="n">console</span><span class="o">&gt;:</span><span class="mi">7</span><span class="k">:</span> <span class="kt">error:</span> <span class="k">type</span> <span class="kt">mismatch</span><span class="o">;</span> <span class="n">found</span> <span class="k">:</span> <span class="kt">Int</span><span class="o">(</span><span class="err">42</span><span class="o">)</span> <span class="kt">required:</span> <span class="o">()</span> <span class="o">=&gt;</span> <span class="nc">Int</span> <span class="n">f2</span> <span class="o">{</span><span class="mi">42</span><span class="o">}</span> <span class="c1">// won&#39;t compile</span> </code></pre></div> <p>but calling is not so straightforward.</p> <p>clearly, <code>() =&gt;</code> is missing. so, now it works. the side-effect is now in the function which is received by <code>f2</code>, the side-effect is executed every time with the closure.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="n">f2</span> <span class="o">{</span> <span class="o">()</span> <span class="k">=&gt;</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; &gt;&gt; return 42&quot;</span><span class="o">);</span> <span class="mi">42</span> <span class="o">}</span> <span class="o">&gt;&gt;</span> <span class="n">f2</span> <span class="o">&gt;&gt;</span> <span class="k">return</span> <span class="mi">42</span> <span class="n">got</span> <span class="mi">42</span> <span class="o">&gt;&gt;</span> <span class="k">return</span> <span class="mi">42</span> <span class="n">got</span> <span class="mi">42</span> <span class="o">&lt;&lt;</span> <span class="n">f2</span> </code></pre></div> <p>the last way is to define a by-name parameter via <code>=&gt; Int</code>.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="k">def</span> <span class="n">f3</span><span class="o">(</span><span class="n">f</span><span class="k">:</span> <span class="o">=&gt;</span> <span class="nc">Int</span><span class="o">)</span> <span class="o">{</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&gt;&gt; f3&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">)</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; got &quot;</span> <span class="o">+</span> <span class="n">f</span><span class="o">)</span> <span class="o">|</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot;&lt;&lt; f3&quot;</span><span class="o">)</span> <span class="o">|</span> <span class="o">}</span> <span class="n">f3</span><span class="k">:</span> <span class="o">(</span><span class="kt">f:</span> <span class="o">=&gt;</span> <span class="kt">Int</span><span class="o">)</span><span class="nc">Unit</span> </code></pre></div> <p>the code block is now handled in a special way. instead of executing it directly like in the first example, it is converted to a function like object and passed to the function <code>f3</code>. so the side-effect is called every time with the closure.</p> <div class="codehilite"><pre><code><span class="n">scala</span><span class="o">&gt;</span> <span class="n">f3</span> <span class="o">{</span> <span class="n">println</span><span class="o">(</span><span class="s">&quot; &gt;&gt; return 23&quot;</span><span class="o">);</span> <span class="mi">23</span> <span class="o">}</span> <span class="o">&gt;&gt;</span> <span class="n">f3</span> <span class="o">&gt;&gt;</span> <span class="k">return</span> <span class="mi">23</span> <span class="n">got</span> <span class="mi">23</span> <span class="o">&gt;&gt;</span> <span class="k">return</span> <span class="mi">23</span> <span class="n">got</span> <span class="mi">23</span> <span class="o">&lt;&lt;</span> <span class="n">f3</span> </code></pre></div> <p>I hope this helps understanding this better.</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'scala-gotcha-blocks-and-functions'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-08-31T00:00:00Z 2010/08/31/scalas_package_shortcut <div class="post"> <h1>scala&#39;s package shortcut</h1> <span class="date">2010-08-31</span> <span class="post-topics"> <a href="http://downgra.de/2010/08/31/scalas_package_shortcut#disqus_thread">comments</a> | programming, scala </span> <div> <p>keep in mind, that these three examples express exactly the same.</p> <h3>sample 1</h3> <div class="codehilite"><pre><code><span class="k">package</span> <span class="nn">a</span> <span class="o">{</span> <span class="k">package</span> <span class="nn">b</span> <span class="o">{</span> <span class="k">package</span> <span class="nn">c</span> <span class="o">{</span> <span class="k">object</span> <span class="nc">SomeTest</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span> <span class="o">}</span> <span class="o">}</span> <span class="o">}</span> </code></pre></div> <h3>sample 2</h3> <div class="codehilite"><pre><code><span class="k">package</span> <span class="nn">a</span> <span class="k">package</span> <span class="nn">b</span> <span class="k">package</span> <span class="nn">c</span> <span class="k">object</span> <span class="nc">SomeTest</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span> </code></pre></div> <h3>sample 3</h3> <div class="codehilite"><pre><code><span class="k">package</span> <span class="nn">a.b.c</span> <span class="k">import</span> <span class="nn">a._</span> <span class="k">import</span> <span class="nn">a.b._</span> <span class="k">object</span> <span class="nc">SomeTest</span> <span class="o">{</span> <span class="o">...</span> <span class="o">}</span> </code></pre></div> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'scalas-package-shortcut'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-09-14T00:00:00Z 2010/09/14/multi-line_strings_with_scala <div class="post"> <h1>multi-line strings with scala</h1> <span class="date">2010-09-14</span> <span class="post-topics"> <a href="http://downgra.de/2010/09/14/multi-line_strings_with_scala#disqus_thread">comments</a> | programming, scala </span> <div> <p>I love the multi-line strings from <a href="http://www.python.org/" title="python">python</a>. very usefull, but there is always the problem with the indentation. <a href="http://www.python.org/" title="python">python</a> has an elegant solution, the <a href="http://docs.python.org/library/textwrap.html#textwrap.dedent"><code>textwrap.dedent(text)</code></a> function.</p> <p>scala has a almost as elegant solution, the <a href="http://www.scala-lang.org/api/current/scala/collection/immutable/StringLike.html"><code>stripMargin</code></a> function.</p> <p>see it here in action:</p> <div class="codehilite"><pre><code><span class="s">&quot;&quot;&quot;foo</span> <span class="s"> bar&quot;&quot;&quot;</span> <span class="n">foo</span> <span class="n">bar</span> <span class="s">&quot;&quot;&quot;|foo</span> <span class="s"> |bar&quot;&quot;&quot;</span><span class="o">.</span><span class="n">stripMargin</span> <span class="n">foo</span> <span class="n">bar</span> </code></pre></div> <p>other than <a href="http://www.python.org/" title="python">pythons</a> function, <a href="http://www.scala-lang.org/" title="scala">scalas</a> <code>stripMargin</code> function need a special character to which leading whitespaces are removed. default is the pipe <code>|</code>, but you can use any charater you want:</p> <div class="codehilite"><pre><code><span class="s">&quot;&quot;&quot;#spam</span> <span class="s"> #eggs&quot;&quot;&quot;</span><span class="o">.</span><span class="n">stripMargin</span><span class="o">(</span><span class="sc">&#39;#&#39;</span><span class="o">)</span> <span class="n">spam</span> <span class="n">eggs</span> </code></pre></div> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'multi-line-strings-scala'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div> 2010-09-25T00:00:00Z 2010/09/25/release_scopt_version_2_dot_0_-_scala_option_parser <div class="post"> <h1>release scopt version 2.0 - scala option parser</h1> <span class="date">2010-09-25</span> <span class="post-topics"> <a href="http://downgra.de/2010/09/25/release_scopt_version_2_dot_0_-_scala_option_parser#disqus_thread">comments</a> | scopt, scala, programming </span> <div> <p>I just release the beta of scopt v2, version 2.0 of the scala option parser.</p> <p>you can find the documentation and code on <a href="http://github.com/xfire/scopt">github</a>.</p> <p>hth</p> </div> <div id="disqus_thread"></div> <script type="text/javascript"> var disqus_identifier = 'release-scopt-version-20---scala-option-parser'; (function() { var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true; dsq.src = 'http://downgrade.disqus.com/embed.js'; (document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq); })(); </script> <noscript>Please enable JavaScript to view the <a href="http://disqus.com/?ref_noscript=downgrade">comments powered by Disqus.</a></noscript> <a href="http://disqus.com" class="dsq-brlink">blog comments powered by <span class="logo-disqus">Disqus</span></a> </div>