Scala

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.scala, .sc, .sbt

Registry names

scala

Recorded symbols

classes · traits · methods · objects

Relationship types this analyzer constructs

11 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

11 constructed, 3 not constructed. All 3 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• Implicit conversions and the implicit search are not resolved, so a call that only type-checks through an implicit reads as an ordinary call and its argument conversion draws no edge.
• A qualified PascalCase call is never a construction: obj.Method() is a call, and only a receiver-less Type(...) is recorded as one, at a lower confidence — because in Scala 2 the qualified form is mostly module and enum-case access.
• Compiler-generated case-class members — copy, productElement, equals, hashCode, toString — and the enum ordinal are not materialized as symbols, because the compiler writes them rather than the programmer.

Every line above was written against Scala’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .scala, .sc, .sbt. Everything below is about where those files actually sit in a working repository.

• Scala 2 and Scala 3 share one surface, so a file may write implicit and implicit class or given and using depending on the build's source level.
• A case class publishes several symbols from one constructor — the class, its constructor and one property per parameter — so a model layer holds far more symbols than it has type names.
• Frameworks are recognised from the import root here, not from annotations: Play, Akka and Spring Boot are flagged, but no route is extracted the way the Java and Kotlin analyzers extract one.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which classes extend this trait?
2. Which method implements this abstract member?
3. Which extension method is declared for this receiver type?
4. Which types does this declaration derive from?

What the analyzer sees in code like this

class Column(val name: String) extends Base {   // bb records: class Column · extends Base
  def rename(to: String): Column = copy(name = to)   // bb records: method rename
}

trait Chargeable { def charge: Int }           // bb records: trait Chargeable

object Registry { val default = "column" }     // bb records: object Registry · default

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Functional & declarative — the count beside each name is how many relationship types that family’s analyzer constructs.

• Elixir10 types
• Clojure11 types
• Haskell12 types
• Erlang9 types
• F#11 types
• Clean9 types
• Nim12 types
• Julia11 types
• MATLAB11 types
• Solidity11 types