Tutorial REPL Scala
Gunakan REPL untuk meneroka Raider daripada Scala: cuba permintaan ejen, ubah jawapannya, bandingkan dua ulasan, atau kekalkan perbualan ringkas. Contoh di bawah menggunakan checkout sumber semasa dan ikatan terbina dalam scout serta worker.
Mulakan REPL
Dari akar repositori, bina contoh pengguna dan mulakan REPL disokong pengkompil dalam mod mock:
sh scripts/build/user-examples.sh
RAIDER_CP=$(cat artifacts/user-examples/classpath.txt)
RAIDER_PROVIDER=mock java -cp "$RAIDER_CP" raider.repl.Main
Pada prom raider>, masukkan Scala. Ikatan kekal tersedia dalam penghantaran kemudian sehingga anda menjalankan :reset. Hantar definisi berbilang baris dengan baris kosong. Contohnya:
case class Check(name: String, passed: Boolean)
val checks = List(Check("compile", true), Check("tests", false))
checks.filterNot(_.passed).map(_.name)
Ungkapan akhir dinilai kepada List("tests"). Untuk mencuba penyedia sebenar, ikuti persediaan penyedia dan konfigurasikan endpoint, model, dan kelayakannya dalam persekitaran peribadi anda sebelum memulakan REPL.
Untuk Raider mengubah dan menyemak kod dalam projek pakai buang, ikuti pembaikan pengebilan luar talian. Ia menggunakan stand berskrip dan arahan kompil/ujian Scala yang bebas; permintaan REPL mock ringkas di atas tidak mengubah file.
Buat satu permintaan
Panggil ask untuk permintaan yang patut dijalankan serta-merta:
scout.ask("Explain what a failed test means in one sentence")
Panggilan memulangkan jawapan pembantu sebagai String. Dalam mod mock jawapan ialah teks berskrip tetap; ia tidak memeriksa projek anda. Penyedia langsung yang dikonfigurasi membekalkan respons sebaliknya.
[]
Sediakan ask malas, kemudian petakan hasilnya
{#prepare-a-lazy-ask-then-map-its-result}
Memanggil scout(prompt) mencipta AgentAsk[String] tanpa menghantar permintaan. Gunakan :type untuk memeriksanya, kemudian panggil .run() apabila anda mahu jawapan. .map mengubah jawapan yang akan datang dan mengekalkan ask sebagai malas.
val ask = scout("Summarize the parser entry point")
:type ask
val answer: String = ask.run()
val answerLength = scout("Summarize the parser entry point").map(_.length)
:type answerLength
val length: Int = answerLength.run()
Pertanyaan jenis melaporkan AgentAsk[String] dan AgentAsk[Int]. Kedua-dua panggilan .run() melaksanakan permintaan; yang dipetakan memulangkan kiraan aksara jawapan. :type mengompil ungkapan tetapi tidak menilainya. Versi boleh jalan contoh ini ialah 02lazy-map.repl.
Minta ulasan dan pelan ujian secara selari
Cipta dua ask malas dan labelkan hasilnya dengan map. all(...).run() memulangkan kedua-dua hasil sebagai tuple:
val code = "if subtotalCents > 10000 then 1000 else 0"
val policy = "A 1000-cent discount applies at 10000 cents and above."
val reviewAsk = scout(
s"$policy Review this expression: $code. Give one boundary counterexample. Do not use tools."
).map(answer => ("review", answer))
val testAsk = worker(
s"$policy Return expected [subtotalCents, discountCents] pairs for " +
"9999, 10000, and 10001. Return only JSON; do not use tools."
).map(answer => ("tests", answer))
val (review, testPlan) = all(reviewAsk, testAsk).run()
review._1 // "review"
testPlan._1 // "tests"
Label tuple menunjukkan jawapan mana milik setiap permintaan. Dalam mod mock, rentetan jawapan ialah balasan fixture tetap; contoh ini menunjukkan komposisi Scala, bukan kualiti ulasan. Fixture ulasan pengebilan mengandungi prompt dan semakan respons yang lebih penuh.
Ulas beberapa item dengan kelompok terhad
Gunakan batch(inputs, parallelism)(f) apabila setiap input memerlukan ask sendiri. Ia memulangkan hasil dalam susunan input dan tidak menjalankan lebih daripada bilangan yang diminta secara serentak.
val areas = List("boundary", "integer cents", "test coverage")
val notes = batch(areas, parallelism = 2) { area =>
scout(s"Review $area in this expression: $code. Give one observation; do not use tools.")
.map(answer => area -> answer)
}.run()
notes.map(_._1) // List("boundary", "integer cents", "test coverage")
Setiap hasil ialah pasangan (String, String) yang mengandungi label input dan respons. Fixture kelompok menunjukkan hasil tersusun menggunakan penyedia berskrip.
Jalankan kerja latar
Gunakan .start(prompt) untuk mendapat pemegang kerja serta-merta. await memulangkan hasilnya; ia boleh dipanggil semula untuk memerhati hasil selesai yang sama. cancel() meminta pembatalan dan memulangkan false jika kerja sudah terminal.
val job = worker.start("Review the parser for an empty-input bug. Do not use tools.")
job.id
val result = job.await
Gunakan :jobs untuk menyenaraikan kerja fasad dan ID mereka. Untuk batal mengikut ID, masukkan :cancel <id>; untuk memeriksa jejak kerja, gunakan :log <id>. Pembatalan tidak boleh membuat asal kesan luaran yang sudah berlaku. Lihat fixture kerja latar.
Kekalkan perbualan dalam memori
openSession(agent) mencipta Chat. Setiap ask yang berjaya menambah mesej pengguna dan balasan pembantu; ask seterusnya menerima sejarah perbualan itu.
val chat = openSession(worker)
val first = chat.ask("Review this parser: def parsePort(raw: String): Int = raw.toInt")
val second = chat.ask("What happens for an empty string?")
chat.messages.size // 4: two user messages and two replies
Sejarah milik objek Chat ini dalam proses REPL semasa. Ia tidak disimpan antara proses, dan Chat tidak mempunyai kaedah close(). Balasan mock ialah teks tetap dan tidak menunjukkan bahawa model menggunakan giliran terdahulu. Fixture sesi menunjukkan kes berskrip.
Sambungkan peringkat bertip dengan andThen
Program[I, O] menerangkan peringkat daripada jenis input I ke jenis output O. andThen menyambungkan peringkat apabila jenis output pertama sepadan dengan jenis input seterusnya. Menggunakan program yang digubah mencipta Task; pelari mentafsir task itu.
import raider.core.{Program, Task}
val parseCount: Program[String, Int] =
Program.fromFunction("parse-count")(text => Task.succeed(text.toInt))
val describeCount: Program[Int, String] =
Program.fromFunction("describe-count")(count => Task.succeed(s"count=$count"))
val describeInput: Program[String, String] = parseCount.andThen(describeCount)
val pending: Task[String] = describeInput("3")
Saluran Scala tulen ini tidak membuat permintaan model. Untuk aliran kerja bertip yang boleh laksana, lihat TaskSummary.scala dan panduan bundle bertip. Ia menggubah dua peringkat Program, kemudian menjalankannya melalui pelari bundle.
Dalam REPL, :help menyenaraikan arahan. Konsol semasa menyokong :type <expression>, :jobs, :cancel <id>, :log <id>, :reset, dan :quit (juga :q dan :exit). Tiada arahan :session; gunakan openSession dalam Scala. JobHandle.send(message) kini melempar CapabilityUnsupported, jadi kerja yang sedang berjalan tidak boleh dihala daripada fasad ini.
Kod ejen dan alat berjalan dengan kebenaran proses Raider. Dasar alat terpakai pada panggilan melalui masa jalan ejen; ia bukan kotak pasir untuk Scala arbitrari yang dimasukkan dalam REPL.
Contoh DSL di sini berjalan melalui REPL. Unjuran salasilah yang dijana ialah penerangan struktur yang direkodkan, bukan main semula; lihat panduan salasilah untuk perbezaan antara akar CI langsung dan unjuran bersatu yang dijana secara berasingan.