Struct TypeFact 

pub struct TypeFact {
    pub module: String,
    pub symbol: String,
    pub kind: TypeFactKind,
    pub signature: String,
    pub return_type: String,
}

A single type fact extracted from Python stubs.

This is the core data structure of the Sovereign Type Database. Each fact represents a symbol (function, class, method, attribute) with its full type signature.

Schema Rationale

• module: Fully qualified module path (e.g., “requests.api”)
• symbol: Symbol name (e.g., “get”)
• kind: Discriminant for symbol type
• signature: Full signature string for display/debugging
• return_type: Parsed return type for codegen integration

Fields

module: String

Fully qualified module path (e.g., “requests.api”)

symbol: String

Symbol name (e.g., “get”)

kind: TypeFactKind

The kind of symbol (function, class, method, attribute)

signature: String

Full signature string (e.g., “(url: str, params: dict = None) -> Response”)

return_type: String

Return type for functions/methods (e.g., “requests.models.Response”)

Implementations

impl TypeFact

pub fn function( module: &str, symbol: &str, signature: &str, return_type: &str, ) -> Self

Create a new TypeFact for a function.

pub fn class(module: &str, symbol: &str) -> Self

Create a new TypeFact for a class.

pub fn method( module: &str, class: &str, method: &str, signature: &str, return_type: &str, ) -> Self

Create a new TypeFact for a method.

pub fn fqn(&self) -> String

Get the fully qualified name of this symbol.

Trait Implementations

impl Clone for TypeFact

fn clone(&self) -> TypeFact

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TypeFact

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TypeFact

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for TypeFact

fn eq(&self, other: &TypeFact) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for TypeFact

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for TypeFact

impl StructuralPartialEq for TypeFact