0Pricing
Swift Academy · Lesson

Creating wrappers, projectedValue

Build a custom wrapper, configure wrappedValue , and surface metadata/helpers with projectedValue ( $ ).

Creating wrappers, projectedValue is a free Swift Academy lesson on CoddyKit — lesson 1 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Why property wrappers?

A property wrapper is a reusable type that manages how a property is stored/read:

  • wrappedValue: the public value
  • projectedValue: extra API via $
  • Config via initializers/arguments

Clamped + projected flag

@Clamped limits a number to a range. The projectedValue ($hp) tells if the last set was clamped.

@propertyWrapper
struct Clamped {
    private var value: Int
    private let range: ClosedRange<Int>
    private(set) var wasClampedLastSet = false

    var wrappedValue: Int {
        get { value }
        set {
            let clamped = min(max(newValue, range.lowerBound), range.upperBound)
            wasClampedLastSet = (clamped != newValue)
            value = clamped
        }
    }

    var projectedValue: Bool { wasClampedLastSet } // $prop -> was it clamped?

    init(wrappedValue: Int, range: ClosedRange<Int>) {
        self.range = range
        let clamped = min(max(wrappedValue, range.lowerBound), range.upperBound)
        self.value = clamped
        self.wasClampedLastSet = (clamped != wrappedValue)
    }
}

struct Player {
    @Clamped(range: 0...100) var hp: Int = 120  // init clamps to 100
}

var p = Player()
print(p.hp)     // 100
p.hp = -5
print(p.hp, p.$hp)  // 0 true (was clamped)

Normalize & alternate view

Wrappers can transform input (trim/lowercase). $property can expose a handy alternate form.

@propertyWrapper
struct Normalized {
    private var storage: String = ""
    var wrappedValue: String {
        get { storage }
        set { storage = newValue.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() }
    }
    var projectedValue: String { storage.uppercased() } // alternate view

    init(wrappedValue: String) { self.wrappedValue = wrappedValue }
}

struct User {
    @Normalized var username: String = "  Alice  "
}
let u = User()
print(u.username)   // "alice"
print(u.$username)  // "ALICE" (projected)

Configurable wrapper

Pass arguments to wrappers (e.g., length). The wrapper applies formatting every time you set the property.

@propertyWrapper
struct Padded {
    private var value: String
    private let length: Int
    var wrappedValue: String {
        get { value }
        set {
            let s = newValue
            value = s.count >= length ? String(s.prefix(length))
                                      : s + String(repeating: " ", count: length - s.count)
        }
    }
    var projectedValue: Int { value.count } // current width
    init(wrappedValue: String, length: Int) {
        self.length = length
        self.value = ""
        self.wrappedValue = wrappedValue
    }
}

struct Row {
    @Padded(length: 6) var code: String = "AB"
}
var r = Row()
print("|\(r.code)|")   // |AB    |
print(r.$code)        // 6

History via $value

Use projectedValue to expose metadata like a change history without cluttering the main value API.

@propertyWrapper
struct History<Value> {
    private var value: Value
    private(set) var changes: [Value] = []
    var wrappedValue: Value {
        get { value }
        set { changes.append(value); value = newValue }
    }
    var projectedValue: [Value] { changes } // $prop -> previous values
    init(wrappedValue: Value) { self.value = wrappedValue }
}

struct Settings {
    @History var level: Int = 1
}
var s = Settings()
s.level = 2
s.level = 3
print(s.level)    // 3
print(s.$level)   // [1, 2]

Design guidance

Tips:

  • Keep wrappers small and focused.
  • Document what $projectedValue exposes.
  • Prefer pure transformations; avoid heavy side effects.
  • Provide clear initializers and sensible defaults.

Projected value purpose

Quick check: What is $property used for in wrappers?

Recap

Recap: Implement @propertyWrapper with a wrappedValue; expose helpers/flags/history through projectedValue ($), and configure behavior via initializers.

Frequently asked questions

Is the “Creating wrappers, projectedValue” lesson free?

Yes — the full text of “Creating wrappers, projectedValue” is free to read here on the web, and the Swift Academy course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Swift Academy course, upgrade to CoddyKit PRO.

What will I learn in “Creating wrappers, projectedValue”?

Build a custom wrapper, configure wrappedValue , and surface metadata/helpers with projectedValue ( $ ). You practise Swift Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Swift Academy?

No prior experience is required. Swift Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Creating wrappers, projectedValue” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Swift Academy lesson?

Yes. Every Swift Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Creating wrappers, projectedValue
  2. Reusability and constraints
  3. Common wrappers patterns (validation, caching)
← Back to Swift Academy