Student Grading System

Process a list of students with optional marks and produce grade summaries using guard let and enums.

OptionalsEnumsFunctions

Overview

Not every student has been graded yet, and Swift has a specific, type-checked way to represent "this value might genuinely not exist": the Optional. A Student whose marks field is typed Int? instead of plain Int is not a workaround — it is the compiler forcing every piece of code that reads marks to explicitly decide what "no marks yet" means for that particular operation, rather than smuggling a sentinel value like -1 through the program and hoping every reader remembers what it means.

By the end of this tutorial you will have a console application that stores a roster of Student values with optional marks, an enum Grade that turns a numeric score into a closed set of letter grades, and a report generator that safely unwraps every optional along the way — using guard let to handle the "ungraded" case early, and compactMap to compute a class average over only the students who actually have a score.

What You'll Build

A Student struct with a genuinely optional marks: Int? field.
A Grade enum with raw String values mapping scores to letter grades.
A gradeForMarks(_:) function using a switch over numeric ranges.
A summary(for:) function that uses guard let to handle ungraded students.
A classAverage(_:) function using compactMap and reduce to average only recorded scores.
A readLine()-driven menu loop for adding students and generating the report.

Prerequisites

Structs — stored properties, let vs. var, and struct initializers.
Optionals — Int?, guard let, if let, and nil-coalescing with ??.
Enums — enum cases and raw values (enum Grade: String).
Functions — parameters, return types, and calling one function from another.
Collection basics — Array, for-in, and passing an [Student] into a function.

Project Structure

The program lives in a single file, main.swift. Student is a plain data struct with no behavior of its own. Grade is a raw-value enum — a closed, compiler-checked set of the only letter grades that can ever exist in this program, which rules out an entire category of bugs a plain String field could introduce (typos like "Aplus" simply cannot compile as a Grade case). gradeForMarks(_:), summary(for:), classAverage(_:), and printReport(_:) are free functions — none of them need to be methods on Student, because none of them depend on any single instance's private state; they each just take the data they need as a parameter and return a result.

Step 1: Define the Student Struct With Optional Marks

marks is typed Int?, not Int, because nil here does not mean zero — it means this student has not been graded yet. Modeling the "ungraded" state as a real Optional, instead of a magic number, is what forces the rest of the program to handle it explicitly instead of accidentally treating an ungraded student as having scored 0.

// marks is a genuine Optional here — nil doesn't mean "zero," it means "this
// student hasn't been graded yet." Modeling that as Int? instead of using a
// sentinel value like -1 is what forces every piece of code that reads marks
// to explicitly decide what "ungraded" means for that operation.
struct Student {
    let name: String
    let marks: Int?   // nil = not yet graded; 0...100 = an actual recorded score
}

Step 2: Define the Grade Enum

A raw-value enum gives each case a fixed underlying value — here, a String — that can be read back with .rawValue, which is exactly what a display label needs. Using an enum instead of a plain String field makes "what are the valid grades" a closed set the compiler checks, rather than an open-ended collection of string literals that could drift or typo anywhere they are used.

// A raw-value enum: each case carries a fixed String ("A+", "A", ...) read
// back with .rawValue. An enum is the right tool here instead of a plain
// String, because it makes "what are the valid grades" a closed,
// compiler-checked set instead of an open-ended set of magic strings.
enum Grade: String {
    case aPlus = "A+"
    case a = "A"
    case b = "B"
    case c = "C"
    case fail = "Fail"
}

Step 3: Map a Score to a Grade

gradeForMarks(_:) is a free function, not a method on anything, because it has no dependency on instance state — it just takes a score and returns a Grade. Swift's switch supports matching against numeric ranges directly: 90...100 is a closed range including both endpoints, while 75..<90 is a half-open range that excludes 90, which is exactly what is needed so the boundaries between grades never overlap or leave a gap.

// A plain function: it takes a score and returns a Grade with no side
// effects and no dependency on any instance state, so it has no reason to
// live on Student or Grade as a method.
func gradeForMarks(_ marks: Int) -> Grade {
    switch marks {
    case 90...100: return .aPlus   // Closed range: 90 through 100 inclusive
    case 75..<90: return .a         // Half-open range: 75 up to (not including) 90
    case 60..<75: return .b
    case 40..<60: return .c
    default: return .fail            // Anything else, including an invalid score below 0, counts as a fail
    }
}

Example Usage

Click Run to see what this code prints.

Step 4: Summarize One Student With guard let

guard let is preferred here over if let because the "no marks" case is the exceptional path that should return its own message immediately — everything after the guard statement can then safely assume marks is a real, unwrapped Int, with no further nil-checking needed for the rest of the function.

// guard let is preferred over if let here because the "no marks" case is the
// exceptional path that should exit early with its own message — the rest of
// the function can then safely assume marks is a real, unwrapped Int.
func summary(for student: Student) -> String {
    guard let marks = student.marks else {
        return "\(student.name): No marks recorded yet"
    }
    let grade = gradeForMarks(marks)
    return "\(student.name): \(marks)/100 -> Grade \(grade.rawValue)"
}

Step 5: Compute the Class Average With compactMap

compactMap runs its closure over every element and keeps only the results that are not nil, unwrapping them in the same step — "give me every marks value that actually exists" in one line, instead of a manual loop with an if let and an accumulator array. reduce(0, +) then folds that array of unwrapped scores down into a single sum before dividing by the count.

// compactMap runs the closure over every element and keeps only the non-nil
// results, unwrapping them in the process — exactly "give me every marks
// value that actually exists," in one line instead of a manual loop with an
// if-let and an accumulator array.
func classAverage(_ students: [Student]) -> Double {
    let recorded = students.compactMap { $0.marks }
    guard !recorded.isEmpty else { return 0 }   // Avoid dividing by zero when nobody has been graded yet
    let total = recorded.reduce(0, +)            // reduce folds the array into a single sum
    return Double(total) / Double(recorded.count)
}

func printReport(_ students: [Student]) {
    print("\n--- Grade Report ---")
    for student in students {
        print(summary(for: student))
    }
    let average = classAverage(students)
    print(String(format: "Class average (graded students only): %.1f", average))
}

Step 6: Build the Menu Loop

When adding a student, an empty or unreadable marks line is turned into nil explicitly with a ternary, rather than trying (and failing) to parse it as a number — Int("") also returns nil, so both "left blank" and "typed something non-numeric" naturally collapse into the same "not graded yet" state that Student.marks already models.

var students: [Student] = []
var running = true

while running {
    print("""

    ===== STUDENT GRADING SYSTEM =====
    1. Add Student
    2. Generate Report
    3. Exit
    """)
    print("Enter your choice: ", terminator: "")
    guard let choiceLine = readLine(), let choice = Int(choiceLine) else {
        print("Invalid input, try again.")
        continue
    }

    switch choice {
    case 1:
        print("Enter student name: ", terminator: "")
        let name = readLine() ?? "Unnamed Student"   // Nil-coalescing: a missing line still produces a usable student
        print("Enter marks, or leave blank if not graded yet: ", terminator: "")
        let marksLine = readLine() ?? ""
        // Int("") returns nil, and so does Int() on anything non-numeric — both
        // naturally become "not graded yet" with no extra special-casing needed.
        let marks = marksLine.isEmpty ? nil : Int(marksLine)
        students.append(Student(name: name, marks: marks))
        print("Student added.")
    case 2:
        printReport(students)
    case 3:
        print("Goodbye!")
        running = false
    default:
        print("Invalid choice, try again.")
    }
}

Complete Code

Here is the full program assembled in the correct order, ready to save as main.swift and run with swift main.swift, or paste into a Swift Playground.

struct Student {
    let name: String
    let marks: Int?
}

enum Grade: String {
    case aPlus = "A+"
    case a = "A"
    case b = "B"
    case c = "C"
    case fail = "Fail"
}

func gradeForMarks(_ marks: Int) -> Grade {
    switch marks {
    case 90...100: return .aPlus
    case 75..<90: return .a
    case 60..<75: return .b
    case 40..<60: return .c
    default: return .fail
    }
}

func summary(for student: Student) -> String {
    guard let marks = student.marks else {
        return "\(student.name): No marks recorded yet"
    }
    let grade = gradeForMarks(marks)
    return "\(student.name): \(marks)/100 -> Grade \(grade.rawValue)"
}

func classAverage(_ students: [Student]) -> Double {
    let recorded = students.compactMap { $0.marks }
    guard !recorded.isEmpty else { return 0 }
    let total = recorded.reduce(0, +)
    return Double(total) / Double(recorded.count)
}

func printReport(_ students: [Student]) {
    print("\n--- Grade Report ---")
    for student in students {
        print(summary(for: student))
    }
    let average = classAverage(students)
    print(String(format: "Class average (graded students only): %.1f", average))
}

var students: [Student] = []
var running = true

while running {
    print("""

    ===== STUDENT GRADING SYSTEM =====
    1. Add Student
    2. Generate Report
    3. Exit
    """)
    print("Enter your choice: ", terminator: "")
    guard let choiceLine = readLine(), let choice = Int(choiceLine) else {
        print("Invalid input, try again.")
        continue
    }

    switch choice {
    case 1:
        print("Enter student name: ", terminator: "")
        let name = readLine() ?? "Unnamed Student"
        print("Enter marks, or leave blank if not graded yet: ", terminator: "")
        let marksLine = readLine() ?? ""
        let marks = marksLine.isEmpty ? nil : Int(marksLine)
        students.append(Student(name: name, marks: marks))
        print("Student added.")
    case 2:
        printReport(students)
    case 3:
        print("Goodbye!")
        running = false
    default:
        print("Invalid choice, try again.")
    }
}

Sample Run

Click Run to see what this code prints.

Extend This Project

Add a Subject enum and track per-subject marks in a [Subject: Int] dictionary instead of one overall score.
Add a retest(name:newMarks:) function that replaces a student's marks and re-runs the report.
Persist the roster to a JSON file with Codable so grades survive between runs.
Add a topStudent(_:) function using max(by:) over students with non-nil marks.
Give Grade a computed var passing: Bool property and report a pass/fail count alongside the average.

Summary

You built a grading system where "no marks yet" is a real, type-checked state instead of a magic number, and guard let turns handling that state into an explicit early exit rather than a hidden edge case. The Grade enum kept every possible letter grade to a closed, compiler-verified set, and compactMap let the class average skip ungraded students without a single manual nil-check in the averaging logic itself. That combination — optionals for "might not exist," enums for "one of a fixed set," and small functions that lean on both — is the backbone of idiomatic Swift data processing.