Skip to content

Commit

Permalink
docs: replace 'leaf types' with 'concrete types' (#56418)
Browse files Browse the repository at this point in the history 
Fixes #55044

---------

Co-authored-by: inkydragon <[email protected]>
  • Loading branch information
@fatteneder @inkydragon
fatteneder and inkydragon authored Nov 4, 2024
1 parent 0249feb commit 74640a1
Show file tree
Hide file tree
Showing 5 changed files with 21 additions and 21 deletions.
4 changes: 2 additions & 2 deletions base/reflection.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -15,7 +15,7 @@ yielded by expanding the generators.
The keyword `debuginfo` controls the amount of code metadata present in the output.
Note that an error will be thrown if `types` are not leaf types when `generated` is
Note that an error will be thrown if `types` are not concrete types when `generated` is
`true` and any of the corresponding methods are an `@generated` method.
"""
function code_lowered(@nospecialize(f), @nospecialize(t=Tuple); generated::Bool=true, debuginfo::Symbol=:default)
Expand All @@ -37,7 +37,7 @@ function code_lowered(@nospecialize(f), @nospecialize(t=Tuple); generated::Bool=
else
error("Could not expand generator for `@generated` method ", m, ". ",
"This can happen if the provided argument types (", t, ") are ",
"not leaf types, but the `generated` argument is `true`.")
"not concrete types, but the `generated` argument is `true`.")
end
else
code = uncompressed_ir(m.def::Method)
Expand Down
4 changes: 2 additions & 2 deletions base/runtime_internals.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -839,7 +839,7 @@ end
"""
isdispatchtuple(T)
Determine whether type `T` is a tuple "leaf type",
Determine whether type `T` is a tuple of concrete types,
meaning it could appear as a type signature in dispatch
and has no subtypes (or supertypes) which could appear in a call.
If `T` is not a type, then return `false`.
Expand Down Expand Up @@ -894,7 +894,7 @@ isconcretedispatch(@nospecialize t) = isconcretetype(t) && !iskindtype(t)
using Core: has_free_typevars

# equivalent to isa(v, Type) && isdispatchtuple(Tuple{v}) || v === Union{}
# and is thus perhaps most similar to the old (pre-1.0) `isleaftype` query
# and is thus perhaps most similar to the old (pre-1.0) `isconcretetype` query
function isdispatchelem(@nospecialize v)
return (v === Bottom) || (v === typeof(Bottom)) || isconcretedispatch(v) ||
(isType(v) && !has_free_typevars(v))
Expand Down
26 changes: 13 additions & 13 deletions doc/src/manual/calling-c-and-fortran-code.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -276,17 +276,17 @@ it to be freed prematurely.

First, let's review some relevant Julia type terminology:

| Syntax / Keyword | Example | Description |
|:----------------------------- |:------------------------------------------- |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `mutable struct` | `BitSet` | "Leaf Type" :: A group of related data that includes a type-tag, is managed by the Julia GC, and is defined by object-identity. The type parameters of a leaf type must be fully defined (no `TypeVars` are allowed) in order for the instance to be constructed. |
| `abstract type` | `Any`, `AbstractArray{T, N}`, `Complex{T}` | "Super Type" :: A super-type (not a leaf-type) that cannot be instantiated, but can be used to describe a group of types. |
| `T{A}` | `Vector{Int}` | "Type Parameter" :: A specialization of a type (typically used for dispatch or storage optimization). |
| | | "TypeVar" :: The `T` in the type parameter declaration is referred to as a TypeVar (short for type variable). |
| `primitive type` | `Int`, `Float64` | "Primitive Type" :: A type with no fields, but a size. It is stored and defined by-value. |
| `struct` | `Pair{Int, Int}` | "Struct" :: A type with all fields defined to be constant. It is defined by-value, and may be stored with a type-tag. |
| | `ComplexF64` (`isbits`) | "Is-Bits" :: A `primitive type`, or a `struct` type where all fields are other `isbits` types. It is defined by-value, and is stored without a type-tag. |
| `struct ...; end` | `nothing` | "Singleton" :: a Leaf Type or Struct with no fields. |
| `(...)` or `tuple(...)` | `(1, 2, 3)` | "Tuple" :: an immutable data-structure similar to an anonymous struct type, or a constant array. Represented as either an array or a struct. |
| Syntax / Keyword | Example | Description |
|:----------------------------- |:------------------------------------------- |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| `mutable struct` | `BitSet` | "Concrete Type" :: A group of related data that includes a type-tag, is managed by the Julia GC, and is defined by object-identity. The type parameters of a concrete type must be fully defined (no `TypeVars` are allowed) in order for the instance to be constructed. Also see [`isconcretetype`](@ref). |
| `abstract type` | `Any`, `AbstractArray{T, N}`, `Complex{T}` | "Super Type" :: A super-type (not a concrete type) that cannot be instantiated, but can be used to describe a group of types. Also see [`isabstracttype`](@ref). |
| `T{A}` | `Vector{Int}` | "Type Parameter" :: A specialization of a type (typically used for dispatch or storage optimization). |
| | | "TypeVar" :: The `T` in the type parameter declaration is referred to as a TypeVar (short for type variable). |
| `primitive type` | `Int`, `Float64` | "Primitive Type" :: A type with no fields, but a size. It is stored and defined by-value. |
| `struct` | `Pair{Int, Int}` | "Struct" :: A type with all fields defined to be constant. It is defined by-value, and may be stored with a type-tag. |
| | `ComplexF64` (`isbits`) | "Is-Bits" :: A `primitive type`, or a `struct` type where all fields are other `isbits` types. It is defined by-value, and is stored without a type-tag. |
| `struct ...; end` | `nothing` | "Singleton" :: a concrete Type or Struct with no fields. |
| `(...)` or `tuple(...)` | `(1, 2, 3)` | "Tuple" :: an immutable data-structure similar to an anonymous struct type, or a constant array. Represented as either an array or a struct. |

### [Bits Types](@id man-bits-types)

Expand Down Expand Up @@ -626,7 +626,7 @@ For translating a C argument list to Julia:
* argument value will be copied (passed by value)
* `struct T` (including typedef to a struct)

* `T`, where `T` is a Julia leaf type
* `T`, where `T` is a concrete Julia type
* argument value will be copied (passed by value)
* `void*`

Expand Down Expand Up @@ -679,7 +679,7 @@ For translating a C return type to Julia:
* argument value will be copied (returned by-value)
* `struct T` (including typedef to a struct)

* `T`, where `T` is a Julia Leaf Type
* `T`, where `T` is a concrete Julia Type
* argument value will be copied (returned by-value)
* `void*`

Expand Down
4 changes: 2 additions & 2 deletions doc/src/manual/performance-tips.md
View file
Original file line number Diff line number Diff line change
Expand Up @@ -805,7 +805,7 @@ or `nothing` if it is not found, a clear type instability. In order to make it e
type instabilities that are likely to be important, `Union`s containing either `missing` or `nothing`
are color highlighted in yellow, instead of red.

The following examples may help you interpret expressions marked as containing non-leaf types:
The following examples may help you interpret expressions marked as containing non-concrete types:

* Function body starting with `Body::Union{T1,T2})`
* Interpretation: function with unstable return type
Expand All @@ -821,7 +821,7 @@ The following examples may help you interpret expressions marked as containing n
element accesses

* `Base.getfield(%%x, :(:data))::Array{Float64,N} where N`
* Interpretation: getting a field that is of non-leaf type. In this case, the type of `x`, say `ArrayContainer`, had a
* Interpretation: getting a field that is of non-concrete type. In this case, the type of `x`, say `ArrayContainer`, had a
field `data::Array{T}`. But `Array` needs the dimension `N`, too, to be a concrete type.
* Suggestion: use concrete types like `Array{T,3}` or `Array{T,N}`, where `N` is now a parameter
of `ArrayContainer`
Expand Down
4 changes: 2 additions & 2 deletions stdlib/InteractiveUtils/src/codeview.jl
View file
Original file line number Diff line number Diff line change
Expand Up @@ -128,10 +128,10 @@ end
Prints lowered and type-inferred ASTs for the methods matching the given generic function
and type signature to `io` which defaults to `stdout`. The ASTs are annotated in such a way
as to cause "non-leaf" types which may be problematic for performance to be emphasized
as to cause non-concrete types which may be problematic for performance to be emphasized
(if color is available, displayed in red). This serves as a warning of potential type instability.
Not all non-leaf types are particularly problematic for performance, and the performance
Not all non-concrete types are particularly problematic for performance, and the performance
characteristics of a particular type is an implementation detail of the compiler.
`code_warntype` will err on the side of coloring types red if they might be a performance
concern, so some types may be colored red even if they do not impact performance.
Expand Down

0 comments on commit 74640a1

Please sign in to comment.