gmane.comp.lang.scala.user

Re: Future and nondeterministic dataflow

√iktor Ҡlang — 2013-05-20T21:15:40

Hi Andrew,

import scala.concurrent.{ Future, ExecutionContext }
import ExecutionContext.Implicits.global
val f = Future(1)
if (f.isCompleted) launchTorpedoes() else lobsterForEverybody()


Is the program above deterministic?

Cheers,
√


On Mon, May 20, 2013 at 11:02 PM, Andrew Gaydenko <andrew.gaydenko-Re5JQEeQqe8< at >public.gmane.orgm

Future and nondeterministic dataflow

Andrew Gaydenko — 2013-05-20T21:02:31

From Future#isCompleted scaladoc: 

   *Note: using this method yields nondeterministic dataflow programs.*

What does it exactly - *in terms of a code*  - mean?

Re: swing: scale & translate mouse position

Naftoli Gugenheim — 2013-05-20T20:03:46

Where do you have the graphics transform?


On Wed, May 15, 2013 at 6:41 AM, Boris Hollas <
hollas-jNDFPZUTrfSI6G3CRkLG2/hqMcnVdK/bs0AfqQuZ5sE< at >public.gmane.org> wrote:

Re: Variable-length tuple?

Joe Barnes — 2013-05-20T15:06:37

I'll have to keep working on the example that Jed offered.  I didn't 
immediately understand it.  

I have a better, slightly less contrived illustrative code for what I am 
trying to accomplish.  The HeadHunter object is where I want to support an 
arbitrary number of arguments to the get function.  The HeadHunterSuiteclass should help show how it could be called.

object HeadHunter {
  def get[A](a:Seq[A]):Option[A] = 
    a.headOption
  def get[A,B](a:Seq[A],b:Seq[B]):(Option[A],Option[B]) = 
    (a.headOption, b.headOption)
  def 
get[A,B,C](a:Seq[A],b:Seq[B],c:Seq[C]):(Option[A],Option[B],Option[C]) = 
    (a.headOption, b.headOption, c.headOption)
  
}

class HeadHunterSuite extends WordSpec with ShouldMatchers {
  "HeadHunter" should {
    "be type safe and therefore awesome" in {
      import HeadHunter._
      get(Seq(1,2,3)) should equal (
          Some(1))
      get(Seq("strs","str2"), Seq(4,5,6)) should equal (
          (Some("strs"),Some(4)))
      get(Seq(true,false,true), Seq("str1","str2"), Seq(3)) should equal (
          (Some(true), Some("str1"), Some(3)))
    }
  }
}

Thanks!

Joe


On Sunday, 19 May 2013 15:58:47 UTC-5, Joe Barnes wrote:

Re: Variable-length tuple?

Joe Barnes — 2013-05-20T14:32:05

Hi Miles, don't worry about missing that detail.  The example I gave is a 
bit contrived to avoid explaining the details of my project.  The 
parameterized types that I will be passing to my functions aren't of type 
Option[A] but some other Type[A] that doesn't have a None.

Joe


On Monday, 20 May 2013 08:53:38 UTC-5, Miles Sabin wrote:

Re: Variable-length tuple?

Joe Barnes — 2013-05-20T14:30:23

Thanks for the reply.  I'll try to pick through this and get it working for 
my code.

Joe


On Sunday, 19 May 2013 17:50:05 UTC-5, Jed Wesley-Smith wrote:

Re: Variable-length tuple?

Miles Sabin — 2013-05-20T13:53:38

You should be able to do this with shapeless ... but one thing I'm
missing though ... what is the intended semantics if one of the
argument to f is None? Is there supposed to be a corresponding
default?

Cheers,


Miles

--
Miles Sabin
tel: +44 7813 944 528
skype: milessabin
gtalk: miles-XKJT71GPLR04Q++5jOxPmw< at >public.gmane.org
g+: http://www.milessabin.com
http://twitter.com/milessabin

Re: Some language questions (about the "Action" and "Ok" concepts from the Scala Play API)

Chris Beach — 2013-05-20T10:18:55

Hi Josh,

Thanks for this explanation. Like the original poster, I was also curious 
to know what was going on!

Chris

On Monday, 26 March 2012 14:38:37 UTC+1, Josh Suereth wrote:

New Functional Programming Job Opportunities

Functional Jobs — 2013-05-20T06:00:02

Here are some functional programming job opportunities that were posted

recently:



Test Engineer at Klarna

http://functionaljobs.com/jobs/146-test-engineer-at-klarna



Cheers,

Sean Murphy

FunctionalJobs.com

Re: new warnings in 2.10 for enumerations

Jason Zaugg — 2013-05-20T04:09:42

This is https://issues.scala-lang.org/browse/SI-6514

It is fixed in the forthcoming release, 2.10.2. We've just had a code
freeze for the first release candidate, so it's not far away.

Until then, remove -Ywarn-dead-code.

-jason

Re: new warnings in 2.10 for enumerations

Jason Zaugg — 2013-05-20T03:54:29


I'm unable to reproduce. What compiler options are you using.

Here's what I tried:

  /code/scala cat sandbox/rp.scala
sealed trait ManeuverType

object ManeuverType { // enumeration of maneuver types

  case object alt extends ManeuverType // altitude maneuver
  case object vec extends ManeuverType // horizontal "vector" maneuver
  case object spd extends ManeuverType // speed manevuer
}
  /code/scala RUNNER=scalac scala-hash v2.10.1 -Ydead-code sandbox/rp.scala
[info] v2.10.1 => /Users/jason/usr/scala-v2.10.1-0-g77b864e
  /code/scala RUNNER=scalac scala-hash v2.10.0 -Ydead-code sandbox/rp.scala
[info] v2.10.0 => /Users/jason/usr/scala-v2.10.0-0-g18481ce

-jason

new warnings in 2.10 for enumerations

Russ P. — 2013-05-20T03:33:48

I just upgraded from 2.9.2 to 2.10.1, and I am getting warnings that I did 
not get before. Here's the relevant code:

sealed trait ManeuverType

object ManeuverType { // enumeration of maneuver types

    case object alt extends ManeuverType // altitude maneuver
    case object vec extends ManeuverType // horizontal "vector" maneuver
    case object spd extends ManeuverType // speed manevuer
    }

And here are the warnings:

[warn] /home/Maneuver.scala:12: dead code following this
construct
[warn]     case object alt extends ManeuverType // altitude maneuver
[warn]                 ^
[warn] /home/Maneuver.scala:13: dead code following this
construct
[warn]     case object vec extends ManeuverType // horizontal "vector" 
maneuver
[warn]                 ^
[warn] /home/Maneuver.scala:14: dead code following this
construct
[warn]     case object spd extends ManeuverType // speed manevuer
[warn] 

What changed in the language or compiler to cause these warnings? Thanks.

--Russ P.                ^

Re: Variable-length tuple?

Vlad Patryshev — 2013-05-19T23:02:45

I believe Shapeless HList was designed exactly with the purpose of solving
this kind of problems.

Thanks,
-Vlad


On Sun, May 19, 2013 at 1:58 PM, Joe Barnes <barnesjd-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: Variable-length tuple?

Jed Wesley-Smith — 2013-05-19T22:50:05

We have something similar (using shapeless) to do command-line option
parsing. Basically we pass in a function of variable arity and it will work
out the length from that, chomping off that many arguments from a list.

The code we use is here:
https://bitbucket.org/atlassian/kadai/src/master/cmdopts/src/main/scala/kadai/cmdopts/CmpOpts.scala?at=master

and an example usage is here:
https://bitbucket.org/atlassian/kadai/src/master/cmdopts/src/main/scala/kadai/cmdopts/Example.scala?at=master

All of the work is done in the opt method:

  def opt[H <: HList, N <: Nat, F, R](t: T, f: F)(    implicit
hlister: FnHListerAux[F, H => R],    length: LengthAux[H, N],
toHList: FromTraversable[H],    size: ToInt[N]): Option[R] =    for {
    ts <- if (size() > 0) tailfind(t) else rawdata.find { _ == t }.map
{ _ => Nil }      hl <- toHList(ts.take(size()))      op <-
nonFatalCatch.opt { hlister(f)(hl) }    } yield op


where the T is the input type (in practice always String) and R is the
output type. The various implicits witness that we can get the
arguments of our function as an HList, that we can work out the length
of that HList, that we can turn our rawdata (a field in this case)
into an HList, and that we can turn our size into an Int value so we
can take that many elements from ou rawdata.


It takes a little while to puzzle though, but it works really well and
is nice and compact.


cheers,

jed.



On 20 May 2013 06:58, Joe Barnes <barnesjd-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Variable-length tuple?

Joe Barnes — 2013-05-19T20:58:47

I've started an open-source project (SNMP4S<https://github.com/barnesjd/snmp4s>if you're interested), and I've run into a snag trying to accomplish my 
type-safety goals.  I *think* what I need is some kind of variable-length 
tuple.  A list won't work because the type of the contents are 
parameterized with different.  A tuple accomplishes what I need, but I have 
to hand-write a function for every number of arguments I hope to support. 
 It is much like Scala's limit on functions having at most 22 parameters.

To avoid gory details of my project, suppose I wanted to have this Tuplizerclass below.  I really like what the 
Consumer class looks like because each variable returned infers the correct 
type.  However, I'd like to avoid hand-writing the 3 different functions 
and be able to support an arbitrary number of Options passed to f.

class Tuplizer {
  def f[A](a:Option[A]):A = ???
  def f[A, B](a:Option[A], b:Option[B]):(A,B) = ???
  def f[A, B, C](a:Option[A], b:Option[B], c:Option[C]):(A,B,C) = ???
  // ...
  
}

class Consumer {
  def t:Tuplizer = new Tuplizer
  
  def use = {
    val a = t.f(Some(1))
    val (b, c) = t.f(Some("String"), Some(5))
    val (d, e, f) = t.f(Some(7), Some("Other"), Some(true))
  }
}

The best hint I've found towards accomplishing this is to use shapeless per this 
post <http://stackoverflow.com/a/10487475>.  But I don't think that helps 
me get a varying number of args.  Any good ideas?

Re: another type mismatch.

yves — 2013-05-19T15:20:16

An interesting link! Thanks!
It certainly is relevant to my problem.

Yves


Le lundi 13 mai 2013 16:27:09 UTC+2, yves a écrit :

Re: another type mismatch.

Jan Vanek — 2013-05-19T14:14:45

Yves, you could look at the proposal about encoding of virtual classes 
in Scala. I found this link:
https://wiki.scala-lang.org/display/SIW/VirtualClasses
but there might be others. I believe understanding of the mechanism will 
clarify a lot of things for you.

Regards,
Jan

On 13.05.2013 16:27, yves wrote:

Re: Best way to declare a typeclass having a superclass

Julien Richard-Foy — 2013-05-19T13:50:01

Thanks for your answers!

Le samedi 18 mai 2013 12:34:45 UTC+2, Lars Hupel a écrit :

Scala 2.11 compiler response speed improved?

Stergios Papadimitriou — 2013-05-19T13:02:02

Hi all,

it seems to me that ScalaLab based on the latest 2.11 build has improved
response ("startup") time.

Does compiler improvements introduced recently (after 2.11 M2) in 2.11?

Stergios

Re: [ANNOUNCE] mysql-async and postgresql-async 0.2.2 released

Maurício Linhares — 2013-05-19T05:08:32

I'm accepting proposals for scalability testing :)

It's rather hard to make statements here, since it would definitely
allow you to keep 10k connections to the database, but can you use 10k
connections? Is the database going to allow you to make 10k
connections to it? How much memory overhead and GC time will 10k
connections will cause in your app? (every prepared statement is an
object and also takes up memory on both ends)

I think the main advantage is allowing you to follow the flow of a
framework like Akka, Spray or blueeyes, where the flow is usually
async by nature. If you're using JDBC, you need to "jump out" of the
main framework loop and block for it, when using these async drivers
you can just do it the way the framework works, since every db call
produces a future.

But if anyone has ideas on how this could be tested, I'm all ears :)
-
Maurício Linhares
http://mauricio.github.io/ - http://twitter.com/#!/mauriciojr


On Sat, May 18, 2013 at 6:51 PM, Flavio W. Brasil <fwbrasil-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org> wrote:

Re: [ANNOUNCE] mysql-async and postgresql-async 0.2.2 released

Flavio W. Brasil — 2013-05-18T21:51:43

Hi.  

I am developing an integration with Activate (http://activate-framework.org/). I've tested the postgresql driver and it works very well!
I am anxious to see what are the performance and scalability characteristcs of the driver.