How to denote an inner singleton in Scala - scala

Question

To exercise my OOP abilities on Scala-specific features, I have tried to design a game where I have a Player class. It has an abstract method play which decides, given a list of players (different from the player the method is called on), what action to take. I wanted to prevent the play method to alter the state of this other players. The right way to play is to cast a Spell and let the system reflect its effect on other players.
Yet, the play method needs read access to the other players to decide a strategy. I have thus created an inner singleton ReadOnlyPlayer. I made it a singleton to prevent copying over and over and simply returning this singleton everytime.
abstract class Player(private var _health: Int = 0) {
Check.isPositive(_health)
def health = _health
def play(players: List[/*?*/]) // how to denote inner type ReadOnlyPlayer ?
def hit(damage: Int) = { _health = max(0, _health - damage); this }
def safeCopy = ReadOnlyPlayer
final object ReadOnlyPlayer extends Player {
override def health = _health
// noop
override def hit (damage: Int ) = this
override def play(players: List[/*?*/]) = ()
}
}
I can't get it to compile because of the line I put a comment on. I am aware of a number of workarounds to this issue :
if it was a class instead of a singleton, I could use Player#ReadOnlyPlayer. I tried, it works fine. However, this requires to create a new copy everytime, so if I wanted to do this it would actually be better to create a separate immutable class.
I could manually implement a singleton pattern and always return the same instance of this class.
I could make the class private and only declare Player, but I want my clients to know they explicitly know they won't be able to modify the Player instance. I can do this using an sealed empty trait with a meaningful name.
I know how I can handle this in various ways, so my question is more out of curiosity : how can one denote an inner singleton type ?

Answer 1

Note that I'm answering without fully understanding what you're trying to do making a list of inner singletons.
Typically the type of a singleton is accessed by using SingletonName.type. So, in your case, it would look like this:
abstract class Player(private var _health: Int = 0) {
def health = _health
def play(players: List[ReadOnlyPlayer.type]) = ()// how to denote inner type ReadOnlyPlayer ?
def hit(damage: Int) = { _health = Math.max(0, _health - damage); this }
def safeCopy = ReadOnlyPlayer
final object ReadOnlyPlayer extends Player {
override def health = _health
// noop
override def hit (damage: Int ) = this
override def play(players: List[ReadOnlyPlayer.type]) = ()
}
}

Answer 2

As #lloydme pointed it, what I was trying to achieve didn't really make sense. Here is the solution I finally opted for :
sealed trait ReadOnlyPlayer extends Player
abstract class Player(private var _health: Int = 0) {
Check.isPositive(_health)
def health = _health
def play(players: List[ReadOnlyPlayer])
def hit(damage: Int) = { _health = max(0, _health - damage); this }
lazy val safeCopy: ReadOnlyPlayer = ReadOnlyCopy
private object ReadOnlyCopy extends ReadOnlyPlayer {
override def health = _health
// noop
override def hit (damage: Int) = this
override def play(players: List[ReadOnlyPlayer]) = ()
}
}

Answer 3

A list of nested objects:
$ scala
Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_60).
Type in expressions to have them evaluated.
Type :help for more information.
scala> class X(id: Int) { object Y { def y = id } }
defined class X
scala> val xs = List.tabulate(10)(new X(_))
xs: List[X] = List(X#5f77d0f9, X#463fd068, X#895e367, X#1b266842, X#7a3793c7, X#42b3b079, X#651aed93, X#4dd6fd0a, X#bb9e6dc, X#5456afaa)
scala> val Ys = xs map (_.Y)
Ys: List[x$1.Y.type forSome { val x$1: X }] = List(X$Y$#43c67247, X$Y$#fac80, X$Y$#726386ed, X$Y$#649f2009, X$Y$#14bb2297, X$Y$#69adf72c, X$Y$#797501a, X$Y$#1a15b789, X$Y$#57f791c6, X$Y$#51650883)
scala> val ys = Ys map (_.y)
ys: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)