github/swift-style-guideArchived
Swift Style Guide
This project is a set of coding standards, architectural patterns, and type safety guidelines for writing Swift source code. It provides a framework for maintaining clean and maintainable code through established conventions and formatting rules.
The guide prioritizes composition over class inheritance by favoring value types and final classes. It establishes a policy for access control to manage boundaries between internal logic and external components through explicit visibility modifiers.
The standards cover type safety optimization through immutable bindings and safe optional handling. Additional areas include the use of early exit patterns to optimize logic flow, the reduction of syntax verbosity, and the application of uniform code formatting.
Features
- Swift Linting Standards - Establishes a comprehensive set of rule sets and standards to enforce consistent syntax and style in Swift.
- Immutable Variables - Prioritizes the use of constants over variables to prevent accidental state mutation and improve thread safety.
- Type Safety - Improves overall type safety by mandating constants and explicit optional handling.
- Swift Type Safety Patterns - Provides guidelines for implementing immutable bindings and safe optional handling to prevent runtime crashes.
- Architectural Governance - Provides a framework for enforcing project-wide architectural constraints and design goals within Swift projects.
- Protocol-Oriented Design - Promotes protocol-oriented design and protocol composition to reduce coupling and complexity.
- Value Unwrapping - Standardizes explicit unwrapping techniques for optional types to eliminate runtime crashes.
- Layer Visibility Enforcement - Maintains strict boundaries between architectural layers through the application of visibility modifiers.
- Composition Over Inheritance - Provides standards for favoring composition and protocol-oriented design over deep class inheritance hierarchies.
- Swift Access Control Standards - Defines the application of explicit visibility modifiers to protect internal logic in Swift.
- Swift Architectural Guidelines - Sets standards for prioritizing value types and composition over complex class inheritance hierarchies.
- Value Type Prioritization - Favors structs and enums over classes to ensure predictable state and reduce memory overhead.
- Explicit Modifier Requirements - Enforces explicit visibility modifiers on top-level definitions to protect internal implementation details.
- Explicit Visibility Enforcement - Hides internal logic from external components by applying explicit access control specifiers.
- Code Style Standardization - Provides guidelines for maintaining consistent whitespace, indentation, and visual structure across the codebase.
- Access Control Policies - Defines policies for applying explicit visibility modifiers to isolate internal implementation details from public APIs.
- Architectural Preference Standards - Provides architectural standards for choosing between value and reference types to simplify maintenance.
- Code Readability Optimizations - Implements techniques to improve code readability through patterns like early exits and concise property declarations.
- Early Return Patterns - Standardizes logic flows by using early returns to align the happy path and improve readability.
- Early-Return Patterns - Implements early-return patterns using guard statements to reduce nesting and handle edge cases efficiently.
- Swift API Design Guidelines - Offers design guidelines for creating robust and type-safe APIs in Swift.
- General - Applies safety patterns including immutable bindings and safe optional handling to prevent crashes.
- Mobile Development Guides - Swift coding conventions used at GitHub.
- Programming Language Standards - Official Swift style and conventions.
- Coding Standards - Swift coding style and habits guide.
