Swift Memberwise Initializer

A memberwise initializer is a compiler-synthesized initialization method automatically provided for struct types in Swift. It allows instances to be initialized by passing values for the struct’s stored properties, matching their exact names and types, without requiring explicit initializer declarations.

Core Mechanics

When a struct is defined without any custom initializers, the Swift compiler inspects its stored properties and generates an init method. The parameters of this method directly correspond to the properties in the order they are declared.

struct Vector3D {
    var x: Double
    var y: Double
    var z: Double
}

// The compiler synthesizes the following:
// init(x: Double, y: Double, z: Double) {
//     self.x = x
//     self.y = y
//     self.z = z
// }

let vector = Vector3D(x: 1.0, y: 2.0, z: 3.0)

Rules for Synthesis

The generation of the memberwise initializer is governed by strict compiler rules regarding type, existing initializers, and property characteristics. 1. Type Restriction Memberwise initializers are exclusive to value types, specifically struct declarations. They are not synthesized for class or enum types. 2. Custom Initializer Suppression If a custom init block is defined directly within the primary body of the struct, the compiler suppresses the synthesis of the memberwise initializer.

struct User {
    var name: String
    
    // This explicit initializer prevents the synthesis of init(name:)
    init() {
        self.name = "Anonymous"
    }
}

3. The Extension Bypass To define custom initializers while retaining the compiler-generated memberwise initializer, the custom initializers must be declared inside an extension of the struct.

struct User {
    var name: String
}

extension User {
    init() {
        self.name = "Anonymous"
    }
}
// Both User(name: "Alice") and User() are now valid.

Property Mutability and Default Values

The signature of the synthesized initializer dynamically adjusts based on the mutability (let vs. var) and the presence of default values for the stored properties.

Uninitialized var or let: Becomes a required parameter in the initializer.
var with a default value: Becomes a parameter with a default argument, allowing it to be omitted during initialization.
let with a default value: Is completely excluded from the memberwise initializer signature, as constant properties with default values cannot be reassigned.

struct NetworkConfiguration {
    let endpoint: String           // Required parameter
    let protocolVersion = "HTTP/2" // Excluded from initializer
    var timeout: Int = 30          // Optional parameter (default argument)
    var retryCount: Int            // Required parameter
}

// The compiler synthesizes the following signature:
// init(endpoint: String, timeout: Int = 30, retryCount: Int)

let config = NetworkConfiguration(endpoint: "/api/v1", retryCount: 3)

Access Control Limitations

The access level of the synthesized memberwise initializer defaults to internal. However, it is subject to the following access control constraints:

Restrictive Inheritance: If any stored property has a more restrictive access level (e.g., private or fileprivate), the entire memberwise initializer inherits that restrictive access level.
Public Structs: If a struct is marked public, the synthesized memberwise initializer remains internal. To expose a memberwise initializer across module boundaries, a public init must be explicitly written by the developer.

Tired of Poor Swift Skills? Fix That With Deep Grasping!Learn More

Methods

Initializers

Closures

Type Declarations

Properties

Generics

Optional Binding

Patterns

Extensions

Error Handling

Attributes

Subscripts

Parameters

Constants & Variables

Conditionals

Loops

Collection Types

Basic Types

Numeric Types

Imports

Comments

Optional Operators

Arithmetic Operators

Overflow Operators

Assignment Operators

Bitwise Operators

Comparison Operators

Conditional Operators

Logical Operators

Range Operators

Type-Casting Operators

Swift Memberwise Initializer

Core Mechanics

Rules for Synthesis

Property Mutability and Default Values

Access Control Limitations

​Core Mechanics

​Rules for Synthesis

​Property Mutability and Default Values

​Access Control Limitations

Core Mechanics

Rules for Synthesis

Property Mutability and Default Values

Access Control Limitations