Julia

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

.jl

Registry names

julia

Recorded symbols

functions · macros · structs · modules

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

• overrides is declined on purpose, and the reason is the language's: Julia has multiple dispatch rather than overriding, so two methods with the same name and different signatures are both live and neither replaces the other. implements is declined for the same reason — struct S <: I is a type-hierarchy edge, not protocol conformance.
• A parameter's upper bound is not a supertype of the declared type. In struct Circle{T<:Real} <: Shape the bound hides inside the curly expression, and a walk that descends into it would report Circle <: Real, so the parameter list is treated as a wall and only the subtype edge written outside it is published.
• The grammar is the boundary: 177 of the 966 files in the pinned corpus carry ERROR nodes, measured at 1,947 in total with none missing. A macro that synthesises a name never appears as source, so it is invisible whatever the analyzer does.

Every line above was written against Julia’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 — .jl. Everything below is about where those files actually sit in a working repository.

• A Julia file is often a script with no module block — measured at 71.9% of a corpus sample — so top-level declarations carry an explicit global scope rather than an invented owner.
• Project.toml and Manifest.toml hold the dependency edge, not the source, so a package's reach is stated in metadata rather than in the files that use it.
• The scientific stack arrives through using and import at file scope, so one line at the top can pull a whole package into a file's reach.

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 types is this one a subtype of?
2. Which functions construct this type?
3. Which modules does this file import, and which names does it reach through?
4. Where is this C symbol called from, and which library is it in?

What the analyzer sees in code like this

abstract type Shape end              # bb records: interface Shape

struct Circle <: Shape              # bb records: class Circle · extends Shape
    radius::Float64                 # bb records: property radius
end

c = Circle(2.0)                    # bb records: instantiates Circle — Julia has no new()
typeof(c) === Circle               # bb records: references Circle

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
• Scala11 types
• Erlang9 types
• F#11 types
• Clean9 types
• Nim12 types
• MATLAB11 types
• Solidity11 types