gmane.comp.lang.scala.internals

Autorun for REPL

Eugene Burmako — 2012-05-26T19:19:45

https://github.com/scalamacros/kepler/commit/f8968b082d5499670e36068d3a0ab65e202c9242

Your thoughts?

compiler no longer builds without specialization

Paul Phillips — 2012-05-26T17:15:47

Can anyone speculate on the nature of the dependency which has formed
between value classes and the specialization phase? The compiler now
crashes in erasure if it doesn't run.  If I remove "extends AnyVal" from
StringOps, it compiles.

% scalac -no-specialization
./src/library/scala/collection/immutable/StringOps.scala
error: no-symbol does not have an owner

     while compiling:
./src/library/scala/collection/immutable/StringOps.scala
        during phase: erasure
     library version: version 2.10.0-20120525-153506-b53b71c100
    compiler version: version 2.10.0-20120525-153506-b53b71c100
  reconstructed args: -no-specialization -d /tmp

  last tree to typer: Apply(constructor WrappedString)
              symbol: constructor WrappedString in class WrappedString
(flags: <method> <triedcooking>)
   symbol definition: def <init>(self: String):
scala.collection.immutable.WrappedString
                 tpe: scala.collection.immutable.WrappedString
       symbol owners: constructor WrappedString -> class Wrapp

Issue 2109 fix

Gábor Bakos — 2012-05-26T11:17:39

Hi,

   Previously I had an attempt to fix this<https://issues.scala-lang.org/browse/SI-2109>bug (or implement this feature), although the tests were failing, and I 
could not perform all the changes that was asked by Paul (like unifying 
with EncodingHeuristics). Here<https://github.com/aborg0/scala-1/commit/83f358bcf0e4e035540caad7feb09be89ca61a2a>is the commit I have currently.
   I am not sure how important was it, so I would like to ask, whether this 
worth adding before the 2.10 RCs, or not. Or what kind of changes do you 
propose?
   The wrong parts as I see:
 - no UTF-7 BOM support, I am not sure how could that be easily done, or is 
it important at all
 - the test settings have to be modified to pass the tests (removed the 
explicit UTF-8 encoding)
 - the IDE implementors might need further adjustments to support these 
files (I guess this should be easy)
 - I am not really good with git, so the encoding of the test files is not 
set to the proper encoding (neither for the eclipse/IDEA/... projects)

Minor-to-miniscule: default ForkJoinWorkerThread doesn't call super.onStart (ExecutionContextImpl)

Som Snytt — 2012-05-25T23:04:34

< at >axel22:

Hi, I was looking at the behavior of some multithreaded code (and don't we
all?)...

since the ForkJoinPool update, ForkJoinWorkerThread.onStart is empty, but
it still recommends calling super (in case Doug Lea puts something back in).

The custom subclass in ExecutionContextImpl doesn't call super.

This isn't quite a bug waiting to happen; or at least, it's not a bug
lurking in the shadows with an evil grin on its face.  It's more like the
kind of bug you catch by not washing your hands with soap while singing
Happy Birthday two times.  (As they say in preschool.)

I don't mind making the totally trivial pull req, which is more fun for me
than for you; or maybe it's worth a //FIXME.

This is modulo my correct reading of the code, of course.  Really I just
wanted to try out the new PRP (pull request protocol)!  In truth, I'd be
nervous to submit a pull req, because wouldn't you know the test suite will
fail with a non-deterministic result.

Thanks!

Question about scopes

Eugene Burmako — 2012-05-25T17:39:56

https://github.com/scalamacros/kepler/blob/d4d397a8bf14da2fe61106f7f7b252557c2c18aa/src/compiler/scala/reflect/runtime/SymbolLoaders.scala#L63

Question about classpaths

martin odersky — 2012-05-25T12:42:41

Looking at classpaths I see:

  def sortString = join(split(asClasspathString).sorted: _*)

  override def equals(that: Any) = that match {
    case x: ClassPath[_]  => this.sortString == x.sortString
    case _                => false
  }

If I understand the logic correctly, this means that two classpaths are
considered equal if they contain the same entries, no matter in what order.
But I would have thought order matters here. For example
say your classpath is:

  dir1:dir2

and both directories contain a file A.class. Then the one in dir1 is
chosen. So, clearly that classpath is different from

  dir2:dir1

Or do I misunderstand something?

Cheers

 - Martin

WeakIdentityHashMap

Stefan Zeiger — 2012-05-25T12:40:13

I just needed a WeakIdentityHashMap for SLICK. It's not available in 
Scala or in Java (but a bunch of custom Java implementations are 
floating around, one of them even in a com.sun package in the JDK). 
Would it make sense to add one to the Scala library?

Here's what I came up with today (fully integrated into Scala 
collections, as far as I can tell): 
https://github.com/slick/slick/commit/922db71c03676e153c5f3d02673bd815cd71ca67

-sz

lubs of structural types

Lukas Rytz — 2012-05-25T08:55:39

In "def lub1" a comment says:

          // add a refinement symbol for all non-class members of lubBase
          // which are refined by every type in ts.

Why are structural type members (i.e. members in refinements that don't
have a matching member
in the underlying type) discarded?

scala> class A; class B
scala> if (true) new { def f: A = ??? } else new { def f: B = ??? }
res0: *Object* = $anon$1< at >5f18cd5


Note that if one of the two types specializes the other, the refinement is
kept (due to elimSub):

scala> if (true) new { def f: A = ??? } else new { def f: *Object* = ??? }
res1: Object{def f: Object} = $anon$1< at >454322ba


Historical reasons (before we had structural types)? Performance?

Thanks for insights!

Lukas

URL for latest nightly tarball?

Miles Sabin — 2012-05-24T13:24:20

Hi folks,

This appears to have completely evaporated. There used to be a symlink
to the latest build here,

  http://www.scala-lang.org/archives/downloads/distrib/files/nightly/distributions/scala-2.10.0.latest.tgz

That disappeared a while back, and I've been using

  https://scala-webapps.epfl.ch/jenkins/job/scala-nightly-main/ws/dists/latest/*zip*/latest.zip

since. But that doesn't appear to have updated since
2.10.0-20120504-065643-e52be82eef.

Can we have the symlink to the latest build on scala-lang.org back?

Cheers,


Miles

Nightly Scaladoc with problem?

Daniel Sobral — 2012-05-23T15:00:28

I was looking toward seeing Heather's recent pull request on Scaladoc
show up on nightly, but it's just not appearing there. Maybe nightly
is broken, but maybe the wrong build is getting published as
Scaladoc's nightly. It happened once before. Can someone look into it?

actors migration kit fails build

Lukas Rytz — 2012-05-23T13:44:32

hey vojin,

the commit

https://github.com/scala/scala/commit/e99fb0c93842d517b8a185458f405bace2bbb46b

fails the build in pack.xml
  https://scala-webapps.epfl.ch/jenkins/job/scala-checkin/5744/consoleFull

can you take a look at it?

thanks!

Class with factory method

Stefan Zeiger — 2012-05-23T13:41:55

Hi,

This code does what you expect it to do in Scala but it's probably not 
what you want in many cases:

trait A {
   class Foo(x: Int) {
     def apply = println("A.Foo("+x+")")
   }

   def bar = (new Foo(42)).apply
}

trait B extends A {
   class Foo(x: Int) extends super.Foo(x) {
     def apply = println("B.Foo("+x+")")
   }
}

This is a common situation in the new driver architecture for SLICK 
(using a super-cake pattern). What I usually want is this:

trait A {
   class Foo(x: Int) {
     def apply = println("A.Foo("+x+")")
   }
   def createFoo(x: Int) = new Foo(x)

   def bar = createFoo(42).apply
}

trait B extends A {
   class Foo(x: Int) extends super.Foo(x) {
     def apply = println("B.Foo("+x+")")
   }
   override def createFoo(x: Int) = new Foo(x) // easy to forget!
}

A possible language support for this is not far from the SIP-13 implicit 
classes (except without the implicit and with no restrictions on the 
constructor parameters). All we need is a mechanism for auto-generating 
factory

Size increase of Scala Swing jar between 20120511 and 20120521

Simon Ochsenreither — 2012-05-22T23:05:11

Hi,

probably I'm just nitpicking, but maybe it is important:

Nothing was changed in swing/event between 20120511 and 20120521, but 11 
new class files appeared there, with names like

KeyTyped$$anonfun$copy$1.class
KeyPressed$$anonfun$copy$2.class
KeyReleased$$anonfun$copy$3.class

each one with ~ 1.5 kb size.

Is this expected?

Thanks,

Simon

abstraction?

Adriaan Moors — 2012-05-22T22:49:56

I can't decide, so was wondering about your opinion:

In the comments of https://github.com/scala/scala/pull/589 I argue that
we should get rid of SymCollector, as one its three subclasses isn't used,
and the other two may need to diverge to fix
https://issues.scala-lang.org/browse/SI-5318.

Then I argue that maybe we should keep them.

What do you think?

    abstract class SymCollector extends TypeCollector(List[Symbol]()) {
      protected def includeCondition(sym: Symbol): Boolean

      def traverse(tp: Type) {
        tp.normalize match {
          case TypeRef(_, sym, _) =>
            if (includeCondition(sym) && !result.contains(sym)) result =
sym :: result
          case _ =>
        }
        mapOver(tp)
      }
    }

    /** A traverser to collect type parameters referred to in a type
     */
    object freeTypeParamsOfTerms extends SymCollector {
      // An inferred type which corresponds to an unknown type
      // constructor creates a file/declaration order-dependent crasher
      // situat

scala meeting summary

Adriaan Moors — 2012-05-22T16:56:31

just a quick update from the meeting notes

on the critical path to M4:
- the pull request that implements exhaustivity for the new pattern matcher
is waiting for a review, but otherwise ready to go
  - unreachability & typetag-based type tests are next
- reflection refactoring: Martin is happy about the new design, but Eugene
& he are still ironing out the implementation, fixing tests

we'll cut M4 when these features are in master, which will either be by the
end of this week or early next week


we now have a pull request policy v0.1:
https://github.com/scala/scala/wiki/Pull-Request-Policy

ScalaReference building

Josh Suereth — 2012-05-22T13:33:14

I think Latex and myself do not get along.  I'm trying to build the
ScalaReference (in the distribution build, not the original ant build) and
getting the following:

[error] kpathsea: Running mktexpk --mfmode / --bdpi 600 --mag 0+526/600
--dpi 526 ul9ro8r
[error] mktexpk: don't know how to create bitmap font for ul9ro8r.
[error] kpathsea: Appending font creation commands to missfont.log.
[info] [182] [183] (./ScalaReference.aux)
[info]
[info] LaTeX Warning: There were undefined references.
[info]
[info]  ) )
[info] (see the transcript file for additional information)
[info] !pdfTeX error: pdflatex (file ul9ro8r): Font ul9ro8r at 526 not found
[info]  ==> Fatal error occurred, no output PDF file produced!
[error] Latexmk: Missing input file: 'ScalaReference.tpt' from line
[error]   'Package thumbpdf Warning: Thumbnail data file
`ScalaReference.tpt' not found.'
[error] Latexmk: Reference `volatile-types' on page 137 undefined
[error] Latexmk: Reference `volatile-types' on page 137 undefined
[error] Latexmk: F

Max Overload

Chris Hodapp — 2012-05-22T08:34:40

In order to be able to allow DynamicProxy to accept explicit type 
parameters, I found that I needed to be able to override the *Dynamic 
methods on their type parameters. The so-called "overload hack" (i.e. 
having different-length implicit parameter lists that are always satisfied) 
allows this for cases of 1+ type parameter. However, this does not allow 
for a version with a zero-length type parameter list to coexist with the 
rest. More precisely, though you can define such a method, you cannot call 
it (or at least not with the regular syntax).

Code:
"""
object O {
def foo(x: Int) = x
def foo[A: TypeTag](x: Int) = x + 1
def foo[A: TypeTag, B: TypeTag](x: Int) = x + 2
}

object P {
def bar {
println(O.foo[Int, String](3)) // works
println(O.foo[Int](2)) // works
println(O.foo(1)) // error: ambiguous

}
}
"""

This happens because the typer is willing to let O.foo(1) become 
O.foo[Nothing](1) or O.foo[Nothing, Nothing](1). Furthermore, it does not 
prefer the version that the user actually wrote over the

on a walkabout with src/{compiler, library}

Paul Phillips — 2012-05-21T22:47:19

All -- on the off chance anyone has noticed that I've been relatively
scarce lately, and on the higher chance someone will notice eventually, I
wanted to let everyone know that I am attempting a more ambitious code
overhaul than is possible for me to undertake within master.  I don't know
whether it will work out, but my goal is to explore providing a more robust
and performant foundation for some future version of scala.

Many thanks to Typesafe for making it possible.  I'll have something to
look at after 2.10 is out.

isInstanceOf and abstract types

Eugene Burmako — 2012-05-21T21:14:02

Can the situation be improved when we have tags for abstract types?

Mailing list reminder: Scala-internals

Scala Mailing Lists — 2012-05-21T13:32:02

Welcome to the "Scala-internals" mailing list.

This automatic reminder is sent once a month to the list,
to keep subscribers up-to-date with the mailing list services,
and to help keeping the list on topic.

-------------------------------------------------------------------

The "Scala-internals" mailing list:

This is the mailing list that developers of the Scala
compiler and libraries use to discuss the core internal
design and the implementation of the Scala system.

This list is normally only used by developers who
commit code to the Scala code base; it is open to the
general public in order to make the development process
more transparent.

Please only create new threads if you commit to the
Scala code base, and you need to discuss the internals
of the Scala system.

General programming questions and bug reports should be
addressed to "scala-user" instead. For all general
questions and other discussions, please use the
"scala-language" mailing list instead.

-------------------------------------------

JIRA is unavailable

Chris Marshall — 2012-05-21T10:03:04

I cannot access this URL: https://issues.scala-lang.org/ - don't know whether this is planned or known already...
Chris