peffect 0.1.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
peffect/queue.py ADDED
@@ -0,0 +1,670 @@
1
+ """Queue at Effect v4 289a53f7: FIFO ownership, backpressure and completion.
2
+
3
+ Queue.ts:480-2175. Public module duals become methods; capability views are the
4
+ same object. No Ref or kernel protocol dependency. The creator dispatcher owns
5
+ coalesced taker releases. A wake means retry, never reservation. Destructive
6
+ reads use suspend_exit to deliver to the first accepting continuation atomically.
7
+
8
+ Numeric capacities are deliberately not normalized (including vendor quirks).
9
+ Counts are normalized. Metadata/Pipeable/Inspectable spellings are not ported.
10
+ Batch capability methods bind their receiver type independently: Python list is
11
+ invariant, but each result contains only that call's supplied/read messages.
12
+ This preserves the vendor's contravariant Enqueue and covariant Dequeue views.
13
+ """
14
+
15
+ from __future__ import annotations
16
+
17
+ from abc import ABC, abstractmethod
18
+ from collections import deque
19
+ from collections.abc import Callable, Iterable, Iterator
20
+ from dataclasses import dataclass, field
21
+ from math import floor, inf, isnan
22
+ from typing import Literal, Never, TypeIs, final, overload
23
+
24
+ from .cause import Cause, Done
25
+ from .core import (
26
+ Effect,
27
+ Exit,
28
+ Failure,
29
+ Success,
30
+ async_,
31
+ exit_,
32
+ fiber_id,
33
+ succeed,
34
+ suspend,
35
+ suspend_exit,
36
+ sync,
37
+ uninterruptible_mask,
38
+ )
39
+ from .fiber import with_dispatcher
40
+ from .option import Some
41
+ from .pull import catch_done
42
+ from .scheduler import SchedulerDispatcher
43
+
44
+ type Strategy = Literal["suspend", "dropping", "sliding"]
45
+ type _Resume[A, E] = Callable[[Effect[A, E, Never]], None]
46
+
47
+
48
+ class Enqueue[A, E = Never](ABC):
49
+ """Write capability, contravariant in both message and error (Queue.ts:175)."""
50
+
51
+ @abstractmethod
52
+ def offer(self, message: A) -> Effect[bool, Never, Never]: ...
53
+
54
+ @abstractmethod
55
+ def offer_unsafe(self, message: A) -> bool: ...
56
+
57
+ @abstractmethod
58
+ def offer_all[B](
59
+ self: Enqueue[B, E], messages: Iterable[B]
60
+ ) -> Effect[list[B], Never, Never]: ...
61
+
62
+ @abstractmethod
63
+ def offer_all_unsafe[B](self: Enqueue[B, E], messages: Iterable[B]) -> list[B]: ...
64
+
65
+ @abstractmethod
66
+ def fail_cause_unsafe(self, cause: Cause[E]) -> bool: ...
67
+
68
+ def fail_cause(self, cause: Cause[E]) -> Effect[bool, Never, Never]:
69
+ return sync(lambda: self.fail_cause_unsafe(cause))
70
+
71
+ def fail(self, error: E) -> Effect[bool, Never, Never]:
72
+ return self.fail_cause(Cause.fail(error))
73
+
74
+ def end[B, F](self: Enqueue[B, F | Done]) -> Effect[bool, Never, Never]:
75
+ return self.fail_cause(Cause.fail(Done()))
76
+
77
+ def end_unsafe[B, F](self: Enqueue[B, F | Done]) -> bool:
78
+ return self.fail_cause_unsafe(Cause.fail(Done()))
79
+
80
+ def interrupt(self) -> Effect[bool, Never, Never]:
81
+ return fiber_id.flat_map(lambda by: self.fail_cause(Cause.interrupt(by)))
82
+
83
+ @abstractmethod
84
+ def shutdown_unsafe(self) -> bool: ...
85
+
86
+ def shutdown(self) -> Effect[bool, Never, Never]:
87
+ return sync(self.shutdown_unsafe)
88
+
89
+ @abstractmethod
90
+ def flush_unsafe(self) -> None: ...
91
+
92
+ def flush(self) -> Effect[None, Never, Never]:
93
+ return sync(self.flush_unsafe)
94
+
95
+ def into[B, F, X, R](
96
+ self: Enqueue[B, F | Done], effect: Effect[X, F, R]
97
+ ) -> Effect[bool, Never, R]:
98
+ """1963-1991: publish the producer Exit, ignoring its success value."""
99
+
100
+ def publish(result: Exit[X, F]) -> Effect[bool, Never, Never]:
101
+ return self.fail_cause(result.cause) if isinstance(result, Failure) else self.end()
102
+
103
+ return uninterruptible_mask(lambda restore: exit_(restore(effect)).flat_map(publish))
104
+
105
+
106
+ class Dequeue[A, E = Never](ABC):
107
+ """Read capability, covariant in message and error (Queue.ts:245)."""
108
+
109
+ @abstractmethod
110
+ def take_unsafe(self) -> Exit[A, E] | None: ...
111
+
112
+ @abstractmethod
113
+ def _await_take(self, ready: Callable[[], bool]) -> Effect[None, E, Never]: ...
114
+
115
+ @abstractmethod
116
+ def _can_take(self, minimum: float) -> bool: ...
117
+
118
+ def take(self) -> Effect[A, E, Never]:
119
+ def attempt() -> Effect[A, E, Never]:
120
+ result = self.take_unsafe()
121
+ if result is not None:
122
+ return result
123
+ return self._await_take(lambda: self._can_take(1)).flat_map(lambda _: self.take())
124
+
125
+ return suspend_exit(attempt)
126
+
127
+ def poll(self) -> Effect[Some[A] | None, Never, Never]:
128
+ def attempt() -> Effect[Some[A] | None, Never, Never]:
129
+ result = self.take_unsafe()
130
+ return Success(Some(result.value) if isinstance(result, Success) else None)
131
+
132
+ return suspend_exit(attempt)
133
+
134
+ @abstractmethod
135
+ def peek(self) -> Effect[A, E, Never]: ...
136
+
137
+ @abstractmethod
138
+ def take_between[B](
139
+ self: Dequeue[B, E], minimum: float, maximum: float
140
+ ) -> Effect[list[B], E, Never]: ...
141
+
142
+ def take_n[B](self: Dequeue[B, E], count: float) -> Effect[list[B], E, Never]:
143
+ return self.take_between(count, count)
144
+
145
+ def take_all[B](self: Dequeue[B, E]) -> Effect[list[B], E, Never]:
146
+ return self.take_between(1, inf)
147
+
148
+ @abstractmethod
149
+ def _clear_raw[B](self: Dequeue[B, E]) -> Effect[list[B], E, Never]: ...
150
+
151
+ @overload
152
+ def clear[B](self: Dequeue[B, Done[object]]) -> Effect[list[B], Never, Never]: ...
153
+ @overload
154
+ def clear[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]: ...
155
+ def clear[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]:
156
+ return catch_done(self._clear_raw(), lambda _: succeed(list[B]()))
157
+
158
+ @overload
159
+ def collect[B](self: Dequeue[B, Done[object]]) -> Effect[list[B], Never, Never]: ...
160
+ @overload
161
+ def collect[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]: ...
162
+ def collect[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[list[B], F, Never]:
163
+ def begin() -> Effect[list[B], F, Never]:
164
+ messages: list[B] = []
165
+
166
+ def append(batch: list[B]) -> Effect[list[B], Done[object] | F, Never]:
167
+ messages.extend(batch)
168
+ return suspend(loop)
169
+
170
+ def loop() -> Effect[list[B], Done[object] | F, Never]:
171
+ return self.take_all().flat_map(append)
172
+
173
+ return catch_done(suspend(loop), lambda _: succeed(messages))
174
+
175
+ return suspend(begin)
176
+
177
+ @abstractmethod
178
+ def _await_raw(self) -> Effect[None, E, Never]: ...
179
+
180
+ @overload
181
+ def await_[B](self: Dequeue[B, Done[object]]) -> Effect[None, Never, Never]: ...
182
+ @overload
183
+ def await_[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[None, F, Never]: ...
184
+ def await_[B, F](self: Dequeue[B, Done[object] | F]) -> Effect[None, F, Never]:
185
+ return catch_done(self._await_raw(), lambda _: succeed(None))
186
+
187
+ @abstractmethod
188
+ def size_unsafe(self) -> int: ...
189
+
190
+ def size(self) -> Effect[int, Never, Never]:
191
+ return sync(self.size_unsafe)
192
+
193
+ @abstractmethod
194
+ def is_full_unsafe(self) -> bool: ...
195
+
196
+ def is_full(self) -> Effect[bool, Never, Never]:
197
+ return sync(self.is_full_unsafe)
198
+
199
+
200
+ class _Registry[T]:
201
+ """Live ordered Set traversal, including append/delete during callbacks.
202
+
203
+ Python dict iteration forbids mutation. Tokens keep cancellation ownership;
204
+ tombstones remain during iteration, then compact with amortized bounded slack.
205
+ No copied waiter snapshot can accidentally wake a cancelled waiter.
206
+ """
207
+
208
+ def __init__(self) -> None:
209
+ self._values: dict[int, T] = {}
210
+ self._order: list[int] = []
211
+ self._next = 0
212
+ self._iterators = 0
213
+
214
+ def __len__(self) -> int:
215
+ return len(self._values)
216
+
217
+ def add(self, value: T) -> int:
218
+ token = self._next
219
+ self._next += 1
220
+ self._values[token] = value
221
+ self._order.append(token)
222
+ return token
223
+
224
+ def remove(self, token: int) -> None:
225
+ self._values.pop(token, None)
226
+ self._compact()
227
+
228
+ def clear(self) -> None:
229
+ self._values.clear()
230
+ self._compact()
231
+
232
+ def _compact(self) -> None:
233
+ if not self._iterators and len(self._order) > 2 * len(self._values):
234
+ self._order = list(self._values)
235
+
236
+ def __iter__(self) -> Iterator[tuple[int, T]]:
237
+ self._iterators += 1
238
+ try:
239
+ index = 0
240
+ while index < len(self._order):
241
+ token = self._order[index]
242
+ index += 1
243
+ if token in self._values:
244
+ yield token, self._values[token]
245
+ finally:
246
+ self._iterators -= 1
247
+ self._compact()
248
+
249
+
250
+ @dataclass
251
+ class _Single[A]:
252
+ message: A
253
+ resume: _Resume[bool, Never]
254
+
255
+
256
+ @dataclass
257
+ class _Batch[A]:
258
+ remaining: list[A]
259
+ resume: _Resume[list[A], Never]
260
+ offset: int = 0
261
+
262
+
263
+ @dataclass
264
+ class _Taker[E]:
265
+ ready: Callable[[], bool]
266
+ resume: _Resume[None, E]
267
+
268
+
269
+ @dataclass
270
+ class _Active[A, E]:
271
+ # None is Open; a stored terminal Failure is Closing. Done owns no registries.
272
+ terminal: Failure[E] | None = None
273
+ takers: _Registry[_Taker[E]] = field(default_factory=_Registry[_Taker[E]])
274
+ offers: _Registry[_Single[A] | _Batch[A]] = field(
275
+ default_factory=_Registry[_Single[A] | _Batch[A]]
276
+ )
277
+ awaiters: _Registry[_Resume[None, E]] = field(default_factory=_Registry[_Resume[None, E]])
278
+
279
+
280
+ @dataclass(frozen=True)
281
+ class _Done[E]:
282
+ terminal: Failure[E]
283
+
284
+
285
+ def _count(value: float) -> float:
286
+ return 0 if isnan(value) or value <= 0 else inf if value == inf else floor(value)
287
+
288
+
289
+ @final
290
+ class Queue[A, E = Never](Enqueue[A, E], Dequeue[A, E]):
291
+ """Invariant FIFO owner. Capacity is raw, counts are normalized upstream."""
292
+
293
+ def __init__(
294
+ self, capacity: float, strategy: Strategy, dispatcher: SchedulerDispatcher
295
+ ) -> None:
296
+ self.capacity = capacity
297
+ self.strategy = strategy
298
+ self._dispatcher = dispatcher
299
+ self._messages: deque[A] = deque()
300
+ self._state: _Active[A, E] | _Done[E] = _Active()
301
+ self._scheduled = False
302
+
303
+ @classmethod
304
+ def make(
305
+ cls, *, capacity: float = inf, strategy: Strategy = "suspend"
306
+ ) -> Effect[Queue[A, E], Never, Never]:
307
+ return with_dispatcher(lambda dispatcher: succeed(cls(capacity, strategy, dispatcher)))
308
+
309
+ @classmethod
310
+ def bounded(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
311
+ return cls.make(capacity=capacity)
312
+
313
+ @classmethod
314
+ def dropping(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
315
+ return cls.make(capacity=capacity, strategy="dropping")
316
+
317
+ @classmethod
318
+ def sliding(cls, capacity: float) -> Effect[Queue[A, E], Never, Never]:
319
+ return cls.make(capacity=capacity, strategy="sliding")
320
+
321
+ @classmethod
322
+ def unbounded(cls) -> Effect[Queue[A, E], Never, Never]:
323
+ return cls.make()
324
+
325
+ def as_enqueue(self) -> Enqueue[A, E]:
326
+ return self
327
+
328
+ def as_dequeue(self) -> Dequeue[A, E]:
329
+ return self
330
+
331
+ def offer_unsafe(self, message: A) -> bool:
332
+ state = self._state
333
+ if isinstance(state, _Done) or state.terminal is not None:
334
+ return False
335
+ if len(self._messages) >= self.capacity:
336
+ if self.capacity <= 0 and len(state.takers) > (
337
+ 0 if self.strategy == "sliding" else len(self._messages)
338
+ ):
339
+ self._messages.append(message)
340
+ if self.strategy == "sliding":
341
+ self._trim(len(state.takers))
342
+ self.flush_unsafe()
343
+ return True
344
+ if self.strategy == "sliding":
345
+ if self.capacity > 0:
346
+ self._messages.popleft()
347
+ self._messages.append(message)
348
+ return True
349
+ return False
350
+ self._messages.append(message)
351
+ self._schedule_takers()
352
+ return True
353
+
354
+ def offer(self, message: A) -> Effect[bool, Never, Never]:
355
+ def attempt() -> Effect[bool, Never, Never]:
356
+ if self.offer_unsafe(message):
357
+ return Success(True)
358
+ state = self._state
359
+ if isinstance(state, _Done) or state.terminal is not None or self.strategy != "suspend":
360
+ return Success(False)
361
+
362
+ def register(resume: _Resume[bool, Never]) -> Effect[None, Never, Never] | None:
363
+ if self.offer_unsafe(message):
364
+ resume(Success(True))
365
+ return None
366
+ return self._wait_offer(_Single(message, resume))
367
+
368
+ return async_(register)
369
+
370
+ return suspend(attempt)
371
+
372
+ def _trim(self, capacity: float) -> None:
373
+ # MutableList.takeNVoid normalizes the removal count (MutableList.ts:516).
374
+ excess = _count(len(self._messages) - capacity)
375
+ while excess > 0 and self._messages:
376
+ self._messages.popleft()
377
+ excess -= 1
378
+
379
+ def offer_all_unsafe[B, F](self: Queue[B, F], messages: Iterable[B]) -> list[B]:
380
+ state = self._state
381
+ if isinstance(state, _Done) or state.terminal is not None:
382
+ return list(messages)
383
+ if self.capacity == inf or self.strategy == "sliding":
384
+ self._messages.extend(messages)
385
+ if self.strategy == "sliding":
386
+ self._trim(len(state.takers) if self.capacity <= 0 else self.capacity)
387
+ self._schedule_takers()
388
+ return []
389
+ free = (len(state.takers) if self.capacity <= 0 else self.capacity) - len(self._messages)
390
+ if free <= 0:
391
+ return list(messages)
392
+ remaining: list[B] = []
393
+ for index, message in enumerate(messages):
394
+ if index < free:
395
+ self._messages.append(message)
396
+ else:
397
+ remaining.append(message)
398
+ self._schedule_takers()
399
+ return remaining
400
+
401
+ def offer_all[B, F](self: Queue[B, F], messages: Iterable[B]) -> Effect[list[B], Never, Never]:
402
+ def register(resume: _Resume[list[B], Never]) -> Effect[None, Never, Never] | None:
403
+ remaining = self.offer_all_unsafe(messages)
404
+ if not remaining or self.strategy == "dropping":
405
+ resume(Success(remaining))
406
+ return None
407
+ return self._wait_offer(_Batch(remaining, resume))
408
+
409
+ return async_(register)
410
+
411
+ def _wait_offer(self, entry: _Single[A] | _Batch[A]) -> Effect[None, Never, Never] | None:
412
+ state = self._state
413
+ if isinstance(state, _Done) or state.terminal is not None:
414
+ self._reject(entry)
415
+ return None
416
+ token = state.offers.add(entry)
417
+
418
+ def cancel() -> None:
419
+ current = self._state
420
+ if isinstance(current, _Done):
421
+ return
422
+ state.offers.remove(token)
423
+ if current.terminal is not None and not state.offers and not self._messages:
424
+ self._finalize(current.terminal)
425
+
426
+ return sync(cancel)
427
+
428
+ @staticmethod
429
+ def _reject(entry: _Single[A] | _Batch[A]) -> None:
430
+ if isinstance(entry, _Single):
431
+ entry.resume(Success(False))
432
+ else:
433
+ entry.resume(Success(entry.remaining[entry.offset :]))
434
+
435
+ def fail_cause_unsafe(self, cause: Cause[E]) -> bool:
436
+ state = self._state
437
+ if isinstance(state, _Done) or state.terminal is not None:
438
+ return False
439
+ terminal = Failure(cause)
440
+ if not state.offers and not self._messages:
441
+ self._finalize(terminal)
442
+ else:
443
+ state.terminal = terminal
444
+ self._schedule_takers()
445
+ return True
446
+
447
+ def shutdown_unsafe(self) -> bool:
448
+ state = self._state
449
+ if isinstance(state, _Done):
450
+ return False
451
+ self._messages.clear()
452
+ self._finalize(state.terminal if state.terminal is not None else Failure(Cause.interrupt()))
453
+ for _, entry in state.offers:
454
+ self._reject(entry)
455
+ state.offers.clear()
456
+ return True
457
+
458
+ def _finalize(self, terminal: Failure[E]) -> None:
459
+ state = self._state
460
+ if isinstance(state, _Done):
461
+ return
462
+ self._state = _Done(terminal)
463
+ for _, taker in state.takers:
464
+ taker.resume(terminal)
465
+ state.takers.clear()
466
+ for _, resume in state.awaiters:
467
+ resume(terminal)
468
+ state.awaiters.clear()
469
+
470
+ def _schedule_takers(self) -> None:
471
+ state = self._state
472
+ if self._scheduled or isinstance(state, _Done) or not state.takers:
473
+ return
474
+ self._scheduled = True
475
+
476
+ def release() -> None:
477
+ self._scheduled = False
478
+ self.flush_unsafe()
479
+
480
+ self._dispatcher.schedule_task(release, 0)
481
+
482
+ def flush_unsafe(self) -> None:
483
+ state = self._state
484
+ if isinstance(state, _Done):
485
+ return
486
+ for token, taker in state.takers:
487
+ if not taker.ready():
488
+ continue
489
+ state.takers.remove(token)
490
+ taker.resume(Success(None))
491
+ if not self._messages:
492
+ break
493
+
494
+ def _await_take(self, ready: Callable[[], bool]) -> Effect[None, E, Never]:
495
+ def register(resume: _Resume[None, E]) -> Effect[None, Never, Never] | None:
496
+ state = self._state
497
+ if isinstance(state, _Done):
498
+ resume(state.terminal)
499
+ return None
500
+ if ready():
501
+ resume(Success(None))
502
+ return None
503
+ token = state.takers.add(_Taker(ready, resume))
504
+ return sync(lambda: state.takers.remove(token))
505
+
506
+ return async_(register)
507
+
508
+ def _can_take(self, minimum: float) -> bool:
509
+ state = self._state
510
+ if isinstance(state, _Done):
511
+ return False
512
+ # JS capacity || 1 treats NaN as false as well as zero.
513
+ capacity = self.capacity if self.capacity and not isnan(self.capacity) else 1
514
+ threshold = 1 if state.terminal is not None else min(minimum, capacity)
515
+ return len(self._messages) >= threshold or (self.capacity <= 0 and bool(state.offers))
516
+
517
+ def _take_offer(self, offers: _Registry[_Single[A] | _Batch[A]]) -> A:
518
+ token, entry = next(iter(offers))
519
+ if isinstance(entry, _Single):
520
+ message = entry.message
521
+ offers.remove(token)
522
+ entry.resume(Success(True))
523
+ return message
524
+ message = entry.remaining[entry.offset]
525
+ entry.offset += 1
526
+ if entry.offset == len(entry.remaining):
527
+ offers.remove(token)
528
+ entry.resume(Success([]))
529
+ return message
530
+
531
+ def _release_capacity(self) -> None:
532
+ """Admit waiting offers into freed capacity, oldest first (releaseCapacity,
533
+ Queue.ts:2109). Each offer is reserved in the buffer and removed before its producer
534
+ resumes: resuming can synchronously take, offer or shut down this queue, so capacity
535
+ and state are read again for every offer."""
536
+ state = self._state
537
+ if isinstance(state, _Done):
538
+ return
539
+ if not state.offers:
540
+ if state.terminal is not None and not self._messages:
541
+ self._finalize(state.terminal)
542
+ return
543
+ for token, entry in state.offers:
544
+ free = self.capacity - len(self._messages)
545
+ if free <= 0 or not self._admit(entry, free):
546
+ return
547
+ state.offers.remove(token)
548
+ self._accept(entry)
549
+ if isinstance(self._state, _Done):
550
+ return
551
+
552
+ def _admit(self, entry: _Single[A] | _Batch[A], free: float) -> bool:
553
+ """Buffer the offer's messages while `free` lasts; True when none are left to send.
554
+ A batch keeps its progress in `offset` and stays registered until then."""
555
+ if isinstance(entry, _Single):
556
+ self._messages.append(entry.message)
557
+ return True
558
+ while entry.offset < len(entry.remaining):
559
+ if free == 0: # upstream's `n === 0`: a fractional raw capacity never stops here
560
+ return False
561
+ self._messages.append(entry.remaining[entry.offset])
562
+ free -= 1
563
+ entry.offset += 1
564
+ return True
565
+
566
+ @staticmethod
567
+ def _accept(entry: _Single[A] | _Batch[A]) -> None:
568
+ if isinstance(entry, _Single):
569
+ entry.resume(Success(True))
570
+ else:
571
+ entry.resume(Success([]))
572
+
573
+ def take_unsafe(self) -> Exit[A, E] | None:
574
+ state = self._state
575
+ if isinstance(state, _Done):
576
+ return state.terminal
577
+ if self._messages:
578
+ message = self._messages.popleft()
579
+ elif self.capacity <= 0 and state.offers:
580
+ message = self._take_offer(state.offers)
581
+ else:
582
+ return None
583
+ self._release_capacity()
584
+ return Success(message)
585
+
586
+ def take_between(self, minimum: float, maximum: float) -> Effect[list[A], E, Never]:
587
+ minimum, maximum = _count(minimum), _count(maximum)
588
+
589
+ def attempt() -> Effect[list[A], E, Never]:
590
+ state = self._state
591
+ if isinstance(state, _Done):
592
+ return state.terminal
593
+ if maximum <= 0 or minimum <= 0:
594
+ return Success([])
595
+ if not self._can_take(minimum):
596
+ return self._await_take(lambda: self._can_take(minimum)).flat_map(
597
+ lambda _: suspend_exit(attempt)
598
+ )
599
+ messages: list[A] = []
600
+ if self._messages:
601
+ while self._messages and len(messages) < maximum:
602
+ messages.append(self._messages.popleft())
603
+ else:
604
+ messages.append(self._take_offer(state.offers))
605
+ self._release_capacity()
606
+ return Success(messages)
607
+
608
+ return suspend_exit(attempt)
609
+
610
+ def _clear_raw(self) -> Effect[list[A], E, Never]:
611
+ def attempt() -> Effect[list[A], E, Never]:
612
+ state = self._state
613
+ if isinstance(state, _Done):
614
+ return state.terminal
615
+ if self._messages:
616
+ messages = list(self._messages)
617
+ self._messages.clear()
618
+ self._release_capacity()
619
+ elif state.offers:
620
+ messages = [self._take_offer(state.offers)]
621
+ self._release_capacity()
622
+ else:
623
+ messages = []
624
+ self._release_capacity()
625
+ return Success(messages)
626
+
627
+ return suspend_exit(attempt)
628
+
629
+ def peek(self) -> Effect[A, E, Never]:
630
+ def attempt() -> Effect[A, E, Never]:
631
+ state = self._state
632
+ if isinstance(state, _Done):
633
+ return state.terminal
634
+ if self._messages:
635
+ return Success(self._messages[0])
636
+ return self._await_take(lambda: bool(self._messages)).flat_map(lambda _: self.peek())
637
+
638
+ return suspend(attempt)
639
+
640
+ def _await_raw(self) -> Effect[None, E, Never]:
641
+ def register(resume: _Resume[None, E]) -> Effect[None, Never, Never] | None:
642
+ state = self._state
643
+ if isinstance(state, _Done):
644
+ resume(state.terminal)
645
+ return None
646
+ token = state.awaiters.add(resume)
647
+ return sync(lambda: state.awaiters.remove(token))
648
+
649
+ return async_(register)
650
+
651
+ def size_unsafe(self) -> int:
652
+ return 0 if isinstance(self._state, _Done) else len(self._messages)
653
+
654
+ def is_full_unsafe(self) -> bool:
655
+ return self.size_unsafe() == self.capacity
656
+
657
+
658
+ def is_queue(value: object) -> TypeIs[Queue[object, object]]:
659
+ return isinstance(value, Queue)
660
+
661
+
662
+ def is_enqueue(value: object) -> TypeIs[Enqueue[object, object]]:
663
+ return isinstance(value, Enqueue)
664
+
665
+
666
+ def is_dequeue(value: object) -> TypeIs[Dequeue[object, object]]:
667
+ return isinstance(value, Dequeue)
668
+
669
+
670
+ __all__ = ["Dequeue", "Enqueue", "Queue", "is_dequeue", "is_enqueue", "is_queue"]