√ Berguru Bahasa Pemrograman Bosque Dengan Lengkap

Apa itu Bahasa Pemrograman Bosque?

Bahasa Bosque adalah berasal dari kombinasi sintaksis tipeScript dan tipe plus semantik yang terinspirasi ML dan Node / JavaScript. Dokumen ini menawarkan ikhtisar perihal sintaks, operasi, dan semantik dalam bahasa Bosque dengan pementingan pada fitur khas atau tidak biasa dalam bahasa.

Pengertian Bahasa Bosque?

Bahasa pemrograman Bosque dirancang untuk menulis instruksi yang sederhana, jelas, dan gampang digunakan untuk insan dan mesin. Desain ini sangat didorong oleh identifikasi dan pembatalan aneka macam sumber kompleksitas yang tidak disengaja dan wawasan perihal bagaimana mereka sanggup dikurangi melalui desain bahasa yang bijaksana.[.blog]

Bagian ini menyoroti dan berisi isu perihal banyak fitur dan pilihan desain yang paling populer dan / atau unik dalam bahasa pemrograman Bosque.

Baca Juga cara membuat game snake keren terbaru dengan Javascript

Mengenal Syntax-Syntax dalam Bahasa Pemprograman Bosque

1. Nilai Tidak Berubah Bosque

Semua nilai dalam bahasa Bosque tidak sanggup diubah!

Memikirkan dan memahami imbas dari pernyataan atau blok instruksi sangat disederhanakan ketika itu imbas samping gratis. Bahasa fungsional telah usang diuntungkan dari penyederhanaan untuk pengembangan program, perkakas canggih, dan optimisasi kompiler berangasan yang dimungkinkan oleh model ini. Dari perspektif ini, pilihan alami untuk bahasa Bosque yaitu mengadopsi model fungsional murni dengan data yang tidak sanggup diubah.[becakcode.site]

2 Block Scoping Dalam Bosque

Variabel lokal dengan instruksi blok terstruktur yaitu model yang sangat menarik untuk menyusun kode. Bahasa Bosque memadukan pemrograman fungsional dengan cakupan blok dan {...} kurung dengan memungkinkan beberapa penugasan untuk variabel yang sanggup diupdate var! (6.3 Penugasan Variabel). Ini mendukung pemrograman gaya fungsional dalam bahasa yang dicakup blok dan memungkinkan pengembang untuk menulis instruksi seperti:

function abs(x: Int): Int {     var! sign = 1; //declare updatable variable with initial value     if(x < 0) {         sign = -1; //update the variable      }      return x * sign;  }

3 Referensi Parameter Threading Dalam Bosque

[Belum Diterapkan]

Selain memungkinkan beberapa penugasan ke variabel, bahasa Bosque juga memungkinkan pengembang untuk mengulir parameter melalui lewat argumen ref. Alternatif nilai multi-pengembalian ini menyederhanakan skenario di mana variabel (seringkali semacam lingkungan) diteruskan ke metode yang sanggup memakai dan memperbaruinya. Mengizinkan pembaruan dalam parameter menghilangkan administrasi nilai pengembalian ekstra yang seharusnya diperlukan:
[becakcode.site]

function internString(ref env: Map<String, Int>, str: String): Int {     if(env.has(str)) {     //use the ref parameter         return env.get(str);     }     env = env.add(str, env.size()); //update the ref parameter     return env.size(); }

4 Type String Dalam Pemrograman Bosque

String dalam pemrograman bosque menyediakan prosedur gres untuk mengangkat struktur yang diketahui perihal isi string ke dalam tipe dengan cara yang berarti bagi insan dan yang sanggup digunakan oleh pemeriksa tipe (). Ini memungkinkan instruksi menyerupai berikut ini:

function foo(zip: String[Zipcode], name: String) {...} var zc: String[Zipcode] = ...; var user: String = ...; foo(user, zc) //Type error String not convertible to String[Zipcode] foo(zc, user) //ok

5 Invokasi Fleksibel Bosque

menawarkan argumen berjulukan bersama dengan operator lainnya dan spread. Ini sanggup digunakan untuk melaksanakan manipulasi data yang sederhana dan berpengaruh sebagai penggalan dari doa dan operasi konstruktor ().[becakcode.site]

function nsum(d: Int, ...args: List[Int]): Int {     return args.sum(default=d); } function np(p1: Int, p2: Int): {x: Int, y: Int} {     return @{x=p1, y=p2}; } //calls with explicit arguments var x = nsum(0, 1, 2, 3); //returns 6 var a = np(1, 2);         //returns @{x=1, y=2} var b = np(p2=2, 1);      //also returns @{x=1, y=2} //calls with spread arguments var t = @[1, 2, 3]; var p = nsum(0, ...t);    //returns 6 -- same as explicit call var r = @{p1=1, p2=2}; var q = np(...r);         //returns @{x=1, y=2} -- same as explicit call

6 Operasi Data Aljabar Di Bosque

Operasi aljabar di Bosque dimulai dengan sumbangan untuk pembacaan massal dan pembaruan nilai data. Pertimbangkan masalah umum mempunyai struct dengan 3 bidang di mana 2 di antaranya perlu diperbarui. Dalam kebanyakan bahasa ini perlu dilakukan menurut lapangan-per-bidang. Namun dengan operasi data massal dimungkinkan untuk melaksanakan pembaruan sebagai operasi atom (tidak menyerupai gaya imperatif) dan tanpa secara manual mengekstraksi dan menyalin bidang (seperti dalam gaya fungsional).[becakcode.site]

var x = @{f=1, g=2, h=3}; x< (f=-1, g=-2); //@{f=-1, @g=-2, h=3}

In addition to eliminating opportunities to forget or confuse a field these operators help focus the code on the overall intent, instead of being hidden in the individual steps, and allow a developer to perform algebraic reasoning on the data structure operations. Bosque provides several flavors of these algebraic operations for various data types, tuples, records, and nominal types, and for various operations including projection, multi-update, and merge.

var l = @[7, 8, 9]; var r = @{f=7, g=8}; l@[0, 2];     //@[7, 9] l<+(@[5, 6]); //@[7, 8, 5, 6] l#[Int, Int]; //@[7, 8] r@{f, h};         //@{f=1, h=none} r< (f=5, h=1);    //@{f=5, g=8, h=1} r<+(@{f=5, h=1}); //@{f=5, g=8, h=1}

7 None Processing Di Bosque

Menangani nilai tidak ada yaitu kiprah yang relatif umum yang sanggup mengaburkan maksud fundamental dari penggalan instruksi dengan sarang masalah dan penanganan kondisional untuk masalah khusus. Untuk menyederhanakan jenis instruksi ini, Bosque menyertakan aneka macam bentuk penggabungan atau operator korelasi singkat ((5.8 Tidak Ada-Rantai) [# 5.8 Tidak Ada-Rantai]) untuk mengaktifkan instruksi seperti:[becakcode.site]

function foo(val?: {tag: Int, value?: String}): String {     return val?.value ?| "[No Value]"; }

8 Pemrosesan Iteratif

Konsep dasar dalam bahasa pemrograman yaitu konstruk iterasi dan pertanyaan kritis yaitu apakah konstruk ini disediakan sebagai fungsi tingkat tinggi, menyerupai filter / peta / kurangi, atau apakah programmer mendapat manfaat dari fleksibilitas yang tersedia dengan iteratif, sementara atau untuk, konstruksi perulangan.[becakcode.site]

Untuk menjawab pertanyaan ini secara definitif, para penulis Mining Idantic Loop Semantic terlibat dalam studi semua "idiom" loop yang ditemukan dalam instruksi dunia nyata. Hasil kategorisasi dan cakupan memperlihatkan bahwa hampir setiap loop yang ingin ditulis oleh pengembang termasuk dalam sejumlah kecil pola idiomatik yang sesuai dengan konsep tingkat tinggi yang digunakan pengembang dalam kode, misalnya, filter, cari, grup, peta, dll. Dengan ini menghasilkan pikiran bahasa Bosque memperdagangkan loop terstruktur untuk serangkaian konstruksi pemrosesan berulang tingkat tinggi (dan).

var v: List[Int?] = List@{1, 2, none, 4}; //Chained - List@{1, 4, 16} v.filter(fn(x) => x != none).map[Int](fn(x) => x*x) //Piped none filter - List@{1, 4, none, 16} v |> filter(fn(x) => x != none) |> map[Int](fn(x) => x*x) //Piped with noneable filter - List@{1, 4, 16} v |??> map[Int](fn(x) => x*x) //Piped with none to result - List@{1, 4, none, 16} v |?> map[Int](fn(x) => x*x)

Menghilangkan pelat dari penulisan loop yang sama berulang kali menghilangkan seluruh kelas kesalahan termasuk, mis. membatasi perhitungan, dan memperjelas maksudnya dengan functor yang dinamai secara deskriptif alih-alih mengandalkan seperangkat pola loop yang diketahui bersama. Yang penting, untuk mengaktifkan validasi dan meningkatkan secara optimal jadwal otomatis, menghilangkan loop juga menghilangkan kebutuhan untuk menghitung loop-invarian. Sebagai gantinya, dan dengan desain perpustakaan koleksi yang cermat, dimungkinkan untuk menulis transformer yang sempurna untuk setiap functor. Dalam hal ini perhitungan postkondisi terkuat atau prekondisi terlemah menghindari kompleksitas menghasilkan loop invarian dan sebagai gantinya menjadi masalah sederhana dan deterministik yang mendorong formula!

9 Rekursi

Kurangnya konstruksi perulangan eksplisit, dan adanya fungsi pemrosesan koleksi, tidak biasa dalam bahasa fungsional. Namun, hasilnya seringkali berupa penggantian struktur loop kompleks dengan struktur rekursi kompleks. Aliran mentah yang kompleks mengaburkan maksud instruksi dan menghalangi analisis dan perkakas otomatis, terlepas dari apakah fatwa itu loop atau rekursi.
[becakcode.site]
Dengan demikian, Bosque dirancang untuk mendorong penggunaan rekursi terbatas, meningkatkan kejelasan struktur rekursif, dan memungkinkan kompiler / runtime untuk menghindari kesalahan terkait tumpukan. Hal ini dilakukan dengan memperkenalkan kata kunci rec yang digunakan di kedua situs deklarasi untuk memperlihatkan fungsi / metode rekursif dan lagi di situs panggilan sehingga menegaskan bahwa penelepon menyadari sifat rekursif panggilan (7 Invokable-Declarations) ).

10 Penentuan

Ketika sikap blok instruksi kurang ditentukan, hasilnya yaitu instruksi yang lebih sulit untuk dipikirkan dan lebih rentan terhadap kesalahan. Sebagai tujuan utama dari bahasa Bosque yaitu untuk menghilangkan sumber kompleksitas yang tidak dibutuhkan yang mengarah pada kebingungan dan kesalahan, kami tentu saja ingin menghilangkan sikap yang tidak ditentukan ini. Dengan demikian, Bosque tidak mempunyai sikap tidak terdefinisi menyerupai membiarkan variabel yang tidak diinisialisasi membaca dan menghilangkan semua di bawah sikap yang ditetapkan juga termasuk stabilitas penyortiran dan semua koleksi asosiatif (set dan peta) mempunyai urutan enumerasi yang tetap dan stabil.[becakcode.site]

Sebagai hasil dari pilihan desain ini, selalu ada hasil yang unik dan kanonik untuk setiap jadwal Bosque. Ini berarti bahwa pengembang tidak akan pernah melihat kegagalan produksi berselang-seling atau tes unit flakey!

11 Kesetaraan dan Representasi

Kesetaraan yaitu konsep multifaset dalam pemrograman dan memastikan sikap yang konsisten di banyak bidang yang sanggup muncul dalam bahasa pemrograman modern menyerupai ==, .equals, Set.has, List.sort, yaitu sumber bug halus. Kompleksitas ini lebih jauh memanifestasikan dirinya dalam kebutuhan untuk mempertimbangkan kemungkinan korelasi aliasing nilai, di samping data struktural mereka, untuk memahami sikap suatu blok kode. Fakta bahwa rujukan kesetaraan dipilih sebagai default, atau merupakan opsi, juga sedikit anakronisme sebab kesetaraan rujukan sangat mengikat sanksi ke model perangkat keras di mana objek terkait dengan lokasi memori.
[becakcode.site]

Mengingat duduk masalah ini, bahasa Bosque tidak memungkinkan persamaan rujukan yang terlihat oleh pengguna dalam operasi apa pun termasuk == atau operasi kontainer. Alih-alih, kesetaraan didefinisikan baik oleh bahasa inti untuk primitif Bool, Int, String, GUID, dll., Atau sebagai jenis kunci kunci komposit yang ditentukan pengguna (5,21 Equality Comparison). Jenis kunci komposit memungkinkan pengembang untuk membuat jenis yang berbeda untuk mewakili nilai sebanding kesetaraan komposit yang menawarkan gagasan perihal kesetaraan, mis. identitas, kunci utama, kesetaraan, dll. yang masuk kebijaksanaan untuk domain mereka. Bahasa ini juga memungkinkan jenis untuk menentukan bidang kunci yang akan digunakan untuk kesetaraan / pesanan oleh wadah asosiatif dalam bahasa ().

12 Kesalahan dan Pemeriksaan

Tujuan utama dari bahasa Bosque yaitu menyederhanakan proses membangun perangkat lunak dengan keandalan tinggi. Sebagai penggalan dari ini, bahasa menyediakan sumbangan kelas satu untuk mengekspresikan aneka macam invarian, investigasi kewarasan, dan pernyataan diagnostik.

entity Foo {     field x: Int;     invariant x > 0; //check whenever a Foo is constructed     method m(y: Int): Int         requires y >= 0; //precondition         ensures _result_ > 0; //postcondition     {         check this.x - y > 0;   //sanity check - enabled on optimized builds         assert this.x * y != 0; //diagnostic assert - only for test/debug         return x * y;     }

13 Konstruktor dan Pabrik Atom

Untuk mengurangi jumlah instruksi boilerplate yang diperkenalkan oleh konstruktor, dan khususnya konstruktor yang mempunyai daftar argumen panjang yang terutama diteruskan ke super konstruktor, Bosque memakai konstruksi melalui inisialisasi bidang pribadi untuk membangun nilai entitas (objek). Untuk banyak kegunaan, pendekatan penginisialisasi pribadi sederhana ini sudah cukup dan tidak perlu untuk konstruktor kompleks yang menghitung nilai turunan sebagai penggalan dari sanksi konstruktor.[becakcode.site]

Namun, kadang kala berkhasiat untuk merangkum logika inisialisasi dan, untuk mencapai ini, kami mengizinkan definisi fungsi pabrik yang beroperasi menyerupai dengan konstruktor tetapi, dalam beberapa hal, terbalik. Fungsi pabrik mengembalikan catatan dengan semua bidang yang dibutuhkan untuk entitas / konsep terlampir

(5.5 Entity Constructors).

concept Bar {     field f: Int;     factory default(): {f: Int} {         return @{f=1};     } } entity Baz provides Bar {     field g: Int;     field h: Bool = true;     factory identity(i: Int): {f: Int, g: Int} {         return @{f=i, g=i};     } } var x = Baz@{f=1, g=2}; var y = Baz@{f=1, g=2, h=false}; var p = Baz@identity(1); //equivalent to Baz@{...Baz::identity(1)} var q = Baz@{...Bar::default(), g=2};

Dalam instruksi ini dua entitas Baz dialokasikan melalui konstruktor inisialisasi atom. Dalam masalah pertama, bidang h yang dihilangkan diatur ke nilai default true yang diberikan. Pabrik identitas mendefinisikan nilai-nilai f dan g untuk entitas melalui catatan yang dikembalikan. Ketika dipanggil dengan sintaks konstruktor ini cocok untuk penginisialisasi atom dengan hasil pabrik.

Dengan desain ini kebutuhan untuk melewatkan data melalui panggilan super dihilangkan sebab data sanggup pribadi dimasukkan ke dalam penginisialisasi atau, kalau konstruktor super mempunyai logika pabrik, maka pabrik super sanggup dipanggil dan hasilnya diperluas pribadi ke konstruktor atom menyerupai pada p = Baz @ {} ... Bar :: default (), g = 2}. Hasil dari logika konstruktor terbalik ini yaitu bahwa hanya argumen yang dibutuhkan untuk perhitungan internal dari nilai inisialisasi yang harus disebarkan sementara semua yang lain sanggup pribadi diatur dalam initializer. Penghapusan instruksi boiler konstruktor dan pengurangan lewat argumen menyederhanakan definisi tipe nominal gres serta dampak perubahan cascading ketika bidang (atau argumen konstruktor) ditambahkan / dihapus dalam definisi dasar.[becakcode.site]

14 Blok Sintesis

[Belum Diimplementasikan]

1 Jenis Sistem

Bahasa Bosque mendukung sistem tipe yang sederhana dan tidak mempunyai pendapat yang memungkinkan pengembang untuk memakai aneka macam tipe struktural, nominal, dan kombinasi untuk memberikan maksud mereka dan secara fleksibel mengkodekan fitur yang relevan dari domain masalah.

Notasi: Sebagai penggalan dari menggambarkan sistem tipe kami memakai notasi berikut yang bukan merupakan penggalan dari bahasa Bosque:

T1 <: T2 //Type T1 is a subtype of T2 T1 <! T2 //Type T1 is not a subtype of T2 T1 === T2 //Type T1 is equal to T2

1.1 Jenis Nominal

Sistem tipe nominal sebagian besar merupakan desain berorientasi objek standar dengan polimorfisme parametrik yang disediakan oleh obat generik. Semua nama tipe harus dimulai dengan karakter kapital - MyType yaitu nama tipe yang valid sedangkan myType tidak.

Pengguna sanggup mendefinisikan tipe abnormal (TODO), deklarasi konsep, yang memungkinkan definisi abnormal dan implementasi yang sanggup diwarisi untuk anggota const (TODO), fungsi statis (TODO), anggota bidang (TODO), dan anggota metode virtual (TODO). Tipe-tipe konsep Bosque sepenuhnya abnormal dan tidak pernah sanggup digunakan secara konkret. Jenis entitas sanggup menawarkan konsep serta mengesampingkan definisi di dalamnya dan sanggup digunakan secara faktual tetapi tidak pernah sanggup diwarisi lebih lanjut.[becakcode.site]

Pengembang sanggup alias mengetik atau membuat tipe khusus (TODO) memakai typedef, enum, dan ckey constructs (TODO).

Pustaka inti Bosque mendefinisikan beberapa konsep / entitas unik. Tipe Any yaitu tipe uber yang semua subtipe lainnya, tipe None dan Some yaitu untuk membedakan nilai none yang unik, dan Tuple, Record, dll. Ada untuk menyatukan dengan sistem tipe struktural (). Bahasa ini mempunyai primitif untuk Bool, Int, String, dll. Serta kumpulan tipe parametrik yang diharapkan menyerupai Daftar [T] Peta [K, V] ().

Contoh jenis nominal termasuk:

 MyType       //user declared concept or entity Some         //core library declared concept NSCore::Some //core library concept with explicit namespace scope List[Int]    //core collection with generic parameter Int>

1.1.1 Jenis Relasi pada Tipe Nominal

Hubungan subtipe pada tipe nominal T1 dan T2 yaitu korelasi pewarisan parametrik standar di mana T1 <: T2 kalau ada di antara yang benar:

 T1 === T2 T1 provides T3 && T3 <: T2 (8 Concept and Entity Declarations) T1 === B1[G1] && T2 === B2[G2] && B1 === B2 && G1 <: G2

Kasus pertama yaitu kalau kedua jenis nama yang identik secara sintaksis. Kasus kedua meliputi situasi di mana T1 dinyatakan untuk menawarkan konsep yang, secara transitif, merupakan subtipe dari T2. Kasus terakhir yaitu korelasi subtipe parametrik standar pada parameter generik. Beberapa contohnya termasuk:[becakcode.site]

MyType <: MyType //true - by case 1
Some <: Any //true - Some provides Any
Int <: Bool //false - no suitable `T3` for case 2
List[Int] <: List[Any] //true - Int <: Any
List[Int] <: List[Bool] //false - Int <! Bool
List[Int] <: Collection[Int] //true - List[T] provides Collection[T]

Perhatikan bahwa korelasi subtipe kovarian sebab semua tipe generik subtipe pada parameter. Ini selalu kondusif sebab semua tipe data di Bosque tidak sanggup diubah ().

1.1.2 String Yang Diketik

String yang diketik menyediakan prosedur gres untuk mengangkat struktur yang diketahui perihal isi string ke dalam tipe dengan cara yang berarti bagi insan dan yang sanggup digunakan oleh pemeriksa tipe. Jika jenis Ty dinyatakan untuk menawarkan konsep Parsable, yang mempunyai metode statis tryParse (str: String): Ty | Tidak ada maka dimungkinkan untuk mendeklarasikan tipe nilai string sebagai String [Ty] yang memperlihatkan bahwa panggilan Ty :: tryParse mengembalikan Ty (bukan None).

Ini mengikat tipe string ke entitas dan kemudian, dengan ekstensi, ke dalam sistem tipe yang lebih besar. Jika kita mempunyai tipe korelasi Ty <: Ty2 maka pemeriksa tipe akan mengizinkan String [Ty] <: String [Ty2] dan tentu saja String [Ty] <: String.

Ini memungkinkan instruksi menyerupai berikut ini:
function foo(zip: String[Zipcode], name: String) {...}

var zc: String[Zipcode] = ...; var user: String = ...; foo(user, zc) //Type error String not convertible to String[Zipcode] foo(zc, user) //ok

1.2 Jenis Struktural

Sistem tipe struktural meliputi Tuples dan Records. Ini menggambarkan diri sendiri, memungkinkan untuk entri opsional dengan? sintaks, dan sanggup ditentukan sebagai tertutup atau terbuka memakai ... sintaks.[becakcode.site]

1.2.1 Tuples

Sebuah tuple yaitu daftar entri di mana setiap entri menyediakan jenis dan sanggup ditandai sebagai opsional. Beberapa pola termasuk:

 [Int, Bool]   //Tuple of an Int and Bool  [Int, ?:Bool] //Tuple of an Int and optionally a Bool  [Int, ...]    //Tuple of an Int an possibly other entries

Relasi subtipe pada tupel T1 dan T2 yaitu urutan leksikografis pada entri tuple di mana entri yang dibutuhkan selalu kurang dari entri opsional (?) Dan tupel terbuka cocok dengan akhiran apa pun dari tupel tertutup.

[Int] <: [Any]               //true - Int <: Any  [Int] <: [Bool]              //false - Int <! Bool  [Int] <: [Int, ?:Bool]       //true - omitting optional type is ok  [Int, Bool] <: [Int, ?:Bool] //true - optional type is ok  [Int, ?:Bool] <: [Int]       //false - missing optional type  [Int] <: [Int, ...]          //true - prefix matches  [Int, Bool] <: [Int, ...]    //true - prefix matches, open covers tail  [Int, ...] <: [Int]          //false - open is not subtype of closed  The tuple [...] is a supertype of all others and [...] is a subtype of the special nominal type Tuple .

1.2.2 Catatan

Catatan yaitu peta nama pengidentifikasi untuk entri di mana setiap entri menawarkan jenis dan sanggup ditandai sebagai opsional. Beberapa pola termasuk:

{f: Int, g: Bool} //Record required f and g  {f: Int, g?: Bool} //Record required f optional g  {f: Int, ...} //Record required f open other

Relasi subtipe pada tupel R1 dan R2 yaitu urutan subset menurut pada entri catatan di mana entri yang dibutuhkan selalu kurang dari entri opsional (?) Dan tupel terbuka cocok dengan akhiran apa pun dari tupel tertutup.[becakcode.site]

{f: Int} <: {f: Any}                    //true - Int <: Any  {f: Int} <: {g: Int}                    //false - different names  {f: Int} <: {f: Bool}                   //false - Int <! Bool  {f: Int} <: {f: Any, g?: Bool}          //true - omitting optional type is ok  {f: Int, g: Bool} <: {f: Int, g?: Bool} //true - optional type is ok  {f: Int, g?: Bool} <: {f: Int}          //false - missing optional type  {f: Int} <: {f: Int, ...}               //true - subset matches  {f: Int, g: Bool] <: {f: Int, ...}      //true - subset matches, open covers rest  {f: Int, ...} <: {f: Int}               //false - open is not subtype of closed

Catatan {...} yaitu supertipe dari semua yang lain dan {...} yaitu subtipe dari Catatan jenis nominal khusus.

1.3 Jenis Fungsi

Fungsi yaitu nilai dan tipe kelas satu dalam bahasa Bosque. Fungsi sanggup memakai argumen berjulukan untuk argumen binding di panggilan dan, dengan demikian, nama yaitu penggalan dari tanda tangan jenis fungsi. Nama parameter _ khusus memperlihatkan "tidak peduli" untuk nama parameter. Fungsi juga memungkinkan untuk parameter opsional, dengan? sintaks, dan parameter istirahat memakai ... sintaks. Jenis parameter lainnya sanggup ditentukan sebagai salah satu tipe koleksi dari pustaka inti termasuk, daftar, set, dan peta. Contoh jenis fungsi meliputi:

fn(x: Int) -> Int          //Function required parameter named "x"  fn(_: Int) -> Int          //Function required unnamed parameter  fn(x?: Int) -> Int         //Function optional x parameter  fn(...l: List[Int]) -> Int //Function rest List parameter

Relasi subtipe pada fungsi F1 dan F2 dimulai dengan urutan leksikografis pada entri parameter (dengan subtyping kontravarian) di mana entri opsional (?) Selalu kurang dari entri yang dibutuhkan dan tupel terbuka cocok dengan akhiran dari tuple tertutup. Relasi kovarian dalam tipe pengembalian.

fn(x: Any) -> Int <: fn(x: Int) -> Int  //true - Int <: Any  fn(x: Int) -> Int <: fn(x: Bool) -> Int //false - Bool <! Int  fn(x: Int) -> Int <: fn(x: Any) -> Int  //false - Any <! Int    fn(x: Any) -> Int <: fn(y: Int) -> Int //false - name mismatch  fn(x: Any) -> Int <: fn(_: Int) -> Int //true - name ignore  fn(_: Any) -> Int <: fn(x: Int) -> Int //false - name needed    fn(x: Int, y?: Bool) <: fn(x: Int) -> Int //true - omitting optional parameter is ok  fn(y?: Bool) <: fn(y: Bool) -> Int        //true - optional parameter is subtype  fn(x: Int) <: fn(x: Int, y?: Bool) -> Int //false - missing optional type    fn(x: Any) -> Int <: fn(x: Int) -> Any //true - Int <: Any  fn(x: Any) -> Any <: fn(x: Int) -> Int //true - Any <! Int    fn(...r: List[Int]) -> Int <: fn(...r: List[Int]) -> Int   //true - prefix match  fn(x: Any, ...r: List[Int]) -> Int <: fn(x: Int) -> Int    //true - prefix match  fn(_: Int) -> Int <: fn(..._: List[Int]) -> Int            //false - rest match  fn(...r: List[Int]) -> Int <: fn(_: Int) -> Int            //true - rest covers

1.4 Jenis Kombinasi

Dengan tipe struktural dan nominal dasar Bosque juga mendukung tipe konsep noneable (T1?), Union (T1 | T2), dan konjungsi terbatas (C1 + C2).

Jenis kombinasi pola meliputi:

String | None  Int | Bool  String?  Parsable + Indexable

T1 | Notasi T2 menentukan suatu tipe sanggup berupa T1 atau T2 sedangkan notasi T1? yaitu abreviasi untuk T1 | Tidak ada Perhatikan bahwa ini menyiratkan bahwa (T1?)? Apakah tipe yang sama dengan T1? . Tipe sistem juga mengakui konjungsi tetapi membatasi konjungsi ke tipe konsep di mana C1 + C2 memperlihatkan tipe harus menyediakan C1 dan C2.
[becakcode.site]

Int | Bool <: Any         //true  Int | Bool <: Int         //false  Int | Bool <: Int | Some  //true  Int | Int <: Int          //true - algebra  Some | None <: Any        //true  Any <: Some | None        //true - special case  Int? <: Int | None        //true  Int <: Int?               //true  Int?? <: Int?             //true - algebra  None? <: None             //true - algebra  C1 + C2 <: C2             //true  C1 + C1 <: C1             //true - algebra  C1 <: C1 + C2             //false - (unless C2 <: C1)

Seperti yang ditunjukkan dalam pola di atas beberapa jenis kombinasi mengurangi ke versi yang lebih sederhana menurut aturan aljabar.

2 Core Types

3 Collections

4 Type Checking

5 Ekspresi

Bahasa Bosque menyediakan serangkaian ekspresi yang mendukung manipulasi data yang ringkas dan ekspresi niat. Tema utama dari operator ini yaitu untuk menawarkan alasan yang sederhana perihal semantik yang menangkap operasi umum dengan tujuan meningkatkan produktivitas dan kualitas kode.[becakcode.site]

5.1 Argumen

Bosque telah menawarkan argumen yang disebutkan bersama dengan operator lainnya dan operator yang tersebar. Ini sanggup digunakan untuk melaksanakan manipulasi data yang sederhana dan berpengaruh sebagai penggalan dari doa dan operasi konstruktor. Contoh dari situasi ini termasuk:

     return args.sum(default=d);  }    function np(p1: Int, p2: Int): {x: Int, y: Int} {      return @{x=p1, y=p2};  }    //calls with explicit arguments  var x = nsum(0, 1, 2, 3); //returns 6    var a = np(1, 2);         //returns @{x=1, y=2}  var b = np(p2=2, 1);      //also returns @{x=1, y=2}  var c = np(p2=2, p1=1);   //also returns @{x=1, y=2}    //calls with spread arguments  var t = @[1, 2, 3];  var p = nsum(0, ...t);    //returns 6 -- same as explicit call    var r = @{p1=1, p2=2};  var q = np(...r);         //returns @{x=1, y=2} -- same as explicit call

Contoh pertama memperlihatkan penggunaan argumen istirahat dan berjulukan dalam tanda tangan panggilan. Panggilan ke nsum mengambil sejumlah argumen arbitrer yang secara otomatis dikonversi menjadi Daftar. Panggilan ke np memperlihatkan bagaimana parameter berjulukan sanggup digunakan dan dicampur dengan parameter posisi.[becakcode.site]

Kumpulan pola berikutnya memperlihatkan bagaimana argumen spread sanggup digunakan. Dalam masalah pertama tuple, @ [1, 2, 3], dibentuk dan ditugaskan ke variabel t. Tuple ini kemudian menyebar untuk menawarkan tiga argumen terakhir ke nsum. Secara semantik num panggilan (0, ... t) sama dengan nsum (0, t [0], t [1], t [2]) dan, sebagai hasilnya, nilai dalam p sama dengan nilai nilai dihitung untuk x. Operator spread juga bekerja untuk catatan dan parameter bernama. Dalam pola panggilan untuk np (... r) secara semantik sama dengan np (p1 = r.p1, p2 = r.p2). Meskipun tidak ditampilkan di sini, spread juga sanggup digunakan pada koleksi apa pun, Daftar, Tetapkan, Peta, nilai data menurut juga.

5.2 Konstanta

Ekspresi nilai konstan tidak termasuk, true, false Integer, String, TypedString, dan TypedStringLiteral:

none  true  0  5  -1  "ok"  ""  'a*b*'#Regex //String[Regex]  '5'#Int      //String[Int]  'a*b*'@Regex //Regex literal for Regex@{str="a*b*"}

Sebagian besar ekspresi literal ini familier dari bahasa lain, tetapi Bosque memperkenalkan konsep Typed Strings (). Notasi konstan meliputi "..." # Ketik untuk memperkenalkan string yang diketik literal dan '...' @ Ketik untuk memperkenalkan objek literal yang diwakili oleh string. Semantik ekspresi '...' @ Type sama dengan ekspresi Type :: tryParse ("..." # Type).[becakcode.site]

5.3 Variabel dan Akses Lingkup

Ekspresi nama sederhana sanggup digunakan untuk merujuk ke variabel lokal, argumen, dan yang ditangkap serta jenis atau konstanta yang dicakup secara global. Contohnya termasuk:

x              //Local, Argument, or Captured Variable  NSFoo::g       //Namespace scoped global  Bar::c         //Type scoped constant  Bar[Int]::c    //Generic type scoped constant  (Bar + Baz)::c //Conjunction type scoped constant

Dalam nama Bosque diselesaikan memakai lingkup leksikal di mana mereka digunakan mulai dari blok ketika ini, sampai argumen, variabel yang ditangkap, ketik dan kesudahannya ruang lingkup namespace. Pembayangan tidak diizinkan pada variabel apa pun. Namun, untuk argumen / penduduk lokal dalam tubuh lambda sanggup sama dengan nama-nama di tubuh deklarasi terlampir (mencegah penangkapan penutupan penggalan 5.6 Konstruksi Lambda).

Kemampuan untuk melaksanakan resolusi konstan konjungsi bekerja dengan mencari definisi dari konstanta memakai Bar dan Baz. Jika definisi konstan yaitu sama untuk keduanya maka ini didefinisikan dengan baik (dan legal) kalau tidak maka ini yaitu kesalahan ketik.[becakcode.site]

5.4 Tuple dan Rekam Konstruktor
Tuple dan catatan dibangun melalui sintaks konstruktor literal sederhana di mana nilai untuk setiap entri tuple atau catatan sanggup berupa ekspresi lain dalam bahasa.

@[]               //Empty Tuple  @[ 1 ]            //Tuple of [Int]  @[ 1, "ok" ]      //Tuple of [Int, String]  @[ 1, foo() ]     //Tuple of 1 and result of foo  @{}               //Empty Record  @{ f=1 };         //Record of {f: Int}  @{ f=1, g=true }; //Record of {f: Int, g: Bool}  @{ g=x.h, f=1 };  //Record where f is 1 and g is result of x.h

5.5 Pembuat Entitas
Untuk mengurangi jumlah instruksi pelat yang diperkenalkan oleh konstruktor, dan khususnya konstruktor yang mempunyai daftar argumen panjang yang terutama diteruskan ke konstruktor super, bahasa Bosque memakai konstruksi melalui inisialisasi bidang pribadi untuk membangun nilai entitas (objek). Untuk banyak penggunaan, pendekatan penginisialisasi pribadi sederhana ini cukup dan tidak perlu untuk konstruktor kompleks yang menghitung nilai turunan sebagai penggalan dari sanksi konstruktor. Contoh sintaks ini termasuk:
[becakcode.site]

concept Bar {     field f: Int; } entity Baz provides Bar {     field g: Int;     field h: Bool = true; } var y = Baz@{f=1, g=2, h=false}; //Create a Baz entity with the given field values var x = Baz@{f=1, g=2};          //Create a Baz entity with default value for h

Dalam cuplikan instruksi ini dua entitas Baz dialokasikan melalui konstruktor inisialisasi atom. Dalam masalah kedua bidang h yang dihilangkan diatur ke nilai default true yang diberikan.

Kadang-kadang berkhasiat untuk merangkum logika inisialisasi dan, untuk mencapai ini, Bosque menawarkan definisi fungsi pabrik yang beroperasi menyerupai dengan konstruktor tetapi, dalam beberapa hal, terbalik. Fungsi pabrik mengembalikan catatan dengan semua bidang yang dibutuhkan untuk entitas / konsep terlampir. Jadi, pabrik identitas mendefinisikan f dan g. Ketika dipanggil dengan sintaks konstruktor, ini sesuai dengan penginisialisasi atom yang digunakan dengan hasil rekaman diperluas dari fungsi pabrik, Baz @ {... Baz :: identity (1)}, dalam pola kami.

Dengan desain ini kebutuhan untuk melewatkan data melalui panggilan super dihilangkan sebab data sanggup pribadi dimasukkan ke dalam penginisialisasi atau, kalau konstruktor super mempunyai logika pabrik, maka pabrik super sanggup dipanggil dan hasilnya diperluas pribadi ke konstruktor atom menyerupai pada Baz @ {... Bar :: default (), g = 2} di bawah ini.

concept Bar {      field f: Int;        factory default(): {f: Int} {          return @{f=1};      }  }    entity Baz provides Bar {      field g: Int;      field h: Bool = true;        factory identity(i: Int): {f: Int, g: Int} {          return @{f=i, g=i};      }  }    var p = Baz@identity(1);              //Factory provides all arguments for constructor  var q = Baz@{...Bar::default(), g=2}; //Use super factory + specific values in direct constructor

Hasil dari logika konstruktor terbalik ini yaitu bahwa hanya argumen yang dibutuhkan untuk perhitungan internal dari nilai inisialisasi yang harus disebarkan sementara semua yang lain sanggup pribadi diatur dalam initializer. Penghapusan instruksi boiler konstruktor dan pengurangan lewat argumen menyederhanakan definisi tipe nominal gres serta dampak perubahan cascading ketika bidang (atau argumen konstruktor) ditambahkan / dihapus dalam definisi dasar.

5.6 Konstruktor Lambda

Konstruktor Lambda dalam bahasa Bosque menggabungkan definisi instruksi untuk tubuh lambda dengan semantik salinan variabel untuk penutupan variabel yang ditangkap pada pembuatan lambda. Definisi tubuh sanggup berupa ekspresi atau blok pernyataan. Dalam masalah ambiguitas, tubuh diuraikan sebagai blok pernyataan.

var f = fn(): Int => { return 1; }             //No arguments statement block body  var g = fn(): Int => 1                          //No arguments statement expression body  var h = fn(x: Int): Int => x                    //One required argument  var k = fn(x: Int, y?: Int): Int => @{a=x, b=y} //One required and one optional argument    var c = 1;  var fc = fn(): Int => c; //Captured variable c  var rc = fc()            //Result is 1    var! m = 1;  var fm = fn(): Int => m; //Captured variable - always copied  m = 3;  var mc = fm();           //Result is still 1 since closure capture copies

Dalam pola di atas, tipe ekspresi lambda secara eksplisit dinyatakan melalui deklarasi tipe eksplisit untuk argumen dan nilai balik. Namun, dalam masalah di mana lambda yaitu argumen literal untuk doa yang mengambil parameter yang diketik fungsi, kami mengizinkan tipe ini untuk disimpulkan secara langsung.[becakcode.site]

function foo(f: fn(_: Int, _: Int) -> Int, a: [Int, Int]): Int {      return f(...a);  }    var f = (x: Int, y: Int): Int => x + y; //Types required  var fr = foo(f, [1, 2]);    var ir = foo(fn(x, y) => x + y, [1, 2]); //Types inferred

5.7 Invitasi Tercakup

Doa cakupan dalam bahasa Bosque meliputi panggilan ke fungsi global dan fungsi anggota statis. Argumen variasi insulasi 5.1 Argumen sanggup digunakan dalam semua doa ini.

NSFoo::f(3)                 //Namespace scoped invocation  NSFoo::g[Int](0)            //Namespace scoped invocation with generic invoke  NSFoo::k[Int, String](1)    //Namespace scoped invocation with generic invoke    Bar::f()                    //Type scoped invocation  Baz[Int]::g[Int](0)         //Static invocation with generic type and invoke  Baz[Int]::k[Int, String](5) //Static invocation with generic type and invoke  (Baz + Bar)::m(0)           //Conjunction resolved static type invocation

Sebagian besar bentuk-bentuk ini dekat dari bahasa berorientasi objek lain tetapi kemampuan untuk melaksanakan doa statis memakai tipe konjungsi unik. Seperti halnya resolusi konstan yang dicakup, ini berfungsi dengan melihat definisi pemanggilan memakai Bar dan Baz. Jika definisi konstan yaitu sama untuk keduanya maka ini didefinisikan dengan baik (dan legal) kalau tidak maka ini yaitu kesalahan ketik.[becakcode.site]

5.8 Rantai dan Tanpa Rantai

Menangani nilai-nilai tidak ada (atau null, tidak terdefinisi, dll dalam bahasa lain) yaitu kiprah yang relatif umum yang sanggup mengaburkan maksud fundamental dari penggalan instruksi dengan sarang masalah dan penanganan kondisional untuk masalah khusus.

Definisi Bosque menawarkan sumbangan untuk nilai-nilai tidak ada korelasi pendek pada semua tindakan yang sanggup berantai, menggunakan? gagasan.

@{}.h           //none  @{}.h.k         //error  @{}.h?.k        //none  @{h={}}.h?.k    //none  @{h={k=3}}.h?.k //3

Ketika dikombinasikan dengan operator yang sanggup di rantai (bawah)? penilaian hubung singkat operator dan tidak mengembalikan apa pun ketika nilai ekspresi tidak ada.

5.9 Operator Akses yang Diketik Tuple

Operator rantai yang diketik tuple termasuk:

[e] untuk mendapat nilai pada indeks i dalam tuple atau tidak sama sekali kalau indeks tidak ditentukan
@ [i, ..., j], buat tuple gres memakai nilai di indecies i, ..., j
Contoh-contoh ini termasuk:

var t = @[ 1, 2, 3 ];    t[0]         //1  t?[1]        //1  t[101]       //none  t@[1]        //@[2]  t@[2, 0]     //@[3, 1]  t@[5, 1]     //@[none, 2]  t[5][0]      //error  t[5]@[0]     //also error  t[5]?@[0, 1] //none

Seperti pada kebanyakan bahasa, operator [] memungkinkan kanal ke elemen individual dalam sebuah tupel sedangkan operator algebraic @ [] menyediakan perubahan bentuk data tuple yang ringkas dan sederhana.

5.10 Rekam Operator Akses yang Diketik

Rekor yang diketik dari operator yang sanggup ditransfer termasuk:

.p untuk mendapat nilai yang terkait dengan properti atau tidak ada kalau properti tidak didefinisikan
@ {f, ..., g}, buat catatan gres memakai nilai pada properti f, ..., g
Contoh-contoh ini termasuk:

var r = @{ f=1, g=2, k=true };    r.f         //1  r?.f        //1  r.h         //none  r@{g}       //@{g=2}  r@{g, k}    //@{g=2, k=true}  r@{h, g}    //@{h=none, g=2}  r.h.f       //error  r.h@{f}     //also error  r.h?@{f, g} //none

Seperti dalam kebanyakan bahasa. operator memungkinkan kanal ke masing-masing elemen dalam suatu catatan sementara operator aljabar besar {{} menyediakan pembentukan kembali data data yang ringkas dan sederhana.

5.11 Operator Akses yang Diketik Nominal

Bidang dalam tipe nominal sanggup diakses berantai dengan cara yang sama menyerupai properti dalam catatan:

.f untuk mendapat nilai yang terkait dengan bidang atau kesalahan kalau bidang tidak ditentukan pada jenisnya
@ {f, ..., g}, buat catatan gres memakai nilai pada bidang f, ..., g
Contoh-contoh ini termasuk:

entity Baz {      field f: Int;      field g: Int;      field k: Bool  }    var e = Baz@{ f=1, g=2, k=true };    e.f         //1  e?.f        //1  e.h         //none  e@{g}       //@{g=2}  e@{g, k}    //@{g=2, k=true}  e@{h, g}    //@{h=none, g=2}  e.h.f       //error  e.h@{f}     //also error  e.h?@{f, g} //none

Seperti dalam kebanyakan bahasa. operator memungkinkan kanal ke elemen individual dalam suatu entitas (objek) sementara operator algebraic @ {} massal menyediakan pembentukan kembali nilai data yang ringkas dan sederhana. Perhatikan bahwa tipe hasil yaitu catatan.[becakcode.site]

5.12 Proyeksi yang Diketik

Selain mengekstraksi tupel / catatan gres memakai notasi @ [] dan @ {} bahasa Bosque juga mendukung memproyeksikan data terstruktur memakai tipe melalui notasi Exp # Type. Operator rantai ini sanggup digunakan pada jenis tupel, catatan, dan nominal:

concept Bar {      field f: Int;  }    concept T3 {      field f: Int;  }    entity Baz provides Bar {      field g: Int;      field k: Bool  }    var t = @[ 1, 2, 3 ];  t#[Int]        //@[1]  t#[Bool]       //error type mismatch  t#[Int, ?:Int] //@[1, 2]  t#[Int, Any]   //@[1, 2]    var r = @{ f=1, g=2, k=true };  r#{f: Int}          //@{f=1}  r#{f: Bool}         //error type mismatch  t#[f: Int, g?: Int] //@{f=1, g=2}  t#[f: Int, g: Any]  //@{f=1, g=2}    var e = Baz@{ f=1, g=2, k=true };  e#Bar       //@{f=1}  e#{f: Bool} //error type projection requires same kinds  e#T3         //error type mismatch

Perhatikan bahwa tipe hasil proyeksi dari tipe nominal yaitu catatan.

5.13 Perbedaan

[Belum Diimplementasikan] hapus indecies \ [i, ..., j], properti \ {f, ..., g}, atau types \ # Ketik.

5.14 Pembaruan

Dalam sebagian besar bahasa, pembaruan (atau membuat salinan yang diperbarui) dilakukan menurut bidang per bidang. Namun, dengan pembaruan massal di Bosque dimungkinkan untuk melaksanakan pembaruan sebagai operasi atom dan tanpa secara manual mengekstraksi dan menyalin bidang. Bosque menyediakan operasi pembaruan yang tidak sanggup dilacak untuk tupel (Exp < (i = e1, ... j = ek) notasi), catatan, dan tipe nominal (Exp < (f = e1, ... f = ek)).

entity Baz {      field f: Int;      field g: Int;      field k: Bool  }    var t = @[ 1, 2, 3 ];  t< (1=5)      //@[1, 5, 2]  t< (0=3, 1=5) //@[3, 5, 3]  t< (1=5, 4=0) //@[1, 5, 3, none, 0]    var r = @{ f=1, g=2, k=true };  r< (g=5)          //@{f=1, g=5, k=true}  r< (g=3, k=false) //@{f=1, g=3, k=false}  r< (g=5, h=0)     //@{f=1, g=5, k=true, h=0}    var e = Baz@{ f=1, g=2, k=true };  e< (g=5)          //Baz@{f=1, g=5, k=true}  e< (g=3, k=false) //Baz@{f=1, g=3, k=false}  e< (g=5, h=0)     //error invalid field name

Perhatikan bahwa untuk pembaruan tupel melewati ujung tuple tidak akan ada alas lokasi yang dibutuhkan sementara untuk catatan itu akan memasukkan properti yang ditentukan. Memperbarui bidang yang tidak ada pada tipe nominal yaitu kesalahan.

5.15 Gabung

Operasi pembaruan memperbolehkan modifikasi aljabar-massal nilai tetapi membutuhkan properti literal / indecies / bidang yang harus ditentukan. Untuk memungkinkan lebih banyak operasi terprogram, bahasa Bosque juga menyediakan operasi adonan yang sanggup di rantai yang mengambil pasangan tuple / tuple, merekam / merekam, atau nominal / merekam dan menggabungkan nilai data memakai sintaks Exp <+ (Exp). Peta operasi tuple / tuple untuk ditambahkan, catatan / catatan yaitu penggabungan kamus, dan nominal / catatan yaitu bidang pembaruan massal.[becakcode.site]

entity Baz {      field f: Int;      field g: Int;      field k: Bool  }    var t = @[ 1, 2, 3 ];  t<+(@[5])       //@[1, 2, 3, 5]  t<+(@[3, 5])    //@[1, 2, 3, 3, 5]    var r = @{ f=1, g=2, k=true };  r<+(@{g=5})          //@{f=1, g=5, k=true}  r<+(@{g=3, k=false}) //@{f=1, g=3, k=false}  r<+(@{g=5, h=0)      //@{f=1, g=5, k=true, h=0}    var e = Baz@{ f=1, g=2, k=true };  e<+(@{g=5})          //@{f=1, g=5, k=true}  e<+(@{g=3, k=false}) //@{f=1, g=3, k=false}  e<+(@{g=5, h=0)      //error field not defined

Kemampuan untuk menggabungkan secara jadwal ke dalam nilai memungkinkan kita untuk menulis instruksi pemrosesan data yang ringkas dan menghilangkan penyalinan instruksi yang berlebihan di sekitar nilai-nilai individual. Selain membantu mencegah bug halus selama pengkodean awal, operator juga sanggup menyederhanakan proses memperbarui representasi data ketika melaksanakan refactoring instruksi dengan mengurangi jumlah daerah di mana dekonstruksi nilai, pembaruan, dan salinan yang perlu digunakan.[becakcode.site]

5.16 Lambda Mendaftar

Operator aplikasi lambda digunakan untuk memanggil tubuh metode dari nilai lambda dengan argumen yang disediakan. Seperti halnya operator rantai lainnya, ia mendukung sistem tanpa rantai.

var f = (x: Int, y: Int): Int => x + y; //Types required var fn = none; f(5, 3)  //8 - normal invoke f?(5, 3) //8 - none-chain invoke fn()     //error fn?()    //none

5.17 Meminta

Operator pemohon rantai -> sanggup digunakan untuk memohon kedua metode anggota dari tipe nominal dan nilai lambda yang disimpan dalam properti atau bidang.

Untuk pemanggilan metode anggota, operator yang dipanggil akan menangani resolusi metode virtual apa pun, baik dari tipe objek dinamis atau dari beban basis yang ditentukan ketika memakai sintaks

-> :: Type.

concept Fizz {     field v: Int;     method m1(x: Int): Int {         return this.v + x;     }     virtual method m3(x: Int): Int {         return this.v + x + 3     } } entity Bar provides Fizz {     field func: fn(this: Bar, x: Int) -> Int = fn(this: Bar, x: Int): Int => this.v + x;     override method m3(x: Int): Int {         return 0;     } } entity Biz provides Fizz {     method mc[T](arg: T): T? {         return this.v != 0 ? arg : none;     } } var kafetaria = Bar@{v=10}; var biz = Biz@{v=3}; bar->m1(5) //15 biz->m1(5) //8 bar->m3(5)      //0 bar->Fiz::m3(5) //18 biz->m3(5)      //11 bar->func(2) //12 biz->func(2) //error no such field or method bar->mc[Int](3) //error no such field or method biz->mc[Int](3) //3 (none)->m1(5)    //error no such field or method (none)?->m1(5)   //none none->isNone() //true - see core None and Any types @{}->isSome()  //true - see core None and Any types 5->isSome()    //true - see core None and Any types

Sistem tipe Bosque menyediakan model terpadu untuk semua tipe struktural, primitif, dan nominal. Jadi, metode sanggup digunakan pada nilai apa pun. Lihat penggalan ini untuk info lebih lanjut perihal seruan apa yang didukung.

5.18 Pipa

Pemrosesan koleksi tingkat tinggi yaitu aspek fundamental dari bahasa Bosque (bagian) tetapi sering kali chaining filter / peta / dll. bukan cara alami untuk memikirkan serangkaian operasi tertentu dan sanggup menghasilkan penciptaan alokasi memori yang substansial untuk objek koleksi perantara. Dengan demikian, Bosque memungkinkan penggunaan kedua metode chaining untuk panggilan pada koleksi dan pemipaan, |, nilai melalui beberapa langkah. Ini memungkinkan pengembang untuk menentukan urutan operasi, yang masing-masing diterapkan pada elemen dari urutan pengumpulan dasar, yang mengubah data input menjadi koleksi akhir. Seperti rantai lainnya, kami mendukung operasi tidak-penggabungan, |?>, Yang mengembangkan tidak pribadi ke output dalam pipa dan, | ??, yang melaksanakan hubung singkat pada pemrosesan dan menurunkan nilai. Beberapa pola representatif ditunjukkan di bawah ini:

var v: List[Int?] = List@{1, 2, none, 4}; //Chained - List@{1, 4, 16} v.filter(fn(x) => x != none).map[Int](fn(x) => x*x) //Piped none filter - List@{1, 4, none, 16} v |> filter(fn(x) => x != none) |> map[Int](fn(x) => x*x) //Piped with noneable filter - List@{1, 4, 16} v |??> map[Int](fn(x) => x*x) //Piped with none to result - List@{1, 4, none, 16} v |?> map[Int](fn(x) => x*x)

5.19 Operator Unary

Bosque mendukung tiga operator awalan unary:

! akan meniadakan nilai Bool dan mengubah nilai tidak ada menjadi true
+ tidak ada tetapi sering berkhasiat untuk memperlihatkan niat
- Meniadakan nilai integer
Contohnya termasuk:

!true   //false !false  //true !none   //true !"true" //error !0      //error +5 //5 -5 //-5

5.20 Operator Biner
Bosque mendukung aneka macam operator biner yang sanggup diterapkan ke nilai Int termasuk +, -, *, /, dan%. Contohnya termasuk:

5 + 6 //11 3 - 1 //2 2 * 3 //6 3 / 2 //1 4 / 2 //2 4 / 0 //error 3 % 2 //1 4 % 2 //0 4 % 0 //error

5.21 Perbandingan Kesetaraan

Bahasa Bosque menawarkan == dan! = Operator yang bekerja untuk nilai dari tipe berikut:

Tidak ada di mana tidak ada yang sanggup dibandingkan dengan nilai-nilai dari jenis lain
Bool
Int
String daerah string yang diketik secara implisit dipaksa ke versi yang tidak diketik
GUID
Enum di mana mereka mengetik dan nilai harus sama
CustomKey daerah mereka mengetik dan nilai harus sama
Contoh operator kesetaraan pada nilai-nilai primitif meliputi:

1 == 1                     //true "1" == ""                  //false "1" != ""                  //true 'hello'#Foo == 'hello'#Foo //true 'hello'#Foo == "hello"     //true @{} == none                //false false == none              //false

Bosque tidak mengakui kesetaraan rujukan dalam bentuk apa pun. Suatu jadwal sanggup memakai perbandingan eksplisit pada tipe primitif atau pengembang sanggup menentukan kunci khusus yang menawarkan gagasan perihal kesetaraan, mis. identitas, kunci utama, kesetaraan, dll. yang masuk kebijaksanaan untuk domain mereka.

Kunci khusus dibandingkan dengan memakai jenis kunci dan kesetaraan berpasangan dari setiap bidang yang ditentukan dalam kunci.

ckey MyKey {      field idx: Int;     field category: String; } ckey OtherKey {     field idx: Int;     field category: String; } var a = MyKey@{1, "yes"}; var b = MyKey@{1, "yes"}; var c = MyKey@{1, "no"}; var q = OtherKey@{1, "yes"}; a == a //true a == b //true a == c //false - different field values (category) a == q //false - different key types

Koleksi dan operasi pada mereka juga didefinisikan untuk memakai definisi bidang kesetaraan dan nilai kunci khusus ini (bagian 3 Koleksi) alih-alih sama dengan kelebihan atau membandingkan metode.

5.22 Perbandingan Pesanan

Bosque mendukung aneka macam operator pesanan, <,>, <=, dan> = yang sanggup diterapkan ke nilai Int atau String. Untuk string yang diketik, String [T] operator pembanding mengabaikan tipe generik dan didasarkan pada urutan string mentah yang mendasarinya, mis. kedua argumen tersebut dipaksakan ke String.

1 < 2                      //true "1" < ""                   //false "11" < "12"                //true 'hello'#Foo <= 'hello'#Foo //true 'hello'#Foo <= "hello"     //true 'hello'#Foo < "h"          //false

5.23 Operator Logika Dalam Pemrograman Bosque

Bosque menyediakan korelasi arus pendek standar && dan || operator serta operator yang tersirat ==>. Semua operator ini bekerja pada nilai yang diketik Bool dan secara implisit akan mengkonversi tidak ada menjadi salah. Contohnya termasuk:

true || (1 / 0 == 0)  //true false || (1 / 0 == 0) //error none || false         //false 1 || true             //error false && (1 / 0 == 0) //false true && (1 / 0 == 0)  //error none && true          //false 1 && true             //error false ==> true        //true false ==> false       //true true ==> true         //true true ==> false        //false false ==> (1 / 0 == 0) //true true ==> (1 / 0 == 0)  //error true ==> none          //false 1 ==> true             //error

5.24 Tidak Ada Penggabungan

Bosque menyediakan operasi khusus yang tidak ada penggabungan,? | dan? &, berlawanan dengan penggabungan berbasis kebenaran yang membebani operator logis dan / atau operator.

function default(x?: Int, y?: Int) : Int {      return (x ?| 0) + (y ?| 0); //default on none } default(1, 1) //2 default(1)    //1 default()     //0 function check(x?: Int, y?: Int) : Int? {     return x ?& y ?& x + y; //check none } default(1, 1) //2 default(1)    //none default()     //none

The ?| Operator hubung-pendek pada nilai-nilai yang tidak ada sedangkan? & hubung-pendek operator pada nilai-nilai tidak ada.

5.25 Pilih

Operator pilih memakai kondisi yang sanggup mengembalikan Bool atau Tidak Ada dan memakai ini untuk menentukan antara ekspresi alternatif yang dievaluasi malas. Nilai tidak ada secara otomatis dipaksa ke false.

true ? 1 : 2      //1 false ? 1 : 2      //2 true ? 1 : 2 / 0  //1 false ? 1 : 2 / 0 //error none ? 1 : 2      //2 "" ? 1 : 2        //error

5.26 Pernyataan Pernyataan

Bosque meliputi pernyataan Match, If, dan Block () yang sanggup digunakan baik sebagai ekspresi maupun pernyataan. Itu juga memungkinkan ini untuk digunakan dalam posisi ekspresi di mana blok tindakan di Jika / Pertandingan diperlakukan sebagai ekspresi dan, bukannya kembali, blok akan menghasilkan hasil:

var a = if(true) 3 else 4;    //3 var b = {var x = 3; yield x;} //3 var c = match("yes") {     case "yes" => 5     case "no" => {var x = 5; yield x - 3;}     case _ => if(true) 11 else 17 } //5

Perhatikan bahwa pengenalan blok ekspresi membuat lingkup leksikal gres untuk variabel apa pun yang dideklarasikan di dalamnya. Dengan demikian, ini tidak akan mencemari namespace terlampir.

Kondisi pernyataan If memungkinkan tipe Bool dan None.

Pernyataan Pertandingan mendukung operasi restrukturisasi dan mengetik dalam pertandingan menyerupai yang dijelaskan dalam.[becakcode.site]

Ketika pernyataan blok digunakan sebagai ekspresi mereka tidak bisa memakai pernyataan return di dalam.

5.27 Blok Pemukulan

[Belum diimplementasikan]

5.28 Blok Sintesis

[Belum diimplementasikan]
6 Pernyataan

Mengingat rangkaian ekspresi primitif yang kaya di Bosque ada kebutuhan yang berkurang untuk sejumlah besar kombinator pernyataan. Bahasa ini meliputi Pencocokan yang diharapkan dan Jika yang sanggup digunakan baik sebagai ekspresi dan pernyataan serta penugasan terstruktur untuk gampang merusak nilai kembali. Karena perangkat lunak keandalan tinggi yaitu tujuan utama, Bosque menawarkan penegasan, hanya diaktifkan untuk debug build, dan pemeriksaan, yang diaktifkan pada semua build, pernyataan sebagai fitur kelas satu dalam bahasa (selain kondisi pra / post dan invarian kelas). Kami juga mencatat bahwa tidak ada konstruksi pengulangan dalam bahasa tersebut.

var Identifier = Exp ; var Identifier : Type = Exp ;

Jika tipe dihilangkan dalam deklarasi itu disimpulkan dari tipe ekspresi yang digunakan untuk menginisialisasi variabel.

var x: Int = 3; //Int variable introduced and initialized var y = 3;      //variable introduced and inferred to be of type Int

Atau variabel sanggup dinyatakan sebagai sanggup diperbarui dalam lingkup memakai var! formulir deklarasi. Di var! bentuk ekspresi initializer sanggup digunakan untuk mengatur nilai awal untuk variabel atau sanggup dihilangkan untuk membiarkan variabel tidak diinisialisasi.[becakcode.site]

var! Identifier : Type ; var! Identifier = Exp ; var! Identifier : Type = Exp ;

Menggunakan var! formulir memungkinkan untuk pernyataan kiprah selanjutnya (6.3 Penugasan Variabel) untuk memperbarui nilai variabel. Ini yaitu kesalahan untuk memakai variabel yang tidak diinisialisasi kecuali semua jalur yang mungkin mengalir ke penggunaan harus memberinya nilai.

Contoh deklarasi ini adalah:

var! x: Int;     //uninitialized mutable variable of type Int introduced var! x: Int = 3; //mutable variable of type Int introduced var! x = 3;      //mutable variable of inferred type Int introduced6.3 Variable Assignment  Variables declared as mutable, using the var! syntax, can be modified by later assignment statements. var! x: Int; var! y = 7; var a = x; //error undefined use x = 3; y = x;     //ok x is defined now var z = 5; z = y;     //error z is not updatable Updates can occur in different blocks of code as well: var! x = 0; if(true) {     x = 1; } var! y: Int; if(true) {     y = 1; } else {     y = 2; }
 6.4 Deklarasi dan Tugas Terstruktur  [Belum diimplementasikan]  6.5 Kembali dan Hasil  Dalam blok instruksi pernyataan pengembalian keluar dari seruan ketika ini dengan nilai ekspresi sebagai hasilnya. Pernyataan hasil digunakan dalam blok ekspresi (5.26 Pernyataan Ekspresi) untuk keluar dari blok dengan nilai ekspresi sebagai hasilnya.  function abs(x: Int): Int {      if(x < 0) {         return -x;     }     else {         return x;     } } function absy(x?: Int): Int {     if(x == none) {         return 0;     }     return {         var! y = x;         if(y < 0) {             y = -y;         }         yield y;     } }
 Pengecekan dan penanganan kembali instruksi kesalahan seringkali sanggup mengaburkan fatwa inti suatu fungsi dan menghasilkan kesalahan yang halus. Untuk menyederhanakan logika atau mengembalikan nilai dengan instruksi kesalahan, bahasa Bosque menawarkan pengembalian dengan, Exp with (return | yield) (when Cond)? (dari Op), sintaksis.    [Belum diimplementasikan]  6.6 Validasi  Untuk pernyataan validasi tingkat pernyataan, bahasa Bosque menyediakan pernyataan tegas dan cek. Penegasan ini hanya diaktifkan di debug builds sementara check diaktifkan di semua build. Jika kondisi yang diberikan bernilai false, kedua pernyataan akan menyebabkan kesalahan.  assert false; //raise error in debug assert true;  //no effect check false;  //raise error always check true;   //no effect
 Semantik kesalahan dalam Bosque yaitu unik. Dalam sebagian besar bahasa, kesalahan sanggup dibedakan sebab pelaporan kesalahan runtime membutuhkan penyertaan isu yang sanggup diobservasi, menyerupai nomor baris dan pesan kesalahan, untuk mendukung analisis kegagalan dan debugging. Namun, sebab sanksi Bosque sepenuhnya deterministik (Penentuan 0,10) dan sanggup diulang, bahasa ini mempunyai dua semantik eksekusi: dikerahkan dan debug. Dalam semantik yang digunakan semua kesalahan runtime tidak bisa dibedakan sementara di debug kesalahan semantik mengandung nomor baris penuh, panggilan-stack, dan metadata kesalahan. Ketika kesalahan terjadi dalam mode yang digunakan runtime hanya membatalkan, me-reset, dan menjalankan kembali sanksi dalam mode debug untuk menghitung kesalahan yang tepat!    6.7 If-Then-Else  Pernyataan bersyarat kalau di Bosque yaitu struktur fatwa kontrol bersyarat klasik.  var x = 3;    //if with fall through  if(x == none) {     return none; } //simple if-else if(x < 0) {     return -x; } else {     return x; } //if-elif*-else form if(x < 0) {     return -x; } elif(x > 0) {     return x; } else {     return 0; }
 Perhatikan bahwa elif yang menggantung harus mempunyai blok final lain.    Untuk menghindari ambiguitas ketika Jika pernyataan / ekspresi digunakan, tindakan tidak sanggup membuat ekspresi telanjang Jika / Mencocokkan. Sebagai gantinya mereka harus dilampirkan dalam blok pernyataan ekspresi.    6.8 Cocok    [Belum diimplementasikan]    6.9 Blokir  Block statement dalam Bosque yaitu urutan pernyataan. Blok ini memperkenalkan lingkup leksikal gres untuk variabel apa pun yang dideklarasikan di dalamnya. var x = 3; {     var y = 5;     var z: Int;     if(x != 3) {         z = 0;     }     else {         z = 1     } } check z == 0; //error z is out of scope check x > 0;  //ok x is in scope
 7 Invokable Declarations    discuss ref parameters threading   discuss rec call management

Demikian Pembahasan tentang bahasa pemrograman bosque,semoga sanggup memberi wawasan dan rujukan bahasa pemrograman anda,Wassalam Salam Becak Code.