Struct ModuleDepthMetrics 

pub struct ModuleDepthMetrics {
    pub module_name: String,
    pub pub_function_count: usize,
    pub pub_type_count: usize,
    pub total_pub_params: usize,
    pub generic_param_count: usize,
    pub trait_bound_count: usize,
    pub pub_const_count: usize,
    pub implementation_loc: usize,
    pub private_function_count: usize,
    pub private_type_count: usize,
    pub complexity_estimate: usize,
}

Metrics for measuring module depth (interface vs implementation complexity)

Fields

module_name: String

Module name/path

pub_function_count: usize

Number of public functions

pub_type_count: usize

Number of public types (structs, enums, traits)

total_pub_params: usize

Total parameters across all public functions

generic_param_count: usize

Number of generic type parameters in public API

trait_bound_count: usize

Number of trait bounds in public API

pub_const_count: usize

Number of public constants

implementation_loc: usize

Total lines of code (excluding comments/blanks)

private_function_count: usize

Number of private functions

private_type_count: usize

Number of private types

complexity_estimate: usize

Cyclomatic complexity estimate (branches, loops, etc.)

Implementations

impl ModuleDepthMetrics

pub fn new(module_name: String) -> Self

pub fn interface_complexity(&self) -> f64

Calculate interface complexity score

Higher score = more complex interface

pub fn implementation_complexity(&self) -> f64

Calculate implementation complexity score

Higher score = more complex implementation (hidden behind interface)

pub fn depth_ratio(&self) -> Option<f64>

Calculate module depth ratio

Depth = Implementation Complexity / Interface Complexity

• High ratio (> 5.0): Deep module (good - hides complexity)
• Low ratio (< 2.0): Shallow module (bad - interface as complex as implementation)

Returns None if interface complexity is 0

pub fn depth_classification(&self) -> ModuleDepthClass

Classify module depth

pub fn is_shallow(&self) -> bool

Check if this module is considered shallow (a red flag)

pub fn avg_params_per_function(&self) -> f64

Calculate average parameters per public function

Trait Implementations

impl Clone for ModuleDepthMetrics

fn clone(&self) -> ModuleDepthMetrics

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleDepthMetrics

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

Formats the value using the given formatter.

impl Default for ModuleDepthMetrics

fn default() -> ModuleDepthMetrics

Returns the “default value” for a type.