<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel rdf:about="http://blog.gmane.org/gmane.comp.lang.scala.user">
    <title>gmane.comp.lang.scala.user</title>
    <link>http://blog.gmane.org/gmane.comp.lang.scala.user</link>
    <description/>
    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>1</syn:updateFrequency>
    <syn:updateBase>1901-01-01T00:00+00:00</syn:updateBase>
    <items>
      <rdf:Seq>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23627"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23616"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23615"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23601"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23586"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23562"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23559"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23558"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23543"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23536"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23522"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23517"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23511"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23499"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23487"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23484"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23482"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23479"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23477"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.comp.lang.scala.user/23473"/>
      </rdf:Seq>
    </items>
    <image rdf:resource="http://gmane.org/img/gmane-25t.png"/>
    <textinput rdf:resource=""/>
  </channel>
  <image rdf:about="http://gmane.org/img/gmane-25t.png">
    <title>Gmane</title>
    <url>http://gmane.org/img/gmane-25t.png</url>
    <link>http://gmane.org</link>
  </image>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23627">
    <title>scalac and javac</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23627</link>
    <description>&lt;pre&gt;
I have a mixed java/scala project. I created a build.xml with only scalac and
it doesn't really compile the .java classes it doesn't have to...

I had to add a javac just as well, to compile those. 

Is this the correct approach?

        &amp;lt;scalac scalacdebugging="true" srcdir="src" destdir="bin"&amp;gt;
            &amp;lt;classpath refid="build.classpath" /&amp;gt;
        &amp;lt;/scalac&amp;gt;

        &amp;lt;javac srcdir="src" destdir="bin"&amp;gt;
            &amp;lt;classpath refid="build.classpath" /&amp;gt;
        &amp;lt;/javac&amp;gt;



-----
Razvan Cojocaru,
Work: http://www.sigma-systems.com
Playground: http://wiki.homecloud.ca
Follow me:  http://feeds.razie.com/RazvanTech RSS Feed , 
http://twitter.com/razie Twitter . 

&lt;/pre&gt;</description>
    <dc:creator>Razvan Cojocaru</dc:creator>
    <dc:date>2010-02-10T02:49:45</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23616">
    <title>2.8+ and while versus for-comprehensions</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23616</link>
    <description>&lt;pre&gt;
Hello all,

I read a lot of posts lately about the speed differences between
plain-and-ugly while loops to replace equivalent but much slower for (i &amp;lt;-
low until high) constructs.

Today I rewrote a genetic algorithm from Java to Scala. I purposely used
for-comprehensions instead of while loops to see how big the difference
would be. Because most loops in the algorithm are pair-wise operations on
two arrays foreach is not an efficient alternative.

As could be expected the Scala versions was about 4-5 times slower than the
Java version. Then I replaced the for-comprehensions with equivalent while
loops and that brought the Scala version within 2-3% of the Java version.

Although I understand what causes this I am curious if future Scala versions
might be able to close this gap. The while-based code is much less readable
than the for-version and arguably even less pretty than the original Java
version which is in total contrast with all previous experiences rewriting
Java stuff in Scala.

Any chance future S&lt;/pre&gt;</description>
    <dc:creator>Silvio Bierman</dc:creator>
    <dc:date>2010-02-09T23:09:23</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23615">
    <title>Dialog class in 2.8</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23615</link>
    <description>&lt;pre&gt;
I am trying to do a simple dialog box that allows the user to enter data into
a text area control.   I want to return the value entered if the user
presses ok and null if they press cancel.   It seems so simple, but I am
having a terrible time getting it to work.   I call a function called
showMyDialog, which contains a custom Dialog.   If the user presses Ok, the
value of a var in showMyDialog get sets to the TA text.  If the user presses
cancel, the var get sets to null.   I then call a second function that goes
and gets the saved  var.

The problem is that the second call gets called before the dialog call
completes.   If I set the dialog to model, the second call waits for the
dialog, but listenTo in the dialog no longer works and I cannot pick either
ok or cancel.   

What am I doing wrong and how do you get a Dialog to do what I want?

Bill
&lt;/pre&gt;</description>
    <dc:creator>Bill Ramsay</dc:creator>
    <dc:date>2010-02-09T22:20:33</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23601">
    <title>Speed of mutable vs immutable objects.</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23601</link>
    <description>&lt;pre&gt;I've just done a little informal benchmark to see if purely functional
objects can compete with the speed of mutable objects, in Scala.

http://www.finalcog.com/speed-mutable-immutable-scala

Creating new immutable objects (instead of mutating mutable objects)
is one-to-two orders of magnitude slower.  (To put this in
perspective, you can still make 10's of millions of immutable objects
per second.)

Regards,

Chris.

&lt;/pre&gt;</description>
    <dc:creator>Chris Dew</dc:creator>
    <dc:date>2010-02-09T19:55:22</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23586">
    <title>Subtle differences between Java &amp; Scala. On purpose?</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23586</link>
    <description>&lt;pre&gt;I wrote two small add methods in Java and Scala, and noticed a subtle
difference. Both methods simply add two Ints and returns the result as a
Long.

Java:
public long add(int a, int b) { return a+b; }

Scala:
def add(a: Int, b: Int): Long = a+b

While they look functionally identical, they are not. Since one can argue
that the Scala method is more "correct" (or at least has the element of
least surprise), I simply wondered if this is an intentional deviation from
Java, or not? If so, I assume it can be relied on as a general principle,
and if so, are there any exceptions or corner cases for Scala?

(for those wondering what the difference is: the Scala compiler casts a and
b to Long before adding, while the Java compiler does not. This can cause
Int overflow in Java's case, but obviously not in Scala's, since it's doing
LADD instead of IADD).
&lt;/pre&gt;</description>
    <dc:creator>Nils Kilden-Pedersen</dc:creator>
    <dc:date>2010-02-09T14:14:16</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23562">
    <title>nondeterministic bug with simple actors</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23562</link>
    <description>&lt;pre&gt;I have the following Scala script:

    import scala.actors.Actor
    import scala.actors.Actor._

    class Foo extends Actor {
      def act() {
        loop {
          receive {
            case s: String =&amp;gt; println("Hello, " + s)
            case _ =&amp;gt; println("wtf...")
  }
}
  }
    }

    val t = new Foo
    t.start()

    t ! "world!"
    t ! "Noah!"
    t ! 354

When I run it, I get strange nondeterministic behavior in 2.8.0beta1:

    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    Hello, world!
    Hello, Noah!
    wtf...
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    Hello, world!
    Hello, Noah!
    wtf...
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    Hello, world!
    Hello, Noah!
    wtf...
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    Hello, world!
    Hello, Noah!
    wtf...
    noah&amp;lt; at &amp;gt;aries:~/scala$ scala actordemo.scala
    noah&amp;lt; at &amp;gt;aries:~/scala&lt;/pre&gt;</description>
    <dc:creator>Noah Tye</dc:creator>
    <dc:date>2010-02-09T02:25:42</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23559">
    <title>Quick question: Array to Seq pattern-matching MatchError</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23559</link>
    <description>&lt;pre&gt;Hi, why does the following throw an exception (in 2.8b1)? Thanks in advance.

scala&amp;gt; val Seq(a,b) = Array(1,2)
scala.MatchError: [I&amp;lt; at &amp;gt;25b0eadd
        at .&amp;lt;init&amp;gt;(&amp;lt;console&amp;gt;:5)
        at .&amp;lt;clinit&amp;gt;(&amp;lt;console&amp;gt;)
        at RequestResult$.&amp;lt;init&amp;gt;(&amp;lt;console&amp;gt;:4)
        at RequestResult$.&amp;lt;clinit&amp;gt;(&amp;lt;console&amp;gt;)
        at RequestResult$scala_repl_result(&amp;lt;console&amp;gt;)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:57)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:616)
        at scala.tools.nsc.Interpreter$Request$$anonfun$loadAndRun$1$$anonfun$apply$13.apply(Interpreter.scala:827)
        at scala.tools.nsc.Interpreter$Request$$anonfun$loadAndRun$1$$anonfun$apply$13.apply(Interpreter.scala:827)
        at scala.util.control.Exception$Catch.apply(Exception.scala:79)
        at scala.tools.nsc.Interpreter$Request$$ano&lt;/pre&gt;</description>
    <dc:creator>Yang Zhang</dc:creator>
    <dc:date>2010-02-09T00:34:49</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23558">
    <title>generic programming?</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23558</link>
    <description>&lt;pre&gt;hi,

any different concise up-to-date most-current references/critiques of
how to do various forms of generic programming in Scala? things i'm
trying to read and grok along these lines to hopefully show what i
mean:

* http://repository.tamu.edu/bitstream/handle/1969.1/5008/etd-tamu-2006C-CPSC-Nguessan.pdf

* http://www.comlab.ox.ac.uk/jeremy.gibbons/publications/scalagp.pdf

thanks!

&lt;/pre&gt;</description>
    <dc:creator>Raoul Duke</dc:creator>
    <dc:date>2010-02-09T00:34:52</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23543">
    <title>JSP taglibs in Scala</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23543</link>
    <description>&lt;pre&gt;Is using Scala XML support to implement JSP Taglibs a good idea? I've 
looked at Scalate but I personally don't like the tradeoffs compared to 
JSP much (it seems to nudge you towards writing logic into templates). 
And I find this kind of syntax to be quite horrible, reminds me of my 
PHP days:

|&amp;lt;%&amp;lt; at &amp;gt; var user:User %&amp;gt;
&amp;lt;p&amp;gt;Hi ${user.name},&amp;lt;/p&amp;gt;
&amp;lt;% for(i &amp;lt;- 1 to 3) { %&amp;gt;
&amp;lt;p&amp;gt;&amp;lt;%= i %&amp;gt;&amp;lt;/p&amp;gt;
&amp;lt;% } %&amp;gt;
|

I'm starting a new project where the rest of the team has not used Scala 
before and the budget is tight so I wouldn't want to risk writing a big 
project completely in Scala right now (especially as IDE support is 
still not very stable and no refactoring), but I'm thinking that besides 
unit tests, tag libraries might be one area where it makes really good 
sense to use Scala.

Has anyone tried this?

Lift templates would probably be another option, but I do like being 
able to use EL in templates.

Erkki

&lt;/pre&gt;</description>
    <dc:creator>Erkki Lindpere</dc:creator>
    <dc:date>2010-02-08T20:49:43</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23536">
    <title>not easy to challenge 'while' loops</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23536</link>
    <description>&lt;pre&gt;Hello Scala Users,

In the scala book section 7.2 p 119 about the while loops one can find:
"In general, we recommend you challenge while loops in your code in the 
same way you challenge vars".

I find it rather difficult to follow this rule when using Java APIs. 
Example: I would like to port the java code presented
http://java.sun.com/docs/books/tutorial/i18n/text/word.html

I find it easy to translate the Java code into a scala java-like code:


-----------------------------
scala&amp;gt; import java.text.BreakIterator
import java.text.BreakIterator

scala&amp;gt; val text="""She stopped. She said, "Hello there," and then went 
on."""
text: java.lang.String = She stopped. She said, "Hello there," and then 
went on.

scala&amp;gt; import java.util.Locale
import java.util.Locale

scala&amp;gt; val currentLocale = new Locale ("en","US")
currentLocale: java.util.Locale = en_US

scala&amp;gt; val wordIterator = BreakIterator.getWordInstance(currentLocale)
wordIterator: java.text.BreakIterator = [checksum=0x5e8990c]


scala&amp;gt;
object extract{
  d&lt;/pre&gt;</description>
    <dc:creator>TuX RaceR</dc:creator>
    <dc:date>2010-02-08T18:56:37</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23522">
    <title>pattern matching over case objects</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23522</link>
    <description>&lt;pre&gt;
I am trying to pattern match against case objects and run into a problecm I
don't understand.

The following is a simplified example of the problem I ran into. 

I have a collection containing case objects and want to filter out those
instances where the entries in the collection match certain case objects. 

My first attempt was to create separate functions for the matching of each
case object, resulting in the methods doMatchObj1 and doMatchObj2. This
works as expected.

Seeing the duplication, I wanted to parameterize the methods, so created
doMatch1, which doesn't behave as I expected and no longer matches on the
case object by on its type, hence returning both case objects.

When matching on a val defined within each case object as in doMatch2 the
matching again works as expected.

What am I doing wrong in doMatch1. The workaround of doMatch2 works for my
project, but wouldn't work when using case objects that define no vals. 

abstract class SomeClass(val label: String)

case object SomeObject1 extend&lt;/pre&gt;</description>
    <dc:creator>Niels Hoogeveen</dc:creator>
    <dc:date>2010-02-08T16:35:31</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23517">
    <title>Scala as a DSL</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23517</link>
    <description>&lt;pre&gt;
Anyone knows a good collection of examples of how Scala is good as a DSL?
i.e. what are the kinds of things you can tweak into it? Is there a good
pattern for scala-based DSL? I'm looking for declarative type of DSLs and
chapter 18 from the scala bible is not quite satisfactory...

Some are obvious with the currying thing and case classes with named
arguments, what else?

So:
- currying: add statement at end of construct
- case classes w/ named parameters: natural object creation/specification
- operators: sometimes are natural, like +/-/+=...
- lambdas: pass stuff around, andThen etc




-----
Razvan Cojocaru,
Work: http://www.sigma-systems.com
Me: http://feeds.razie.com/RazvanTech
Playground: http://wiki.homecloud.ca

&lt;/pre&gt;</description>
    <dc:creator>Razvan Cojocaru</dc:creator>
    <dc:date>2010-02-08T15:08:10</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23511">
    <title>Dialog class in 2.8</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23511</link>
    <description>&lt;pre&gt;
I'm trying to use the new Dialog class in 2.8.    When I try to add a
TextArea or a BoxPanel with contents += I get the following error:

cbDialog.scala:55: error: type mismatch;
 found   : scala.swing.BoxPanel
 required: String
      contents += new BoxPanel(Orientation.Horizontal) {
                  ^
Either I'm doing something wrong or this is a Bug.

Bill
&lt;/pre&gt;</description>
    <dc:creator>Bill Ramsay</dc:creator>
    <dc:date>2010-02-08T14:09:28</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23499">
    <title>Best practices for Actors with blocking I/O</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23499</link>
    <description>&lt;pre&gt;Hello,

When looking at Scala actors/Akka actors, how do you best handle actors that have low computational load but still blocks the thread by doing ie. a file download?
As I have understood it, the Actors implementations starts up a set number of worker threads (8?) and spreads the actors over these. This is a great way to handle OS scheduling overhead, but not when waiting for I/O.

Should I stay away from Actors when doing this, or is there some good way to get ScalaActors/Akka to spawn the number of threads I will need to keep all blocking actors running at the same time, or have I misunderstood something completely?

Thanks,
Peter
&lt;/pre&gt;</description>
    <dc:creator>Peter Salanki</dc:creator>
    <dc:date>2010-02-08T12:32:03</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23487">
    <title>Closure Implementation</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23487</link>
    <description>&lt;pre&gt;Hi,
Does anyone know of a description , preferably an academic paper, of the way
Scala implements closure on top of the JVM,

Regards,
Mokua
&lt;/pre&gt;</description>
    <dc:creator>Richard Mokua</dc:creator>
    <dc:date>2010-02-08T05:41:21</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23484">
    <title>Tricky problem combining Covariance and Implicit Builder pattern</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23484</link>
    <description>&lt;pre&gt;The code below demonstrates a problem I have got stuck upon and would
very much appreciate some advice on.

Hopefully, my intent is fairly clear: to declare generic methods in
base class BaseThing, and yet have the static return types of
transformations be tailored to each specific subclass (inspired by the
Scala 2.8 collections). At the same time, Im using an implicit builder
to handle the instantiation of the correct specific subtype.

Where things get particularly "interesting" is with an open-ended
hierarchy (ie VerySpecificThing). Because we are extending BaseThing
through several paths, the covariance annotation is required on the
This type of BaseThing. Unfortunately, that results in a variance
compiler error when passing the builder parameter.

Any ideas for solutions welcome. Im not wedded to this design, as long
as I can achieve appropriate genericity.

-Ben

object BuilderTest extends Application {

abstract class Builder[T &amp;lt;: BaseThing[T]] {
def apply(): T
}
object Builder {
implicit val &lt;/pre&gt;</description>
    <dc:creator>Ben Hutchison</dc:creator>
    <dc:date>2010-02-08T01:27:30</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23482">
    <title>HaskellDB equallent for Scala?</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23482</link>
    <description>&lt;pre&gt;Hi

I am looking for the best option to do SQL work with Scala. I am looking for
something more like JDBC or iBatis, and not so much something like
Hibernate.

I found a project called HaskellDB which is much like what I would like,
just for Scala of course

http://www.cs.chalmers.se/~bringert/publ/haskelldb/haskelldb-db-2005.pdf

Thanks,

Baldur
&lt;/pre&gt;</description>
    <dc:creator>Baldur Norddahl</dc:creator>
    <dc:date>2010-02-07T23:22:11</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23479">
    <title>Passing arrays as parameters to Java varargs methods</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23479</link>
    <description>&lt;pre&gt;When I compile the following code:

package test

class Test {
   def createMultiArray(componentType: Class[_], dimensions: Int) {
     java.lang.reflect.Array.newInstance(componentType, new 
Array[Int](dimensions))
   }
}

It produces this error:

     Error:Error:line (5)error: overloaded method value newInstance with 
alternatives (x$1: java.lang.Class[_],x$2: 
&amp;lt;repeated...&amp;gt;[Int])java.lang.Object &amp;lt;and&amp;gt; (x$1: java.lang.Class[_],x$2: 
Int)java.lang.Object cannot be applied to (Class[_$1],Array[Int])
java.lang.reflect.Array.newInstance(componentType, new 
Array[Int](dimensions))

How can I make that call, or is it a compiler bug? It used to work when 
I was developing my project on Scala 2.7.5, but after upgrading to 
2.8.0.Beta1-RC7 it does not anymore compile.

&lt;/pre&gt;</description>
    <dc:creator>Esko Luontola</dc:creator>
    <dc:date>2010-02-07T21:06:30</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23477">
    <title>scala parser for OWL</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23477</link>
    <description>&lt;pre&gt;Hi

Does anyone know of any Scala parsers for OWL -- preferably the  
functional syntax, but really any of the syntaxes would work for me.

thanks
graham&lt;/pre&gt;</description>
    <dc:creator>Graham Matthews</dc:creator>
    <dc:date>2010-02-07T20:36:42</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23473">
    <title>actors on opensolaris and os x</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23473</link>
    <description>&lt;pre&gt;Hi.

I'm writing a small scala-program using 2.8.0 beta 1 where I'm
converting images using ImageMagick. Some images can be converted in
parallel and I'm trying to wrap my head around to use actors "the
right way" :-) .

To test concurrency I convert x images on os x 10.6.2 and opensolaris
rev. 131. Both are using jdk 1.6. Opensolaris is on a xeon E5520 with
four cores with hyperthreading enabled (eight virtual cores). Os x is
my macbook pro with a dual core.

When I run the program on opensolaris 16 processes are running in
parallel which (I guess) are two threads pr. core. On my macbook pro
it starts as many processes as I wish making it crawl.

Do I have to specify a flag on os x to limit concurrent processes?

The scala-program is at http://dl.dropbox.com/u/2729115/Convert.scala.
Starting 99 processes: scala Convert 99

opensolaris: ps ax | grep -i "convert -resize" | wc -l
17 (including the ps-command)

os x: ps ax | grep -i "convert -resize" | wc -l
78

I had to force a shutdown when I had watched th&lt;/pre&gt;</description>
    <dc:creator>Claus Guttesen</dc:creator>
    <dc:date>2010-02-07T19:49:20</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.comp.lang.scala.user/23467">
    <title>newbie - obtaining nested xml elements without external elements</title>
    <link>http://comments.gmane.org/gmane.comp.lang.scala.user/23467</link>
    <description>&lt;pre&gt;scala&amp;gt; val xml =
     | &amp;lt;a&amp;gt;&amp;lt;b&amp;gt;&amp;lt;c&amp;gt;
     | &amp;lt;a&amp;gt;&amp;lt;/a&amp;gt;
     | &amp;lt;/c&amp;gt;&amp;lt;/b&amp;gt;&amp;lt;/a&amp;gt;
xml: scala.xml.Elem =
&amp;lt;a&amp;gt;&amp;lt;b&amp;gt;&amp;lt;c&amp;gt;
&amp;lt;a&amp;gt;&amp;lt;/a&amp;gt;
&amp;lt;/c&amp;gt;&amp;lt;/b&amp;gt;&amp;lt;/a&amp;gt;

scala&amp;gt; val allA = xml \\ "a"
allA: scala.xml.NodeSeq =
&amp;lt;a&amp;gt;&amp;lt;b&amp;gt;&amp;lt;c&amp;gt;
&amp;lt;a&amp;gt;&amp;lt;/a&amp;gt;
&amp;lt;/c&amp;gt;&amp;lt;/b&amp;gt;&amp;lt;/a&amp;gt;&amp;lt;a&amp;gt;&amp;lt;/a&amp;gt;

Given these xml fragments how could I specify a query that only pulled the
internal &amp;lt;a&amp;gt;&amp;lt;/a&amp;gt; node (i.e the second node in the sequence).  Or can I
always assume that it will be the final element in the sequence and always
take the last element?

Thanks in advance

Ray
&lt;/pre&gt;</description>
    <dc:creator>Raymond McDermott</dc:creator>
    <dc:date>2010-02-07T16:36:19</dc:date>
  </item>
  <textinput rdf:about="http://search.gmane.org/?group=$group=gmane.comp.lang.scala.user">
    <title>Search Engine</title>
    <description>Search the mailing list at Gmane</description>
    <name>query</name>
    <link>http://search.gmane.org/?group=$group=gmane.comp.lang.scala.user</link>
  </textinput>
</rdf:RDF>
