peer.acceptFrame() // DATA STREAM 3 "abcde"
    peer.acceptFrame() // HEADERS STREAM 3
    peer.play()

    // Play it back.
    val connection = connect(peer)
    val stream = connection.newStream(headerEntries("a", "android"), true)
    stream.enqueueTrailers(headersOf("foo", "bar"))
    val sink = stream.sink.buffer()
    sink.writeUtf8("abcdefghi")
    sink.close()

pkg p1, const FloatConst = 1.5  // 3/2
pkg p1, const FloatConst ideal-float
pkg p1, const StrConst = "foo"
pkg p1, const StrConst ideal-string
pkg p1, func Bar(int8, int16, int64)
pkg p1, func Bar1(int8, int16, int64) uint64
pkg p1, func Bar2(int8, int16, int64) (uint8, uint64)
pkg p1, func BarE() Error
pkg p1, func Now() Time
pkg p1, func PlainFunc(int, int, string) (*B, error)
pkg p1, func TakesFunc(func(int) int)
pkg p1, method (*B) JustOnB()

   *
   * <p>For example:
   *
   * {@snippet :
   * Streams.zip(
   *     Stream.of("foo1", "foo2", "foo3"),
   *     Stream.of("bar1", "bar2"),
   *     (arg1, arg2) -> arg1 + ":" + arg2)
   * }
   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one

   *
   * <p>For example:
   *
   * {@snippet :
   * Streams.zip(
   *     Stream.of("foo1", "foo2", "foo3"),
   *     Stream.of("bar1", "bar2"),
   *     (arg1, arg2) -> arg1 + ":" + arg2)
   * }
   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one

labels.profile_button=Pengaturan
labels.profile.title=Pengaturan
labels.profile.update=Perbarui
labels.profile.back=Kembali
labels.profile.placeholder_old_password=Kata Sandi Saat Ini
labels.profile.placeholder_new_password=Kata Sandi Baru
labels.profile.placeholder_confirm_new_password=Konfirmasi Kata Sandi Baru
labels.top.search=Cari
labels.index_title=Fess
labels.index_form_search_btn=Cari
labels.index_osdd_title=Cari

For a more "real life" example of this, imagine a bank.

Up to recently, most of the banks had multiple cashiers 👨‍💼👨‍💼👨‍💼👨‍💼 and a big line 🕙🕙🕙🕙🕙🕙🕙🕙.

All of the cashiers doing all the work with one client after the other 👨‍💼⏯.

And you have to wait 🕙 in the line for a long time or you lose your turn.

You probably wouldn't want to take your crush 😍 with you to run errands at the bank 🏦.

app = FastAPI()


@app.get("/items/stream-bare-async")
async def stream_bare_async() -> AsyncIterable:
    yield {"name": "foo"}


@app.get("/items/stream-bare-sync")
def stream_bare_sync() -> Iterable:
    yield {"name": "bar"}


client = TestClient(app)


def test_stream_bare_async_iterable():
    response = client.get("/items/stream-bare-async")
    assert response.status_code == 200

	if cap(b) != bp.wcap {
		// someone tried to put back buffer which is not part of this buffer pool
		// we simply don't put this back into pool, a modified buffer provided
		// by this package is no more usable, callers make sure to not modify
		// the capacity of the buffer.
		return
	}

	select {
	case bp.c <- b[:bp.w]:
		// buffer went back into pool
	default:
		// buffer didn't go back into pool, just discard
	}
}

   * @param max the upper bound (inclusive) of the range to constrain {@code value} to
   * @throws IllegalArgumentException if {@code min > max}
   * @since 21.0
   */
  // A call to bare "min" or "max" would resolve to our varargs method, not to any static import.
  @SuppressWarnings("StaticImportPreferred")
  public static int constrainToRange(int value, int min, int max) {

4. The daemon runs the request, sending back data such as logging output or tooling API events and intermediate models while doing so.
5. The daemon sends the result back. For some requests, this might be a simple success/failure result, and for others this might also include a more complex object, such as a tooling API model.