Future.onSuccess

[Nils Kilden-Pedersen]

I guess I know why this doesn't work, but I'm not sure why it's not allowed, i.e. why a partial function? Seems syntactically heavier and I could just match if that was needed.

scala> def slow = {Thread.sleep(2000); "Slow string"}

slow: java.lang.String

scala> Future(slow).onSuccess(println)

<console>:18: error: type mismatch;

 found   : Unit

 required: PartialFunction[java.lang.String,?]

              Future(slow).onSuccess(println)

                                     ^

[Rex Kerr]

You have foreach and map available to handle the full function cases.  onSuccess and onFailure are specifically for partial functions.

  --Rex

--
You received this message because you are subscribed to the Google Groups "scala-user" group.
To unsubscribe from this group and stop receiving emails from it, send an email to scala-user+...@googlegroups.com.
For more options, visit https://groups.google.com/groups/opt_out.
 
 

[Nils Kilden-Pedersen]

Indeed I do. Although somewhat unexpected to have foreach and map be blocking calls.

Thanks.

[Rex Kerr]

You mean for them to _not_ be blocking:

scala> Future{ Thread.sleep(1000); println("Hi"); "Bye" }.foreach(println); println("Look!")
Look!

scala> Hi
Bye

   --Rex

[Nils Kilden-Pedersen]

Ha, well no. :-)

What I meant was that it's unexpected to have them be asynchronous.

[Matthew Pocock]

The key thing, I think, is the sequencing, not which thread things run on. As long as the things that are requested to run before or after each other do run in that order, all is good. Beyond that, you should plan for the maximal asynchronousity but perhaps expect not so much ;)

Matthew

Dr Matthew Pocock

Turing ate my hamster LTD

mailto: turingate...@gmail.com

Integrative Bioinformatics Group, School of Computing Science, Newcastle University

mailto: matthew...@ncl.ac.uk

gchat: turingate...@gmail.com

msn: matthew...@yahoo.co.uk

irc.freenode.net: drdozer

skype: matthew.pocock

tel: (0191) 2566550

mob: +447535664143

[Nils Kilden-Pedersen]

The question then becomes, is there any way to block on a Future?

[Nils Kilden-Pedersen]

Presumably using `ready` or `result`. Although the syntax is a bit unusual (seen through Java Future glasses). An implicit CanAwait is expected. And then the docs say that I shouldn't really use those methods, but instead use Await.ready/result. Which then begs the question of why they're public then. Oh well....

[√iktor Ҡlang]

abstract defresult(atMost: Duration)(implicit permit: CanAwait): T

Await and return the result (of type T) of this Awaitable.

This method should not be called directly; use Await.result instead.

atMost

maximum wait time, which may be negative (no waiting is done), Duration.Inf for unbounded waiting, or a finite positive duration

returns

the result value if the Awaitable is completed within the specific maximum wait time

Definition Classes

Awaitable

Annotations

@throws( cause = classOf[Exception] )

Exceptions thrown

IllegalArgumentException

if atMost is Duration.Undefined

InterruptedException

if the current thread is interrupted while waiting

TimeoutException

if after waiting for the specified time this Awaitable is still not ready

http://www.scala-lang.org/api/current/index.html#scala.concurrent.Future

Viktor Klang
Director of Engineering

Typesafe

Twitter: @viktorklang

[Luis Ángel Vicente Sánchez]

You could block using scala.concurrente.Await.

[Nils Kilden-Pedersen]

Yes, those docs. Were you trying to imply something?

[Nils Kilden-Pedersen]

I guess a race condition :-)

But why are those methods public if they shouldn't be called directly?

[√iktor Ҡlang]

I answered your question?

[Nils Kilden-Pedersen]

Yes, but it wasn't clear which of the posts you were replying to. I assumed a later post than I guess it was.

[√iktor Ҡlang]

JVM interfaces only have public abstract methods (see Awaitable). (and consider Java usage)

We wanted people to have to go through Await for all blocking, to make it easier to do the right thing (async).

Cheers,

√

[√iktor Ҡlang]

Your email, which I replied to, was quoted below my reply.

(as I do always)

Cheers,

√

[Nils Kilden-Pedersen]

Ah, it was hidden by gmail and I clicked the other hidden part. Sorry about that.

[Som Snytt]

On Tue, May 7, 2013 at 1:43 PM, √iktor Ҡlang <viktor...@gmail.com> wrote:

I answered your question?

...with a question?

But seriously, I'd endorse Nils' original point, that it's easy for us, pardon the expression, dumb people to forget when a PF is expected.

There have been recent threads about:

1) if the expected type is TupleN => R, let me write:

c map ((x,y,z) => r)      // or similarly for Foo(x) => res

to mean

c map (_ match { case (x, y, z) => r })

2) if the expected type is A => Boolean, let me write:

c filter p

to mean

c filter { case p => true; case _ => false }

Actually, the SIP is to allow c filter (_ match p).  So I munged that.

Maybe there's a suitably wishy-washy Episcopalian middle ground whereby one could forget whether a =?> is expected and just use a pattern, and scalac will desugar it correctly.

Future(expr) onSuccess (MyResult(x,y) => println(x * y))

to mean

f onSuccess { case MyResult(x,y) => println(x * y) }

Meanwhile, I've kind of forgotten if it was desugared to a partial or complete function.

Do I care?  We, pardon the expression, dumb people, don't really.  Though after we've finished working the crossword puzzle in pencil, we might enjoy figuring that out.

To return to the original example,

f onSuccess println

could maybe possibly fall back to

f onSuccess ((x => Option(g(x))).unlift)  // or whatever

I don't know that I typed enough parens there.

> I know why this doesn't work, but I'm not sure why it's not allowed.

I hope this slogan makes it onto a Scala fleece hoodie, medium, in "heather".

[√iktor Ҡlang]

I guess this is the old "why isn't Function1 a PartialFunction" discussion?

val pf: PartialFunction[Any, Unit] = { case _ => () } // Total?

val f: Function[Any, Unit] = _ => () // Total?

To which degree is one more "partial" than the other?

Cheers,

√

[Som Snytt]

Sorry, I was about to write, and somehow forgot through distraction:

...Apologies In Advance, I'm sure the smart people have hashed this over already.

But this lapse gives me the opportunity to propose another t-shirt:

"I'm partial to functions."