Comment enquêter sur les objets/types / etc. de Scala REPL?

vous avez mentionné un point important qui manque un peu à Scala: la documentation.

Le REPL est un outil fantastique, mais il n'est pas fantastique, il peut être. Il y a trop de traits manquants et des traits qui peuvent être améliorés - certains d'entre eux sont mentionnés dans votre post. Scaladoc est un bel outil, aussi, mais est loin d'être parfait. De plus, beaucoup de code dans L'API n'est pas encore ou trop peu documenté et les exemples de code sont souvent absents. Les IDEs sont des insectes ob pleins et par rapport aux possibilités Java IDEs nous montrent qu'ils ressemblent à des jouets de maternelle.

néanmoins, il y a une différence énorme entre les outils courants de Scalas et les outils disponibles lorsque j'ai commencé à apprendre le Scala il y a 2-3 ans. A ce moment-là, IDEs a compilé de façon permanente quelques déchets à l'arrière-plan, le compilateur s'est écrasé toutes les quelques minutes et il n'y avait absolument aucune documentation. Souvent j'ai eu des attaques de rage et souhaité la mort et la corruption à Scala auteurs.

et maintenant? Je n'ai plus aucune de ces attaques de rage. Parce que les outils que nous avons actuellement sont grands, bien le ne sont pas parfaits!

il y a docs.scala-lang.org , qui résume beaucoup de grande documentation. Il y a des tutoriels, des fiches de tricherie, des glossaires, des Guides et beaucoup d'autres choses géniales. Un autre grand outil est Scalex , qui peut trouver même l'opérateur le plus étrange que l'on peut penser. C'est Scalas Hoogle et bien qu'il ne soit pas encore aussi bon que son grand idéal, il est très utile.

de grandes améliorations sont à venir avec Scala2.10 sous forme de Scalas propre bibliothèque de réflexion:

// needs Scala2.10M4
scala> import scala.reflect.runtime.{universe => u}
import scala.reflect.runtime.{universe=>u}

scala> val t = u.typeOf[List[_]]
t: reflect.runtime.universe.Type = List[Any]

scala> t.declarations
res10: Iterable[reflect.runtime.universe.Symbol] = SynchronizedOps(constructor List, method companion, method isEmpty, method head, method tail, method ::, method :::, method reverse_:::, method mapConserve, method ++, method +:, method toList, method take, method drop, method slice, method takeRight, method splitAt, method takeWhile, method dropWhile, method span, method reverse, method stringPrefix, method toStream, method removeDuplicates)

la Documentation pour la nouvelle bibliothèque de réflexion est toujours manquante, mais en cours. Il permet d'utiliser scalac d'une manière simple à l'intérieur de la REPL:

scala> u reify { List(1,2,3) map (_+1) }
res14: reflect.runtime.universe.Expr[List[Int]] = Expr[List[Int]](immutable.this.List.apply(1, 2, 3).map(((x) => x.$plus(1)))(immutable.this.List.canBuildFrom))

scala> import scala.tools.reflect.ToolBox
import scala.tools.reflect.ToolBox

scala> import scala.reflect.runtime.{currentMirror => m}
import scala.reflect.runtime.{currentMirror=>m}

scala> val tb = m.mkToolBox()
tb: scala.tools.reflect.ToolBox[reflect.runtime.universe.type] = scala.tools.reflect.ToolBoxFactory$ToolBoxImpl@32f7fa37

scala> tb.parseExpr("List(1,2,3) map (_+1)")
res16: tb.u.Tree = List(1, 2, 3).map(((x) => x.$plus(1)))

scala> tb.runExpr(res16)
res18: Any = List(2, 3, 4)

C'est encore plus quand nous voulons savoir comment le code Scala est traduit en interne. Auparavant, Wen doit taper scala -Xprint:typer -e "List(1,2,3) map (_+1)" pour obtenir la représentation interne. En outre, quelques petites améliorations ont trouvé place à la nouvelle version, par exemple:

scala> :type Predef
scala.Predef.type

Scaladoc gagnera quelques graphe de type-hiérarchie (cliquez sur Type-hiérarchie).

avec les Macros il est maintenant possible d'améliorer les messages d'erreur d'une grande manière. Il y a une bibliothèque appelée expecty , qui fait ceci:

// copied from GitHub page
import org.expecty.Expecty

case class Person(name: String = "Fred", age: Int = 42) {
  def say(words: String*) = words.mkString(" ")
}

val person = Person()
val expect = new Expecty()

// Passing expectations

expect {
  person.name == "Fred"
  person.age * 2 == 84
  person.say("Hi", "from", "Expecty!") == "Hi from Expecty!"
}

// Failing expectation

val word1 = "ping"
val word2 = "pong"

expect {
  person.say(word1, word2) == "pong pong"
}

/*
Output:

java.lang.AssertionError:

person.say(word1, word2) == "pong pong"
|      |   |      |      |
|      |   ping   pong   false
|      ping pong
Person(Fred,42)
*/

il y a un outil qui permet de trouver des bibliothèques hébergées sur GitHub, appelé ls.implicite.ly .

les IDEs ont maintenant une certaine mise en évidence sémantique, pour montrer si un membre est un objet/type/Méthode/n'importe quoi. La caractéristique de mise en évidence sémantique de ScalaIDE .

la fonctionnalité javap de la javap natif, donc ce n'est pas un outil très riche en fonctionnalités. Vous devez pleinement qualifier le nom d'un module:

scala> :javap scala.collection.immutable.List
Compiled from "List.scala"
public abstract class scala.collection.immutable.List extends scala.collection.AbstractSeq implements scala.collection.immutable.LinearSeq,scala.Product,scala.collection.LinearSeqOptimized{
...

Il ya quelque temps , j'ai écrit un résumé de la façon dont le code Scala est compilé en Bytecode , qui offre beaucoup de choses à savoir.

Et le meilleur: C'est tout à fait dans les derniers mois!

alors, comment utiliser toutes ces choses à l'intérieur de la RÉPL? Eh bien, il n'est pas possible ... pas encore de. ;)

mais je peux vous dire qu'un jour nous aurons une telle RÉPL. Une réponse qui nous montre la documentation si nous voulons la voir. Une réponse qui nous permet de communiquer avec elle (peut-être comme lambdabot ). Une réponse qui nous laisse faire des choses cool que nous ne pouvons toujours pas imaginer. Je ne sais pas quand ce sera le cas, mais je sais que beaucoup de choses ont été faites dans les dernières années et je sais même plus de choses seront faites dans les prochaines années.