Merge pull request #10 from jVirus/bulking-and-value-binding

Balking and value binding

Author: eleev

Concurrency Design Patterns/BalkingPattern/BalkingPattern.md

@@ -0,0 +1,59 @@
+# Balking Pattern
+
+## Introduction
+Concurrency is a crucial aspect of software design, as it allows for the efficient execution of multiple tasks simultaneously. When dealing with concurrent programming, it is essential to handle situations where an object's method is called when it's not ready to perform the requested action. The Balking design pattern provides an elegant solution for such cases by refusing to execute the method when the object is in an undesirable state.
+
+In this article, we will discuss the Balking design pattern in Swift, its benefits, and how to implement it in your applications.
+
+## The Balking Pattern
+
+The Balking pattern is a concurrency design pattern used to handle situations where an object's method is called when the object is not ready to perform the requested action. In such cases, the method "balks" or refuses to execute, often returning immediately without doing anything. This pattern is commonly used to avoid blocking when an object is in an undesirable state for a certain operation.
+
+Here's an example of the Balking pattern implemented in Swift:
+```swift
+import Foundation
+
+class WashingMachine {
+ enum State {
+ case idle
+ case washing
+ }
+
+ private(set) var state: State = .idle
+ private let lock = NSRecursiveLock()
+
+ func wash() {
+ lock.lock()
+ defer { lock.unlock() }
+
+ if state == .washing {
+ print("Already washing. Balking.")
+ return
+ }
+
+ state = .washing
+ print("Start washing")
+ DispatchQueue.global().async {
+ self.doWashing()
+ }
+ }
+
+ private func doWashing() {
+ Thread.sleep(forTimeInterval: 2) // Simulate washing
+ lock.lock()
+ defer { lock.unlock() }
+ state = .idle
+ print("Washing completed")
+ }
+}
+```
+
+In this example, we have a `WashingMachine` class with an internal State enum to represent its state, either idle or washing. The `wash()` method is called to initiate the washing process. We use a lock to ensure that only one thread can modify the state at a time.
+
+When the `wash()` method is called while the washing machine is already in the washing state, it "balks" and returns immediately, printing "Already washing. Balking." to indicate that the operation was not performed.
+
+## Benefits
+The Balking pattern can be useful in situations where it's undesirable to block the calling thread when an object is not ready to perform a requested action. By implementing the Balking pattern, you can improve your application's concurrency behavior and avoid potential issues caused by blocking on unavailable resources.
+
+# Conclusion
+The Balking design pattern is a valuable tool for handling concurrency in your Swift applications. It helps you manage situations where an object's method is called when the object is not prepared to execute the requested action. By implementing the Balking pattern, you can ensure that your application responds gracefully to such situations, improving its overall concurrency behavior.

README.md

@@ -2,7 +2,7 @@
 
 ![GitHub last commit](https://img.shields.io/github/last-commit/jvirus/swift-design-patterns?label=Last%20Commit)
 [![Language](https://img.shields.io/badge/language-Swift-orange.svg)]()
-[![Progress Patterns](https://img.shields.io/badge/patters-33/79-green.svg)]()
+[![Progress Patterns](https://img.shields.io/badge/patters-35/79-green.svg)]()
 [![Progress Principles](https://img.shields.io/badge/principles-0/50-red.svg)]()
 [![NLOC](https://img.shields.io/tokei/lines/github/jvirus/swift-design-patterns)]()
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)]()
@@ -124,7 +124,7 @@ rise of new classes
 > **Source:** [wikipedia.org](https://en.wikipedia.org/wiki/Concurrency_pattern)
 
 - **Active Object:** decouples method execution from method invocation for objects that each reside in their own thread of control
-- **Balking Pattern:** executes an action on an object when the object is in a particular state
+- [**Balking Pattern:**](/Concurrency%20Design%20Patterns/BalkingPattern/BalkingPattern.md) executes an action on an object when the object is in a particular state
 - [**Barrier:**](/Concurrency%20Design%20Patterns/Barrier/Barrier.md) is a type of synchronization method. A barrier for a group of threads or processes in the source code means any thread/process must stop at this point and cannot proceed until all other threads/processes reach this barrier
 - **Binding Pattern:** combines multiple observers to force properties in different objects to be synchronized or coordinated in some way
 - **Double-Checked Locking:** used to reduce the overhead of acquiring a lock by first testing the locking criterion (the "lock hint") without actually acquiring the lock. Only if the locking criterion check indicates that locking is required does the actual locking logic proceed
@@ -161,7 +161,7 @@ The following patterns are not part of the `design patterns` topic. However, the
 
 - [**Wildcard:**](/Swift%20Design%20Patterns/Wildcard/Wildcard.md) a wildcard pattern matches and ignores any value and consists of an underscore (_). Use a wildcard pattern when you don’t care about the values being matched against [[code]](/Swift%20Design%20Patterns/Wildcard/Wildcard.playground/Contents.swift)
 - [**Identifier:**](/Swift%20Design%20Patterns/Identifier/Identifier.md) an identifier pattern matches any value and binds the matched value to a variable or constant name [[code](/Swift%20Design%20Patterns/Identifier/Identifier.playground/Contents.swift)]
-- **Value-Binding:** a value-binding pattern binds matched values to variable or constant names. Value-binding patterns that bind a matched value to the name of a constant begin with the let keyword; those that bind to the name of variable begin with the var keyword
+- [**Value-Binding:**](/Swift%20Design%20Patterns/ValueBinding/ValueBinding.md) a value-binding pattern binds matched values to variable or constant names. Value-binding patterns that bind a matched value to the name of a constant begin with the let keyword; those that bind to the name of variable begin with the var keyword
 - **Tuple Pattern:** a tuple pattern is a comma-separated list of zero or more patterns, enclosed in parentheses. Tuple patterns match values of corresponding tuple types
 - **Enumeration Case:** an enumeration case pattern matches a case of an existing enumeration type. Enumeration case patterns appear in switch statement case labels and in the case conditions of `if`, `while`, `guard`, and `for-in` statements
 - **Optional:** an optional pattern matches values wrapped in a `some(Wrapped)` case of an `Optional<Wrapped>` enumeration. Optional patterns consist of an identifier pattern followed immediately by a question mark and appear in the same places as enumeration case patterns

Swift Design Patterns/ValueBinding/ValueBinding.md

@@ -0,0 +1,43 @@
+# Value-Binding Pattern
+
+## Introduction
+The value-binding pattern in Swift is a powerful feature that allows you to extract values from complex structures like enums, tuples, or custom types and assign them to new constants or variables. It is most commonly used with switch statements when working with enums that have associated values. In this article, we will discuss the value-binding pattern in detail and provide examples to demonstrate its benefits.
+
+## What is the Value-Binding Pattern?
+Value-binding in Swift is a way to destructure complex structures and access their individual values. By using the value-binding pattern, you can create new constants or variables and assign the extracted values to them, making your code more readable and maintainable.
+
+## Value-Binding with `Enums`
+Enums in Swift can have associated values, which are additional pieces of information stored alongside each case. The value-binding pattern is particularly useful when working with enums that have associated values, as it simplifies the process of accessing these values.
+
+## Example
+Consider the following example demonstrating the value-binding pattern in Swift:
+
+```swift
+enum ApiResponse {
+ case success(Int, String)
+ case failure(Int, String)
+}
+
+let response = ApiResponse.success(200, "OK")
+
+switch response {
+case .success(let statusCode, let message):
+ print("Success: \(statusCode) - \(message)")
+case .failure(let statusCode, let message):
+ print("Failure: \(statusCode) - \(message)")
+}
+```
+
+In this example, we define an `ApiResponse` enum that has two cases: success and failure. Each case has associated values: a status code (`Int`) and a message (`String`).
+
+When we create a response with `ApiResponse.success(200, "OK")`, the switch statement checks which case of the enum it is. The value-binding pattern is used within the switch statement to extract the associated values (status code and message) and assign them to new constants: `statusCode` and `message`. Then we can use these constants to print the response details.
+
+## Benefits of the Value-Binding Pattern
+The value-binding pattern offers several benefits:
+
+- Readability: By using value-binding, you can make your code more readable and easier to understand. Instead of accessing associated values through cumbersome methods, you can directly bind them to new constants or variables.
+- Maintainability: The value-binding pattern promotes cleaner code, making it easier to maintain and modify when necessary.
+- Flexibility: Value-binding allows you to work with complex structures, like enums with associated values, tuples, or custom types, in a more efficient and concise manner.
+
+## Conclusion
+The value-binding pattern in Swift is an essential tool for working with complex structures, such as enums with associated values, tuples, or custom types. By using the value-binding pattern, you can simplify your code, making it more readable, maintainable, and flexible. Incorporate this pattern into your Swift development practices to improve the quality and efficiency of your code.