Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit b1ecf0f

Browse files
KyNorthstarKyNorthstar
committedDec 26, 2024··
#40: Added .initializeNow() to LazyContainer
Implemented it everywhere in this package, added tests. Also moved tests to the proper folder.
1 parent 60e6ed8 commit b1ecf0f

13 files changed

+232
-12
lines changed
 

‎Sources/LazyContainers/FunctionalLazy.swift ‎Sources/Lazy/FunctionalLazy.swift

+10
Original file line numberDiff line numberDiff line change
@@ -73,6 +73,11 @@ public struct FunctionalLazy<Value>: LazyContainer {
7373
public var isInitialized: Bool { _guts.isInitialized }
7474

7575

76+
public mutating func initializeNow() {
77+
_guts.initializeNow()
78+
}
79+
80+
7681

7782
/// The actual functionality of `FunctionalLazy`, separated so that the semantics work out better
7883
@propertyWrapper
@@ -114,6 +119,11 @@ public struct FunctionalLazy<Value>: LazyContainer {
114119
set { initializer = { newValue } }
115120
}
116121

122+
123+
func initializeNow() {
124+
_ = initializer()
125+
}
126+
117127

118128
/// Indicates whether the value has indeed been initialized
119129
public var isInitialized: Bool { nil == semaphore }

‎Sources/LazyContainers/Lazy.swift ‎Sources/Lazy/Lazy.swift

+20-5
Original file line numberDiff line numberDiff line change
@@ -19,11 +19,11 @@ public struct Lazy<Value>: LazyContainer {
1919

2020
/// Privatizes the inner-workings of this functional lazy container
2121
@ValueReference
22-
private var guts: ValueHolder<Value>
22+
private var guts: ValueHolder
2323

2424

2525
/// Allows other initializers to have a shared point of initialization
26-
private init(_guts: ValueReference<ValueHolder<Value>>) {
26+
private init(_guts: ValueReference<ValueHolder>) {
2727
self._guts = _guts
2828
}
2929

@@ -73,6 +73,11 @@ public struct Lazy<Value>: LazyContainer {
7373

7474
/// Indicates whether the value has indeed been initialized
7575
public var isInitialized: Bool { _guts.wrappedValue.hasValue }
76+
77+
78+
public mutating func initializeNow() {
79+
guts.initializeNow()
80+
}
7681
}
7782

7883

@@ -120,6 +125,18 @@ public enum LazyContainerValueHolder<Value> {
120125
case .unset(initializer: _): return false
121126
}
122127
}
128+
129+
130+
/// Immediately initializes the value held inside this value holder
131+
///
132+
/// If this holder already contains a value, this does nothing
133+
mutating func initializeNow() {
134+
switch self {
135+
case .hasValue(_): return
136+
case .unset(let initializer):
137+
self = .hasValue(value: initializer())
138+
}
139+
}
123140
}
124141

125142

@@ -128,7 +145,5 @@ public enum LazyContainerValueHolder<Value> {
128145
public extension LazyContainer {
129146

130147
/// Takes care of keeping track of the state, value, and initializer as needed
131-
///
132-
/// - Attention: This will change in version 5, to be an alias to `LazyContainerValueHolder<Value>`
133-
typealias ValueHolder = LazyContainerValueHolder
148+
typealias ValueHolder = LazyContainerValueHolder<Value>
134149
}

‎Sources/LazyContainers/LazyContainer.swift ‎Sources/Lazy/LazyContainer.swift

+7-2
Original file line numberDiff line numberDiff line change
@@ -34,6 +34,13 @@ public protocol LazyContainer {
3434
var isInitialized: Bool { get }
3535

3636

37+
/// Immediately initializes the value held inside this lazy container
38+
///
39+
/// If this holder already contains a value, this does nothing
40+
// https://github.com/RougeWare/Swift-Lazy-Containers/issues/40
41+
mutating func initializeNow()
42+
43+
3744
/// Creates a lazy container that already contains an initialized value.
3845
///
3946
/// This is useful when you need a uniform API (for instance, when implementing a protocol that requires a `Lazy`),
@@ -68,7 +75,5 @@ public final class LazyContainerValueReference<Value> {
6875
public extension LazyContainer {
6976

7077
/// Allows you to use reference semantics to hold a value inside a lazy container.
71-
///
72-
/// - Attention: This will change in version 5, to be an alias to `LazyContainerValueReference<Value>`
7378
typealias ValueReference = LazyContainerValueReference
7479
}

‎Sources/LazyContainers/ResettableLazy.swift ‎Sources/Lazy/ResettableLazy.swift

+20-5
Original file line numberDiff line numberDiff line change
@@ -20,11 +20,11 @@ public struct ResettableLazy<Value>: LazyContainer {
2020

2121
/// Privatizes the inner-workings of this functional lazy container
2222
@ValueReference
23-
private var guts: ResettableValueHolder<Value>
23+
private var guts: ResettableValueHolder
2424

2525

2626
/// Allows other initializers to have a shared point of initialization
27-
private init(_guts: ValueReference<ResettableValueHolder<Value>>) {
27+
private init(_guts: ValueReference<ResettableValueHolder>) {
2828
self._guts = _guts
2929
}
3030

@@ -80,6 +80,11 @@ public struct ResettableLazy<Value>: LazyContainer {
8080
public var isInitialized: Bool { _guts.wrappedValue.hasValue }
8181

8282

83+
public mutating func initializeNow() {
84+
guts.initializeNow()
85+
}
86+
87+
8388
/// Resets this lazy structure back to its unset state. Next time a value is needed, it will be regenerated using
8489
/// the initializer given by the constructor
8590
public func clear() {
@@ -147,6 +152,18 @@ public enum LazyContainerResettableValueHolder<Value> {
147152
case .unset(initializer: _): return false
148153
}
149154
}
155+
156+
157+
/// Immediately initializes the value in this holder.
158+
///
159+
/// If this holder already contains a value, this does nothing
160+
public mutating func initializeNow() {
161+
switch self {
162+
case .hasValue(value: _, initializer: _): return
163+
case .unset(let initializer):
164+
self = .hasValue(value: initializer(), initializer: initializer)
165+
}
166+
}
150167
}
151168

152169

@@ -156,7 +173,5 @@ public enum LazyContainerResettableValueHolder<Value> {
156173
public extension LazyContainer {
157174

158175
/// Takes care of keeping track of the state, value, and initializer as needed
159-
///
160-
/// - Attention: This will change in version 5, to be an alias to `LazyContainerResettableValueHolder<Value>`
161-
typealias ResettableValueHolder = LazyContainerResettableValueHolder
176+
typealias ResettableValueHolder = LazyContainerResettableValueHolder<Value>
162177
}

‎Tests/LazyContainersTests/LazyContainersTests.swift ‎Tests/LazyTests/LazyContainersTests.swift

+175
Original file line numberDiff line numberDiff line change
@@ -144,6 +144,66 @@ struct LazyContainersTests {
144144

145145

146146

147+
// MARK: .initializeNow()
148+
149+
// https://github.com/RougeWare/Swift-Lazy-Containers/issues/40
150+
151+
@Test
152+
mutating func initializeNow_Lazy_traditional() {
153+
#expect(false == lazyInitTraditionally.isInitialized)
154+
lazyInitTraditionally.initializeNow()
155+
#expect(true == lazyInitTraditionally.isInitialized)
156+
#expect("lazy B" == lazyInitTraditionally.wrappedValue)
157+
#expect(true == lazyInitTraditionally.isInitialized)
158+
#expect("lazy B" == lazyInitTraditionally.wrappedValue)
159+
#expect(true == lazyInitTraditionally.isInitialized)
160+
161+
lazyInitTraditionally.wrappedValue = "Manual B"
162+
163+
#expect(true == lazyInitTraditionally.isInitialized)
164+
#expect("Manual B" == lazyInitTraditionally.wrappedValue)
165+
#expect(true == lazyInitTraditionally.isInitialized)
166+
#expect("Manual B" == lazyInitTraditionally.wrappedValue)
167+
#expect(true == lazyInitTraditionally.isInitialized)
168+
#expect("Manual B" == lazyInitTraditionally.wrappedValue)
169+
#expect(true == lazyInitTraditionally.isInitialized)
170+
}
171+
172+
173+
@Test
174+
mutating func initializeNow_Lazy_customInitWithSideEffect() {
175+
#expect(sideEffectA == nil)
176+
#expect(false == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
177+
#expect(sideEffectA == nil)
178+
_lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.initializeNow()
179+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
180+
#expect(sideEffectA == "Side effect A1")
181+
#expect("lAzy" == lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect)
182+
#expect(sideEffectA == "Side effect A1")
183+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
184+
#expect(sideEffectA == "Side effect A1")
185+
#expect("lAzy" == lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect)
186+
#expect(sideEffectA == "Side effect A1")
187+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
188+
#expect(sideEffectA == "Side effect A1")
189+
190+
lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect = "MAnual"
191+
192+
#expect(sideEffectA == "Side effect A1")
193+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
194+
#expect(sideEffectA == "Side effect A1")
195+
#expect("MAnual" == lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect)
196+
#expect(sideEffectA == "Side effect A1")
197+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
198+
#expect(sideEffectA == "Side effect A1")
199+
#expect("MAnual" == lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect)
200+
#expect(sideEffectA == "Side effect A1")
201+
#expect(true == _lazyInitWithPropertyWrapperAndCustomInitializerWithSideEffect.isInitialized)
202+
#expect(sideEffectA == "Side effect A1")
203+
}
204+
205+
206+
147207
// MARK: - `ResettableLazy`
148208

149209
@Test
@@ -209,6 +269,73 @@ struct LazyContainersTests {
209269
#expect(true == resettableLazyInitTraditionally.isInitialized)
210270
}
211271

272+
// MARK: .initializeNow()
273+
274+
// https://github.com/RougeWare/Swift-Lazy-Containers/issues/40
275+
276+
@Test
277+
mutating func initializeNow_ResettableLazy_propertyWrapper() {
278+
#expect(false == _resettableLazyInitWithPropertyWrapper.isInitialized)
279+
_resettableLazyInitWithPropertyWrapper.initializeNow()
280+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
281+
#expect("lazy C" == resettableLazyInitWithPropertyWrapper)
282+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
283+
#expect("lazy C" == resettableLazyInitWithPropertyWrapper)
284+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
285+
286+
resettableLazyInitWithPropertyWrapper = "Manual C"
287+
288+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
289+
#expect("Manual C" == resettableLazyInitWithPropertyWrapper)
290+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
291+
#expect("Manual C" == resettableLazyInitWithPropertyWrapper)
292+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
293+
#expect("Manual C" == resettableLazyInitWithPropertyWrapper)
294+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
295+
296+
_resettableLazyInitWithPropertyWrapper.clear()
297+
298+
#expect(false == _resettableLazyInitWithPropertyWrapper.isInitialized)
299+
#expect("lazy C" == resettableLazyInitWithPropertyWrapper)
300+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
301+
#expect("lazy C" == resettableLazyInitWithPropertyWrapper)
302+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
303+
#expect("lazy C" == resettableLazyInitWithPropertyWrapper)
304+
#expect(true == _resettableLazyInitWithPropertyWrapper.isInitialized)
305+
}
306+
307+
308+
@Test
309+
mutating func initializeNow_ResettableLazy_traditional() {
310+
#expect(false == resettableLazyInitTraditionally.isInitialized)
311+
resettableLazyInitTraditionally.initializeNow()
312+
#expect(true == resettableLazyInitTraditionally.isInitialized)
313+
#expect("lazy D" == resettableLazyInitTraditionally.wrappedValue)
314+
#expect(true == resettableLazyInitTraditionally.isInitialized)
315+
#expect("lazy D" == resettableLazyInitTraditionally.wrappedValue)
316+
#expect(true == resettableLazyInitTraditionally.isInitialized)
317+
318+
resettableLazyInitTraditionally.wrappedValue = "Manual D"
319+
320+
#expect(true == resettableLazyInitTraditionally.isInitialized)
321+
#expect("Manual D" == resettableLazyInitTraditionally.wrappedValue)
322+
#expect(true == resettableLazyInitTraditionally.isInitialized)
323+
#expect("Manual D" == resettableLazyInitTraditionally.wrappedValue)
324+
#expect(true == resettableLazyInitTraditionally.isInitialized)
325+
#expect("Manual D" == resettableLazyInitTraditionally.wrappedValue)
326+
#expect(true == resettableLazyInitTraditionally.isInitialized)
327+
328+
resettableLazyInitTraditionally.clear()
329+
330+
#expect(false == resettableLazyInitTraditionally.isInitialized)
331+
#expect("lazy D" == resettableLazyInitTraditionally.wrappedValue)
332+
#expect(true == resettableLazyInitTraditionally.isInitialized)
333+
#expect("lazy D" == resettableLazyInitTraditionally.wrappedValue)
334+
#expect(true == resettableLazyInitTraditionally.isInitialized)
335+
#expect("lazy D" == resettableLazyInitTraditionally.wrappedValue)
336+
#expect(true == resettableLazyInitTraditionally.isInitialized)
337+
}
338+
212339

213340

214341
// MARK: - `FuctionalLazy`
@@ -255,4 +382,52 @@ struct LazyContainersTests {
255382
#expect("Manual F" == functionalLazyInitTraditionally.wrappedValue)
256383
#expect(true == functionalLazyInitTraditionally.isInitialized)
257384
}
385+
386+
387+
// MARK: .initializeNow()
388+
389+
// https://github.com/RougeWare/Swift-Lazy-Containers/issues/40
390+
391+
@Test
392+
mutating func initializeNow_FunctionalLazy_propertyWrapper() {
393+
#expect(false == _functionalLazyInitWithPropertyWrapper.isInitialized)
394+
_functionalLazyInitWithPropertyWrapper.initializeNow()
395+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
396+
#expect("lazy E" == functionalLazyInitWithPropertyWrapper)
397+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
398+
#expect("lazy E" == functionalLazyInitWithPropertyWrapper)
399+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
400+
401+
functionalLazyInitWithPropertyWrapper = "Manual E"
402+
403+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
404+
#expect("Manual E" == functionalLazyInitWithPropertyWrapper)
405+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
406+
#expect("Manual E" == functionalLazyInitWithPropertyWrapper)
407+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
408+
#expect("Manual E" == functionalLazyInitWithPropertyWrapper)
409+
#expect(true == _functionalLazyInitWithPropertyWrapper.isInitialized)
410+
}
411+
412+
413+
@Test
414+
mutating func initializeNow_FunctionalLazy_traditional() {
415+
#expect(false == functionalLazyInitTraditionally.isInitialized)
416+
functionalLazyInitTraditionally.initializeNow()
417+
#expect(true == functionalLazyInitTraditionally.isInitialized)
418+
#expect("lazy F" == functionalLazyInitTraditionally.wrappedValue)
419+
#expect(true == functionalLazyInitTraditionally.isInitialized)
420+
#expect("lazy F" == functionalLazyInitTraditionally.wrappedValue)
421+
#expect(true == functionalLazyInitTraditionally.isInitialized)
422+
423+
functionalLazyInitTraditionally.wrappedValue = "Manual F"
424+
425+
#expect(true == functionalLazyInitTraditionally.isInitialized)
426+
#expect("Manual F" == functionalLazyInitTraditionally.wrappedValue)
427+
#expect(true == functionalLazyInitTraditionally.isInitialized)
428+
#expect("Manual F" == functionalLazyInitTraditionally.wrappedValue)
429+
#expect(true == functionalLazyInitTraditionally.isInitialized)
430+
#expect("Manual F" == functionalLazyInitTraditionally.wrappedValue)
431+
#expect(true == functionalLazyInitTraditionally.isInitialized)
432+
}
258433
}

0 commit comments

Comments
 (0)
Please sign in to comment.