API glossary
What the kind, modifier, and package labels in the API reference mean, with language-specific distinctions. Select an annotation or full API badge to open its definition here.
The signature and entry documentation describe the API’s behavior. A shared label does not imply identical calling conventions, storage, or runtime checks across languages.
Symbol kinds
Kinds identify the declaration being documented. Some categories group equivalent language constructs under one label.
module
A named scope that groups related declarations for lookup or import.
A module can be a Python file, a Julia namespace, or an F# grouping. The label alone does not identify an installable package.
References: Python modules .
class
A type that groups data and behavior, often with inheritance.
The reference uses this category for class declarations and for Julia abstract types. Check the signature and abstract modifier before assuming a type can be constructed.
References: Python classes ; Julia types .
interface
A contract describing the members or behavior a conforming type must provide.
This category also includes Swift protocols. Conformance rules differ by language: Go interfaces are satisfied implicitly, while other languages can require a declared relationship.
References: Go interface types ; Swift protocols .
struct
A structured type that groups fields and can expose operations on them.
Copying, mutation, and inheritance follow the language. A C++ struct is a class with different default access; Julia distinguishes struct from mutable struct. This badge does not promise immutability.
References: C++ class declarations ; Julia composite types .
union
A type that represents alternative forms of a value.
An F# discriminated union has named cases, which can carry data. A C++ union shares storage between members and has rules about which member is active. These have different representation and access rules.
References: F# discriminated unions ; C++ unions .
enum
A type with named values or variants.
C# enum members name integral values. Rust enum variants can also carry fields. Read the declaration to see which form is used.
References: C# enumeration types ; Rust enumerations .
trait
A named set of behavior that types can implement.
Rust traits can declare methods, associated types, and associated constants, with default implementations where the language permits them.
References: Rust traits .
function
A callable operation documented at module or language scope.
A PowerShell function is implemented in the scripting language; an advanced function can support cmdlet-style parameter binding and pipelines. Julia functions can have multiple methods selected by argument types.
References: PowerShell advanced functions ; Julia methods .
method
A callable member associated with a type or object.
An instance method works with an instance. Static and class methods use different binding rules, shown by their modifiers. Julia uses method to mean an implementation of a generic function for particular argument types.
References: Python method objects ; Julia methods .
property
A named value accessed through an object or type, potentially through a getter or setter.
The reference also uses this category for some extracted fields, including Julia fields. Reading a property can execute code; the badge alone does not establish whether it is writable or stored.
References: C# properties ; Julia composite types .
attribute
A named data attribute or field of an object or type.
On these pages, attribute describes member data. .NET attributes that attach metadata to declarations are a separate language feature.
References: Python class and instance attributes .
constant
A named value or binding intended to remain fixed.
Enforcement depends on the language. A constant binding does not necessarily make the referenced object immutable or require the value to be known at compile time.
References: Julia constants .
typealias
A name for an existing type or type expression.
An alias can make a compound type easier to name. It does not by itself introduce a distinct runtime class.
References: TypeScript type aliases .
exception
A type used to report an error through the language’s exception mechanism.
The API documentation states when it can be raised or thrown and what a caller can catch. The label does not imply that every failure uses exceptions.
References: Python exceptions .
cmdlet
A compiled .NET command invoked through PowerShell’s command and object-pipeline system.
This label records PowerShell’s Cmdlet command type. Advanced script functions can offer similar parameter and pipeline features while retaining the Function command type. A cmdlet is not a standalone executable.
References: PowerShell cmdlet overview ; PowerShell advanced functions .
Modifiers
Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.
static
A member associated with a type rather than bound to a particular instance.
A Python staticmethod receives neither an implicit instance nor an implicit class argument. A classmethod receives the class. Static does not mean pure, immutable, or safe for concurrent calls.
References: C# static members ; Python staticmethod .
macro
A declaration expanded by a language’s macro mechanism rather than called as an ordinary function.
Julia macros transform expressions. C and C++ preprocessor macros operate on tokens. Expansion rules, evaluation, and invocation syntax differ.
References: Julia macros ; C++ macro replacement .
classmethod
A Python method that receives the calling class as its implicit first argument.
It can be called through a class or an instance. A call through a subclass passes that subclass, which is useful for constructors that preserve the requested type.
References: Python classmethod .
abstract
A type or member whose complete implementation is supplied by a concrete subtype.
An abstract type cannot be constructed directly. An abstract member declares required behavior. Julia abstract types define a place in the type hierarchy rather than a concrete data layout.
References: C# abstract declarations ; Julia abstract types .
async
An operation that participates in the language’s asynchronous or suspending execution model.
Use the await or coroutine mechanism required by the signature. Python async functions, .NET task-returning methods, and Kotlin suspend functions have different invocation rules. This label does not promise a new thread or parallel execution.
References: Python coroutine functions ; C# async methods ; Kotlin coroutines .
readonly
A declaration with restrictions on assignment or mutation through the documented member.
The exact restriction depends on the language and declaration. The C++ extractor also uses this label for const-qualified methods. A read-only field or reference does not necessarily make the object it refers to deeply immutable.
References: C# readonly ; C++ cv-qualification .
deprecated
An API marked as discouraged for new use by its source documentation or language metadata.
Read the entry for its replacement and any removal schedule. Deprecation alone does not mean the API is absent or that calling it always emits a warning.
References: Python warning categories .
overload
An operation documented with more than one accepted signature.
The numbered badge reports the signatures shown by the reference. Python typing overloads describe one implementation to a type checker; other languages can select separate implementations. The badge does not define a common dispatch rule.
References: Python typing overloads ; Julia method dispatch .
private
A declaration whose intended or enforced accessibility is restricted.
The restriction may be a naming convention, a type-checking rule, or a runtime access rule. For example, TypeScript private and JavaScript #private have different enforcement. The badge alone is not a security boundary.
References: TypeScript private members .
generator
A callable that produces a generator or iterator, yielding values as iteration advances.
For a Python generator function, calling it creates the generator; iteration runs the body until the next yield. Reading every value can therefore execute work or raise errors later than the initial call.
References: Python generators .
unsafe
A Rust declaration that carries safety obligations the compiler cannot fully check.
For an unsafe function, the caller must uphold the documented invariants. For an unsafe trait, implementers must uphold its contract. Read the entry’s safety requirements before using or implementing it.
References: Rust unsafe .
inherited
A member available on a type through a declaration supplied by a base type.
The reference identifies the declaring type. Follow that declaration for its signature and documentation; inheritance and overriding rules depend on the language.
References: Python inheritance .
Package context
Package labels identify where an API is supplied.
package
The library package that supplies the documented declaration.
The badge displays the package’s name rather than the word package. Package, import, module, and namespace names can differ; use the port’s installation and import instructions.
References: Python distribution and import packages .