Structs as Parameter Objects in Rust: Simplifying Complex Function Signatures

Introduction and Overview

Welcome to the third lesson of our course, where we explore the concept of using structs as Parameter Objects to address a common code smell: complex function signatures in Rust. Throughout this course, we strive to eliminate code smells to enhance the readability, maintainability, and scalability of your codebase, with a strong emphasis on Test Driven Development (TDD) using Rust's built-in testing capabilities. In our previous lessons, we addressed code smells such as duplicated code using the Extract Function technique to manage long functions. Today, we are focusing on the code smell associated with long parameter lists and how to effectively address it using Rust's structural capabilities. You will learn to leverage Rust structs to encapsulate related parameters and improve the clarity and usability of your functions. Mastering the TDD cycle — Red, Green, Refactor — will be crucial as we continue to refactor and improve your codebase in this lesson.

Why Long Parameter Lists are a Code Smell

Long parameter lists are considered a code smell because they complicate function signatures, making the code harder to read, maintain, and test. This complexity arises from several issues: Readability : When a function has too many parameters, it becomes challenging to understand each parameter's purpose without referring to documentation or the function's implementation. This clutter makes the code less intuitive. Maintainability : Modifying a function with a long parameter list becomes cumbersome. Adding or removing parameters can introduce errors in existing function calls throughout the codebase, increasing the risk of bugs. Error-Prone : Parameters can easily be mixed up or misordered, especially when they have similar types. Even with type-checking, logical errors can occur if parameters are passed incorrectly. Testing Challenges : Long parameter lists complicate writing and maintaining tests, as test cases need to supply many arguments. This complexity can lead to brittle tests that are more challenging to maintain. Lack of Cohesion : Long parameter lists might indicate unrelated parameters or a function that needs to do too much, violating the single responsibility principle. By recognizing long parameter lists as a code smell and refactoring them into structs as Parameter Objects, we can improve code maintainability and readability, making it more robust and easier to understand.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rust

struct ExamResult {
    final_score: f64,
}

fn process_exam_score(
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    is_retake: bool,
    course_code: &str,
) -> ExamResult {
    // Function implementation...
}

struct ExamResult {
    final_score: f64,
}

fn process_exam_score(
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    is_retake: bool,
    course_code: &str,
) -> ExamResult {
    // Function implementation...
}

Rust

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        100.0,
        true,
        3,
        vec![],
        0.7,
        0.2,
        0.1,
        2,
        75.0,
        false,
        "MATH101",
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        100.0,
        true,
        3,
        vec![],
        0.7,
        0.2,
        0.1,
        2,
        75.0,
        false,
        "MATH101",
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

Rust

struct IndividualPerformance {
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    is_retake: bool,
}

struct ScoreWeights {
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
}

struct CoursePolicy {
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    retake_penalty_percentage: i32,
    missed_homework_penalty_percentage: i32,
}

fn process_exam_score_with_config(
    course_code: &str,
    performance: IndividualPerformance,
    score_weights: ScoreWeights,
    course_policy: CoursePolicy,
) -> ExamResult {
    // Logic...
}

fn process_exam_score(course_code: &str, performance: IndividualPerformance) -> ExamResult {
    process_exam_score_with_config(
        course_code,
        performance,
        default_score_weights(),
        default_course_policy(),
    )
}

struct IndividualPerformance {
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    is_retake: bool,
}

struct ScoreWeights {
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
}

struct CoursePolicy {
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    retake_penalty_percentage: i32,
    missed_homework_penalty_percentage: i32,
}

fn process_exam_score_with_config(
    course_code: &str,
    performance: IndividualPerformance,
    score_weights: ScoreWeights,
    course_policy: CoursePolicy,
) -> ExamResult {
    // Logic...
}

fn process_exam_score(course_code: &str, performance: IndividualPerformance) -> ExamResult {
    process_exam_score_with_config(
        course_code,
        performance,
        default_score_weights(),
        default_course_policy(),
    )
}

Rust

impl Default for ScoreWeights {
    fn default() -> Self {
        ScoreWeights {
            exam_weight: 0.7,
            homework_weight: 0.2,
            attendance_weight: 0.1,
        }
    }
}

impl Default for CoursePolicy {
    fn default() -> Self {
        CoursePolicy {
            bonus_points_per_activity: 2,
            passing_threshold: 75.0,
            retake_penalty_percentage: 5,
            missed_homework_penalty_percentage: 40,
        }
    }
}

impl IndividualPerformance {
    fn with_default_exam_score(exam_score: f64) -> Self {
        IndividualPerformance {
            exam_score,
            is_homework_complete: true,
            attendance_score: 3,
            bonus_activities: vec![],
            is_retake: false,
        }
    }
}

impl Default for ScoreWeights {
    fn default() -> Self {
        ScoreWeights {
            exam_weight: 0.7,
            homework_weight: 0.2,
            attendance_weight: 0.1,
        }
    }
}

impl Default for CoursePolicy {
    fn default() -> Self {
        CoursePolicy {
            bonus_points_per_activity: 2,
            passing_threshold: 75.0,
            retake_penalty_percentage: 5,
            missed_homework_penalty_percentage: 40,
        }
    }
}

impl IndividualPerformance {
    fn with_default_exam_score(exam_score: f64) -> Self {
        IndividualPerformance {
            exam_score,
            is_homework_complete: true,
            attendance_score: 3,
            bonus_activities: vec![],
            is_retake: false,
        }
    }
}

Rust

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        "MATH101",
        IndividualPerformance::with_default_exam_score(100.0),
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        "MATH101",
        IndividualPerformance::with_default_exam_score(100.0),
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

Rust

struct ExamResult {
    final_score: f64,
}

fn process_exam_score(
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    is_retake: bool,
    course_code: &str,
) -> ExamResult {
    // Function implementation...
}

Rust

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        100.0,
        true,
        3,
        vec![],
        0.7,
        0.2,
        0.1,
        2,
        75.0,
        false,
        "MATH101",
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

Rust

struct IndividualPerformance {
    exam_score: f64,
    is_homework_complete: bool,
    attendance_score: i32,
    bonus_activities: Vec<String>,
    is_retake: bool,
}

struct ScoreWeights {
    exam_weight: f64,
    homework_weight: f64,
    attendance_weight: f64,
}

struct CoursePolicy {
    bonus_points_per_activity: i32,
    passing_threshold: f64,
    retake_penalty_percentage: i32,
    missed_homework_penalty_percentage: i32,
}

fn process_exam_score_with_config(
    course_code: &str,
    performance: IndividualPerformance,
    score_weights: ScoreWeights,
    course_policy: CoursePolicy,
) -> ExamResult {
    // Logic...
}

fn process_exam_score(course_code: &str, performance: IndividualPerformance) -> ExamResult {
    process_exam_score_with_config(
        course_code,
        performance,
        default_score_weights(),
        default_course_policy(),
    )
}

Rust

impl Default for ScoreWeights {
    fn default() -> Self {
        ScoreWeights {
            exam_weight: 0.7,
            homework_weight: 0.2,
            attendance_weight: 0.1,
        }
    }
}

impl Default for CoursePolicy {
    fn default() -> Self {
        CoursePolicy {
            bonus_points_per_activity: 2,
            passing_threshold: 75.0,
            retake_penalty_percentage: 5,
            missed_homework_penalty_percentage: 40,
        }
    }
}

impl IndividualPerformance {
    fn with_default_exam_score(exam_score: f64) -> Self {
        IndividualPerformance {
            exam_score,
            is_homework_complete: true,
            attendance_score: 3,
            bonus_activities: vec![],
            is_retake: false,
        }
    }
}

Rust

#[test]
fn test_calculates_maximum_score_with_completed_homework() {
    // Act
    let result = process_exam_score(
        "MATH101",
        IndividualPerformance::with_default_exam_score(100.0),
    );

    // Assert
    assert_eq!(100.0, result.final_score);
}

Introduction and Overview

Why Long Parameter Lists are a Code Smell

Join the 1M+ learners on CodeSignal

Example: Long Parameter List

Confusing Tests

Refactor: Introduce Parameter Objects, Reorder, and Defaults

Provide defaults

Less Confusing Tests

Real-world Application

Summary and Practice Preparation