I am trying to schedule a message to be sent after a period of time - a simple retry.

```
override def receive = {
  case Worked => ???
  case DidNotWork => 
    val target = sender() // Avoid closing over sender().
    import context._
    context.system.scheduler.scheduleOnce(500.milliseconds, target, TryAgain)
}

```

This works as expected, however, when I receive the `TryAgain` message, and access `sender()` to try and get this `ActorRef` to this object, I get `DeadLetters`. Why is this happening?

(Note that the problem is the `sender()` call in the other actor, which is not in a closure - this is not a problem where I'm closing over `sender()`):

```
override def receive = {
  case TryOnce => sender() ! DidNotWork
  case TryAgain => sender() ! Worked // sender() here is DeadLetters!
}

```

Complete example (in response to [cmbaxter's comment](https://stackoverflow.com/questions/24958369/why-is-my-sender-deadletters-from-a-scheduled-message/24958370#comment38800597_24958370)):

```
import akka.actor.{Props, ActorSystem, Actor}
import scala.concurrent.duration._

object Main {
  def main(args: Array[String]) {
    val sys = ActorSystem("Test")
    val test = sys.actorOf(Props[Test], "test-actor")
    test ! "badtest"
    test ! "goodtest"
  }
}

class Test extends Actor {
  override def receive = {
    case "badtest" =>
      import context._
      context.system.scheduler.scheduleOnce(10.milliseconds, this.self, "bad")
    case "goodtest" =>
      import context.dispatcher
      context.system.scheduler.scheduleOnce(10.milliseconds, this.self, "good")
    case other => println(s"$sender $other")
  }
}

```

Which produces:

```
Actor[akka://Test/deadLetters] bad
Actor[akka://Test/user/test-actor#621986067] good

```