         }
     }
 
-    @inlinable public func reentrantChannelReception(_ element: Any) {
+    public func reentrantChannelReception(_ element: Any) {
         #if DEBUG_CHANNELZ
             //print("ChannelZ reentrant channel short-circuit; break on \(#function) to debug", type(of: element))
             ChannelZReentrantReceptions.increment()

#if !(os(Linux))
/// A `Lock` implementation that uses an `os_unfair_lock`
@available(macOS 10.12, iOS 10.0, *)
public final class UnfairLock : Lock {
    public var unfairLock = os_unfair_lock_s()

    @inlinable public init() {
    }

    @inlinable public var isReentrant: Bool {
        return false
    }

    @inlinable public func lock() {
        os_unfair_lock_lock(&unfairLock)
    }

    @inlinable public func unlock() {
        os_unfair_lock_unlock(&unfairLock)
    }

    @inlinable public func withLock<T>(_ f: () throws -> T) rethrows -> T {
        os_unfair_lock_lock(&unfairLock)
        defer { os_unfair_lock_unlock(&unfairLock) }
        return try f()
    }

    @inlinable public func tryLock<T>(_ f: () throws -> T) rethrows -> T? {
        if !os_unfair_lock_trylock(&unfairLock) { return nil }
        defer { os_unfair_lock_unlock(&unfairLock) }
        return try f()

    }

    /// Adds a receiver that will return a receipt that simply removes itself from the list
    public func addReceipt(_ receptor: @escaping Receptor) -> Receipt {
        let token = addReceiver(receptor)
        return ReceiptOf(canceler: { self.removeReceptor(token) })
    }

    /// Adds a custom receiver block and returns a token that can later be used to remove the receiver
    public func addReceiver(_ receptor: @escaping Receptor) -> Int64 {
        precondition(entrancy.get() == 0, "cannot add to receivers while they are flowing")
        let index = receptorIndex.increment()
        receivers.append((index, receptor))
        return index
    }

    public func removeReceptor(_ index: Int64) {
        receivers = receivers.filter { $0.index != index }
    }

    /// Clear all the receivers
    public func clear() {
        receivers = []
    }
}

open class ReceiverQueueSource<T> {
    let receivers = ReceiverQueue<T>()
}

/// A Lock used for synchronizing access to the receiver queue
protocol Lock {
    init()
    func lock()
    func unlock()
