if (failed(GetOp(region, &recv_op))) return failure();

  SendTPUEmbeddingGradientsOp send_op;
  if (failed(GetOp(region, &send_op))) return failure();

  // No TPU embedding ops.
  if (!recv_op && !send_op) return success();

  Location loc = recv_op ? recv_op.getLoc() : send_op.getLoc();
  StringRef config = recv_op ? recv_op.getConfig() : send_op.getConfig();

  // Create XlaRecvTPUEmbeddingDeduplicationData op.

	c := make(chan T)
	d := make(chan bool)
	s := &Sender[T]{values: c, done: d}
	r := &Receiver[T]{values: c, done: d}
	runtime.SetFinalizer(r, r.finalize)
	return s, r
}

// A sender is used to send values to a Receiver.
type Sender[T any] struct {
	values chan<- T
	done <-chan bool
}

// Send sends a value to the receiver. It returns whether any more

	default:
		panic("Exclusive Release without Acquire")
	}
}

// Ranger returns a Sender and a Receiver. The Receiver provides a
// Next method to retrieve values. The Sender provides a Send method
// to send values and a Close method to stop sending values. The Next
// method indicates when the Sender has been closed, and the Send
// method indicates when the Receiver has been freed.
//

apiVersion: release-notes/v2
kind: feature
area: networking
releaseNotes:
- |

    public void execute(WorkerProcessContext workerProcessContext) {
        TestListenerInterface sender = workerProcessContext.getServerConnection().addOutgoing(TestListenerInterface.class);
        workerProcessContext.getServerConnection().connect();
        sender.send("other 1", 1);
        sender.send("other 2", 2);
    }

			need := tpl.MissingParams(s.Params())
			needFrom := need.Contains(param.From.String())
			needTo := need.Contains(param.To.String())

			if needFrom && needTo {
				out.needFromAndTo = append(out.needFromAndTo, s)
			} else if needFrom {
				out.needFrom = append(out.needFrom, s)
			} else if needTo {
				out.needTo = append(out.needTo, s)
			} else {
				// No well-known parameters are missing.

	c, err := smtp.Dial("mail.example.com:25")
	if err != nil {
		log.Fatal(err)
	}

	// Set the sender and recipient first
	if err := c.Mail("sender@example.org"); err != nil {
		log.Fatal(err)
	}
	if err := c.Rcpt("******@****.***"); err != nil {
		log.Fatal(err)
	}

	// Send the email body.
	wc, err := c.Data()
	if err != nil {
		log.Fatal(err)
	}

Das bedeutet, dass anstelle des normalen Prozesses, bei dem Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre Anwendung) **Requests an deren System** (an deren API, deren Anwendung) senden könnte.

Das wird normalerweise als **Webhook** bezeichnet.

## Webhooks-Schritte

            throw new RuntimeException(e);
        }

        // Send some messages
        TestListenerInterface sender = workerProcessContext.getServerConnection().addOutgoing(TestListenerInterface.class);
        workerProcessContext.getServerConnection().connect();
        sender.send("message 1", 1);
        sender.send("message 2", 2);
    }

func (m *Map[K, V]) InOrder() *Iterator[K, V] {
	sender, receiver := chans.Ranger[keyValue[K, V]]()
	var f func(*node[K, V]) bool
	f = func(n *node[K, V]) bool {
		if n == nil {
			return true
		}
		// Stop sending values if sender.Send returns false,
		// meaning that nothing is listening at the receiver end.
		return f(n.left) &&
                        // TODO
			// sender.Send(keyValue[K, V]{n.key, n.val}) &&
			f(n.right)
	}