select {
	case <-ctx.Done():
		return false
	case s.values <- v:
		return true
	case <-s.done:
		return false
	}
}

// Close tells the receiver that no more values will arrive.
// After Close is called, the Sender may no longer be used.
func (s *Sender[Elem]) Close() {
	close(s.values)
}

// A Receiver receives values from a Sender.
type Receiver[Elem any] struct {

network namespace processes always take the output path, while packets coming in from
outside the host network namespace (whether that's from an external host or from a pod
network namespace) arrive via `ingress` and take the input or forward path, depending on
the routing decision made after `prerouting`; packets destined for an IP which is assigned

      enable_large_batch_splitting = false,
      Tin = [i32],
      Tcaptured = [i32],
      Tout = [i32]} : 1

  // Since batch function kernel scheduling is async, the above 2 batches can arrive in any order.
  // CHECK: Running @matmul_cpu
  // CHECK-NEXT: Tensor<type: int32 shape: [4,2] values: [[value_output:.*]]>

  // CHECK: Tensor<type: int32 shape: [2,2] values: [4 4]

			`ConstTwo = 2`,                     // No second entry in constant block.
			`VarTwo = 2`,                       // No second entry in variable block.
			`VarFive = 5`,                      // From block starting with unexported variable.
			`type unexportedType`,              // No unexported type.
			`unexportedTypedConstant`,          // No unexported typed constant.

		call.AuxInt = stksize // Call operations carry the argsize of the callee along with them
	}
	s.prevCall = call
	s.vars[memVar] = s.newValue1I(ssa.OpSelectN, types.TypeMem, int64(len(ACResults)), call)
	// Insert VarLive opcodes.
	for _, v := range n.KeepAlive {
		if !v.Addrtaken() {
			s.Fatalf("KeepAlive variable %v must have Addrtaken set", v)
		}
		switch v.Class {
		case ir.PAUTO, ir.PPARAM, ir.PPARAMOUT:
		default:

# The update should bring the version required by b, not the latest version of c.

go list -m example.com/c
stdout '^example.com/c v0.1.0 '

cmp go.mod go.mod.b


# We should reach the same state if we arrive at it via `go test -mod=mod`.

cp go.mod.117 go.mod

[short] go list -mod=mod -test -deps example.com/a
[!short] go test -mod=mod -c -o $devnull example.com/a

[short] go list -mod=mod -test -deps example.com/b

		assertTick()
		Sleep(sched)
		tim.Reset(10000 * Second)
		drainAsync()
		noTick()

		// Test that len sees an immediate tick arrive
		// for Reset of timer in heap.
		tim.Reset(1)
		assertLen()
		assertTick()

		// Test that len sees an immediate tick arrive
		// for Reset of timer NOT in heap.
		tim.Stop()
		drainAsync()
		tim.Reset(1)
		assertLen()
		assertTick()
	}

	select {
	case <-ctx.Done():
		return false
	case s.values <- v:
		return true
	case <-s.done:
		return false
	}
}

// Close tells the receiver that no more values will arrive.
// After Close is called, the Sender may no longer be used.
func (s *Sender[Elem]) Close() {
	close(s.values)
}

// A Receiver receives values from a Sender.
type Receiver[Elem any] struct {

			}

			// close body because the handler might block in Flush, unable to send the remaining event.
			response.Body.Close()

			// wait for events to arrive, at least the given number in the test
			events := []*auditinternal.Event{}
			err = wait.Poll(50*time.Millisecond, testTimeout(t), wait.ConditionFunc(func() (done bool, err error) {
				events = sink.Events()

The application-layer can also do blocking reads. If the application asks to read and there's nothing available, we need to hold that thread until either the bytes arrive, the stream is closed, or a timeout elapses. If we get bytes but there's nobody asking for them, we buffer them. We don't consider bytes as delivered for flow control until they're consumed by the application.