Les Options sont nommés et les arguments par défaut comme l'huile et l'eau dans une API Scala?

Voici une autre solution, en partie inspiré par Chris répondre. Elle implique aussi un wrapper, mais l'emballage est transparent, vous n'avez qu'à définir une fois, et l'utilisateur de l'API n'a pas besoin d'importer toutes les conversions:

class Opt[T] private (val option: Option[T])
object Opt {
   implicit def any2opt[T](t: T): Opt[T] = new Opt(Option(t)) //NOT Some(t)
   implicit def option2opt[T](o: Option[T]): Opt[T] = new Opt(o)
   implicit def opt2option[T](o: Opt[T]): Option[T] = o.option
}

case class Gather(finishOnKey: Char = '#', 
                  numDigits: Opt[Int] = None, //Infinite
                  callbackUrl: Opt[String] = None, 
                  timeout: Int = 5
                 ) extends Verb

//this works with no import
Gather(numDigits = 4, callbackUrl = "http://xxx")
//this works too
Gather(numDigits = 4, callbackUrl = Some("http://xxx"))
//you can even safely pass the return value of an unsafe Java method
Gather(callbackUrl = maybeNullString())

D'aborder plus largement la question du design, je ne pense pas que l'interaction entre les Options et nommé par défaut des paramètres est comme l'huile et l'eau, comme il pourrait sembler à première vue. Il y a une nette distinction entre un champ facultatif et l'autre avec une valeur par défaut. Un champ facultatif (c'est à dire un type Option[T]) pourrait jamais ont une valeur. Un champ avec une valeur par défaut, sur l'autre main, il suffit de ne pas exiger de sa valeur fournie en argument du constructeur. Ces deux notions sont donc orthogonaux, et il n'est pas surprenant qu'un champ peut être en option et ont une valeur par défaut.

Cela dit, je pense qu'un argument raisonnable peut être faite pour l'utilisation de Opt plutôt que Option pour de tels domaines, au-delà de sauvegarder le client saisie. Ainsi, l'API plus souple, dans le sens que vous pouvez remplacer une T argument avec un Opt[T] argument (ou vice-versa) sans casser les appelants du constructeur[1].

Comme pour l'utilisation d'un null valeur par défaut pour un champ public, je pense que c'est une mauvaise idée. "Vous" savez peut-être que vous vous attendez à une null, mais des clients qui accèdent à la zone peut pas. Même si le terrain est privé, à l'aide d'un null est d'avoir des ennuis sur la route quand d'autres développeurs ont à maintenir votre code. Tous les arguments habituels sur null valeurs entrent en jeu ici, je ne pense pas que ce cas d'utilisation est tout à fait exceptionnel.

[1] à Condition que vous retirez le option2opt de conversion de sorte que les appelants doivent passer un T chaque fois qu'un Opt[T] est nécessaire.

Personnellement, je pense que l'utilisation de 'null' comme valeur par défaut est parfaitement OK ici. L'utilisation de l'Option à la place de null, c'est quand vous voulez transmettre à vos clients que quelque chose ne peut pas être définie. Ainsi, une valeur de retour peut être déclaré Option[...], ou l'un des arguments de méthode pour des méthodes abstraites. Cela permet d'économiser le client à partir de la lecture de la documentation ou, plus probablement, d'obtenir des Npe parce que de ne pas réaliser quelque chose peut être null.

Dans votre cas, vous êtes conscient qu'une valeur null peut être là. Et si vous aimez Option de méthodes que nous venons de faire val optionalFallbackUrl = Option(fallbackUrl) au début de la méthode.

Cependant, cette approche ne fonctionne que pour les types de AnyRef. Si vous souhaitez utiliser la même technique pour tout type d'argument (sans qu'il en résulte Entier.MAX_VALUE de remplacement pour les nuls), alors je pense que vous devriez aller avec l'une des autres réponses

Pourrait je viens d'argumenter en faveur de votre approche actuelle, Some("callbackUrl")? Il est tout de plus de 6 caractères pour l'utilisateur API de type, leur indique que le paramètre est optionnel, et sans doute fait de la mise en œuvre plus facile pour vous.

J'ai également été surpris par cette. Pourquoi ne pas le généraliser à:

implicit def any2Option[T](x: T): Option[T] = Some(x)

Aucune raison pour que ne pouvait pas juste être une partie de Predef?