Swift Academy · Lesson

Projected Values with $binding

Exposing a projectedValue to provide additional functionality via $prefix.

Lesson 2 of 412 steps

Projected Values with $binding is a free Swift Academy lesson on CoddyKit. This is lesson 2 of 4. Any 3 lessons of this learning path are free to read in full — after that, CoddyKit PRO unlocks every lesson, plus hands-on practice with a built-in code editor and a 24/7 AI tutor. It is part of the Swift Academy learning path, and your progress syncs across the web and the CoddyKit app. The Swift Academy course includes 4 lessons in total.

Welcome

Projected values (accessed via `$`) give property wrappers a secondary interface — used by SwiftUI's `@State` and `@Published` to expose `Binding` and `Publisher`.

Adding projectedValue

```swift @propertyWrapper struct Toggle { var wrappedValue: Bool = false var projectedValue: String { wrappedValue ? "ON" : "OFF" } } struct Model { @Toggle var active } var m = Model() print(m.$active) // "OFF" — projected value accessed with $ ```

Type of projectedValue

The projected value can be any type — a `Binding`, a `Publisher`, a `String`, or a custom type. SwiftUI's `@State` projects a `Binding` that allows two-way data flow.

Binding Projection Example

```swift // @State projects Binding: @State var isOn = false Toggle(isOn: $isOn) // $isOn is Binding ```

Custom Binding Projection

```swift @propertyWrapper struct Validated { var wrappedValue: String var projectedValue: Bool { !wrappedValue.isEmpty } } struct Form { @Validated var email = "" } var f = Form() f.email = "hi@example.com" print(f.$email) // true — projected Bool ```

@Published Projection

```swift class VM: ObservableObject { @Published var score = 0 } let vm = VM() let cancellable = vm.$score // Publisher .sink { print("Score: \($0)") } vm.score = 10 // "Score: 10" ```

Accessing projectedValue Inside Wrapper

```swift @propertyWrapper struct History { private var current: T private(set) var projectedValue: [T] = [] var wrappedValue: T { get { current } set { projectedValue.append(current); current = newValue } } init(wrappedValue: T) { current = wrappedValue } } ```

Using the History Wrapper

```swift struct Counter { @History var count = 0 } var c = Counter() c.count = 1; c.count = 5; c.count = 3 print(c.$count) // [0,1,5] — history of old values ```

$ Syntax Disambiguation

```swift struct Form { @State var text = "" var body: some View { TextField("Enter", text: $text) // $text is Binding } } // text → String (wrappedValue) // $text → Binding (projectedValue) ```

Design Considerations

• `projectedValue` is optional — add only when a secondary interface is needed • The type can differ completely from `wrappedValue` • Use `$` at call site to access projected value • Projected values are great for Combine publishers and SwiftUI bindings

Quick Check

How do you access a property wrapper's `projectedValue`?

Answer it in the interactive lesson

Recap

Key takeaways: • `projectedValue` gives wrappers a secondary API via `$` • Can be any type — Binding, Publisher, Bool, Array • `@State` projects `Binding`; `@Published` projects `Publisher` • Access with `$propertyName` in both body and call site • Only add when a second interface adds real value Next: @Published and Combine.

Free to start

Learn Swift with an AI tutor — free

Write and run real code in your browser, get instant help from a 24/7 AI tutor, and pick up where you left off on the web or in the app.

Courses: 122
Lessons: 409

Start learning free View the full course

Frequently Asked Questions

Is the “Projected Values with $binding” lesson free?

Yes — any 3 lessons of the Swift Academy learning path, including “Projected Values with $binding”, are free to read in full here on the web. After that, CoddyKit PRO unlocks every lesson, plus interactive practice with a built-in code editor and a 24/7 AI tutor. The Swift Academy course includes 4 lessons in total.

What will I learn in “Projected Values with $binding”?

Exposing a projectedValue to provide additional functionality via $prefix. 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, so you can start here or from the beginning and move at your own pace. This is lesson 2 of 4.

How long does the “Projected Values with $binding” 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

← Back to Swift Academy