Simplifying Value Constraints in Swift with the Clamped Property Wrapper

In Swift development, ensuring that a variable stays within a specific range is a common requirement. Handling these constraints manually can lead to repetitive code and potential errors. Fortunately, Swift's property wrappers offer a clean and reusable solution for such tasks. In this article, we'll explore a custom property wrapper called @Clamped that automatically clamps a value within a defined range.

Introducing the @Clamped Property Wrapper

The @Clamped property wrapper is designed to ensure that a value remains within a specified range. This wrapper is particularly useful for scenarios where you want to guarantee that a variable, such as a user input or a configuration setting, does not exceed predefined limits.

Here's the implementation of the @Clamped property wrapper:

@propertyWrapper

struct Clamped<Value: Comparable> {

    private var value: Value
    private let range: ClosedRange<Value>

    init(wrappedValue: Value, _ range: ClosedRange<Value>) {
        self.range = range
        self.value = Self.clamp(wrappedValue, to: range)
    }

    var wrappedValue: Value {
        get { value }
        set { value = Self.clamp(newValue, to: range) }
    }

    private static func clamp(_ value: Value, to range: ClosedRange<Value>) -> Value {
        return min(max(value, range.lowerBound), range.upperBound)
    }

}        

In this implementation:

• Clamped is a generic struct constrained to types that conform to Comparable.

• The initialiser takes an initial value and a range, clamping the initial value to the range.

• The wrappedValue property uses a getter and setter to manage the clamping logic.

Using the @Clamped Wrapper

With the @Clamped wrapper implemented, using it in your code is straightforward. Let's see it in action with a simple example:

struct Example {
    @Clamped(wrappedValue: 5, 0...10) var number: Int
}

var example = Example()

print(example.number) // Output: 5

example.number = 15

print(example.number) // Output: 10 (clamped to the upper bound of the range)

example.number = -5

print(example.number) // Output: 0 (clamped to the lower bound of the range)        

In this example:

• The number property in the Example struct is initialised with a value of 5 and is constrained to the range 0 to 10.
• Any assignments to number that fall outside this range are automatically clamped. Setting number to 15 clamps it to 10, and setting it to -5 clamps it to 0.

Benefits of the @Clamped Wrapper

The @Clamped wrapper offers several benefits:

1. Code Reusability: Encapsulating the clamping logic within a property wrapper reduces code duplication.

2. Improved Readability: Using @Clamped makes it clear that a property should stay within a specified range, enhancing code readability.

3. Enhanced Safety: Automatic clamping helps prevent bugs related to out-of-bound values, ensuring data integrity.