Bahasa Pemrograman Bosque dan Mengenal Berbagai Syntaxnya

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 memberikan ikhtisar tentang sintaks, operasi, dan semantik dalam bahasa Bosque dengan penekanan pada fitur khas atau tidak biasa dalam bahasa.



Pengertian Bahasa Bosque?



Bahasa pemrograman Bosque dirancang untuk menulis kode yang sederhana, jelas, dan mudah digunakan untuk manusia dan mesin. Desain ini sangat didorong oleh identifikasi dan penghapusan berbagai sumber kompleksitas yang tidak disengaja dan wawasan tentang bagaimana mereka dapat dikurangi melalui desain bahasa yang bijaksana.[becakcode.site]



Bagian ini menyoroti dan berisi informasi tentang banyak fitur dan pilihan desain yang paling terkenal 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 dapat diubah!

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



2 Block Scoping Dalam Bosque


Variabel lokal dengan kode blok terstruktur adalah model yang sangat menarik untuk menyusun kode. Bahasa Bosque memadukan pemrograman fungsional dengan cakupan blok dan {...} kurung dengan memungkinkan beberapa penugasan untuk variabel yang dapat diupdate var! (6.3 Penugasan Variabel). Ini mendukung pemrograman gaya fungsional dalam bahasa yang dicakup blok dan memungkinkan pengembang untuk menulis kode 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 dapat menggunakan dan memperbaruinya. Mengizinkan pembaruan dalam parameter menghilangkan manajemen 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 mekanisme baru untuk mengangkat struktur yang diketahui tentang isi string ke dalam tipe dengan cara yang berarti bagi manusia dan yang dapat digunakan oleh pemeriksa tipe (). Ini memungkinkan kode seperti 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



memberikan argumen bernama bersama dengan operator lainnya dan spread. Ini dapat digunakan untuk melakukan manipulasi data yang sederhana dan kuat sebagai bagian 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 dukungan untuk pembacaan massal dan pembaruan nilai data. Pertimbangkan kasus umum memiliki struct dengan 3 bidang di mana 2 di antaranya perlu diperbarui. Dalam kebanyakan bahasa ini perlu dilakukan berdasarkan lapangan-per-bidang. Namun dengan operasi data massal dimungkinkan untuk melakukan pembaruan sebagai operasi atom (tidak seperti 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 adalah tugas yang relatif umum yang dapat mengaburkan maksud mendasar dari bagian kode dengan sarang kasus dan penanganan kondisional untuk kasus khusus. Untuk menyederhanakan jenis kode ini, Bosque menyertakan berbagai bentuk penggabungan atau operator hubungan singkat ((5.8 Tidak Ada-Rantai) [# 5.8 Tidak Ada-Rantai]) untuk mengaktifkan kode seperti:[becakcode.site]

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


8 Pemrosesan Iteratif



Konsep dasar dalam bahasa pemrograman adalah konstruk iterasi dan pertanyaan kritis adalah apakah konstruk ini disediakan sebagai fungsi tingkat tinggi, seperti 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 kode dunia nyata. Hasil kategorisasi dan cakupan menunjukkan 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 optimasi program otomatis, menghilangkan loop juga menghilangkan kebutuhan untuk menghitung loop-invarian. Sebagai gantinya, dan dengan desain perpustakaan koleksi yang cermat, dimungkinkan untuk menulis transformer yang tepat untuk setiap functor. Dalam hal ini perhitungan postkondisi terkuat atau prekondisi terlemah menghindari kompleksitas menghasilkan loop invarian dan sebagai gantinya menjadi kasus 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 kode dan menghalangi analisis dan perkakas otomatis, terlepas dari apakah aliran 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 menunjukkan fungsi / metode rekursif dan lagi di situs panggilan sehingga menegaskan bahwa penelepon menyadari sifat rekursif panggilan (7 Invokable-Declarations) ).

10 Penentuan


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

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

11 Kesetaraan dan Representasi



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

Mengingat masalah ini, bahasa Bosque tidak memungkinkan persamaan referensi 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 memberikan gagasan tentang kesetaraan, mis. identitas, kunci utama, kesetaraan, dll. yang masuk akal 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 adalah menyederhanakan proses membangun perangkat lunak dengan keandalan tinggi. Sebagai bagian dari ini, bahasa menyediakan dukungan kelas satu untuk mengekspresikan berbagai invarian, pemeriksaan 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 kode boilerplate yang diperkenalkan oleh konstruktor, dan khususnya konstruktor yang memiliki daftar argumen panjang yang terutama diteruskan ke super konstruktor, Bosque menggunakan konstruksi melalui inisialisasi bidang langsung untuk membangun nilai entitas (objek). Untuk banyak kegunaan, pendekatan penginisialisasi langsung sederhana ini sudah cukup dan tidak perlu untuk konstruktor kompleks yang menghitung nilai turunan sebagai bagian dari eksekusi konstruktor.[becakcode.site]

Namun, kadang-kadang berguna untuk merangkum logika inisialisasi dan, untuk mencapai ini, kami mengizinkan definisi fungsi pabrik yang beroperasi mirip dengan konstruktor tetapi, dalam beberapa hal, terbalik. Fungsi pabrik mengembalikan catatan dengan semua bidang yang diperlukan 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 kode ini dua entitas Baz dialokasikan melalui konstruktor inisialisasi atom. Dalam kasus 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 karena data dapat langsung dimasukkan ke dalam penginisialisasi atau, jika konstruktor super memiliki logika pabrik, maka pabrik super dapat dipanggil dan hasilnya diperluas langsung ke konstruktor atom seperti pada p = Baz @ {} ... Bar :: default (), g = 2}. Hasil dari logika konstruktor terbalik ini adalah bahwa hanya argumen yang diperlukan untuk perhitungan internal dari nilai inisialisasi yang harus disebarkan sementara semua yang lain dapat langsung diatur dalam initializer. Penghapusan kode boiler konstruktor dan pengurangan lewat argumen menyederhanakan definisi tipe nominal baru 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 memiliki pendapat yang memungkinkan pengembang untuk menggunakan berbagai tipe struktural, nominal, dan kombinasi untuk menyampaikan maksud mereka dan secara fleksibel mengkodekan fitur yang relevan dari domain masalah.

Notasi: Sebagai bagian dari menggambarkan sistem tipe kami menggunakan notasi berikut yang bukan merupakan bagian 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 huruf kapital - MyType adalah nama tipe yang valid sedangkan myType tidak.

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

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

Pustaka inti Bosque mendefinisikan beberapa konsep / entitas unik. Tipe Any adalah tipe uber yang semua subtipe lainnya, tipe None dan Some adalah untuk membedakan nilai none yang unik, dan Tuple, Record, dll. Ada untuk menyatukan dengan sistem tipe struktural (). Bahasa ini memiliki primitif untuk Bool, Int, String, dll. Serta kumpulan tipe parametrik yang diharapkan seperti 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 adalah hubungan pewarisan parametrik standar di mana T1 <: T2 jika 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 adalah jika kedua jenis nama yang identik secara sintaksis. Kasus kedua mencakup situasi di mana T1 dinyatakan untuk memberikan konsep yang, secara transitif, merupakan subtipe dari T2. Kasus terakhir adalah hubungan 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 hubungan subtipe kovarian karena semua tipe generik subtipe pada parameter. Ini selalu aman karena semua tipe data di Bosque tidak dapat diubah ().


1.1.2 String Yang Diketik



String yang diketik menyediakan mekanisme baru untuk mengangkat struktur yang diketahui tentang isi string ke dalam tipe dengan cara yang berarti bagi manusia dan yang dapat digunakan oleh pemeriksa tipe. Jika jenis Ty dinyatakan untuk memberikan konsep Parsable, yang memiliki metode statis tryParse (str: String): Ty | Tidak ada maka dimungkinkan untuk mendeklarasikan tipe nilai string sebagai String [Ty] yang menunjukkan 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 memiliki tipe relasi Ty <: Ty2 maka pemeriksa tipe akan mengizinkan String [Ty] <: String [Ty2] dan tentu saja String [Ty] <: String.

Ini memungkinkan kode seperti 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 dapat ditentukan sebagai tertutup atau terbuka menggunakan ... sintaks.[becakcode.site]

1.2.1 Tuples

Sebuah tuple adalah daftar entri di mana setiap entri menyediakan jenis dan dapat ditandai sebagai opsional. Beberapa contoh 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 adalah urutan leksikografis pada entri tuple di mana entri yang diperlukan 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 adalah peta nama pengidentifikasi untuk entri di mana setiap entri memberikan jenis dan dapat ditandai sebagai opsional. Beberapa contoh 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 adalah urutan subset berdasarkan pada entri catatan di mana entri yang diperlukan 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 {...} adalah supertipe dari semua yang lain dan {...} adalah subtipe dari Catatan jenis nominal khusus.

1.3 Jenis Fungsi

Fungsi adalah nilai dan tipe kelas satu dalam bahasa Bosque. Fungsi dapat menggunakan argumen bernama untuk argumen binding di panggilan dan, dengan demikian, nama adalah bagian dari tanda tangan jenis fungsi. Nama parameter _ khusus menunjukkan "tidak peduli" untuk nama parameter. Fungsi juga memungkinkan untuk parameter opsional, dengan? sintaks, dan parameter istirahat menggunakan ... sintaks. Jenis parameter lainnya dapat 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 diperlukan 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 contoh meliputi:
String | None

Int | Bool

String?

Parsable + Indexable

T1 | Notasi T2 menentukan suatu tipe dapat berupa T1 atau T2 sedangkan notasi T1? adalah singkatan 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 menunjukkan 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 contoh di atas beberapa jenis kombinasi mengurangi ke versi yang lebih sederhana berdasarkan 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 adalah untuk memberikan alasan yang sederhana tentang semantik yang menangkap operasi umum dengan tujuan meningkatkan produktivitas dan kualitas kode.[becakcode.site]

5.1 Argumen


Bosque telah memberikan argumen yang disebutkan bersama dengan operator lainnya dan operator yang tersebar. Ini dapat digunakan untuk melakukan manipulasi data yang sederhana dan kuat sebagai bagian 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 menunjukkan penggunaan argumen istirahat dan bernama dalam tanda tangan panggilan. Panggilan ke nsum mengambil sejumlah argumen arbitrer yang secara otomatis dikonversi menjadi Daftar. Panggilan ke np menunjukkan bagaimana parameter bernama dapat digunakan dan dicampur dengan parameter posisi.[becakcode.site]

Kumpulan contoh berikutnya menunjukkan bagaimana argumen spread dapat digunakan. Dalam kasus pertama tuple, @ [1, 2, 3], dibuat dan ditugaskan ke variabel t. Tuple ini kemudian menyebar untuk memberikan 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 contoh panggilan untuk np (... r) secara semantik sama dengan np (p1 = r.p1, p2 = r.p2). Meskipun tidak ditampilkan di sini, spread juga dapat digunakan pada koleksi apa pun, Daftar, Tetapkan, Peta, nilai data berdasarkan 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 dapat 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 menggunakan lingkup leksikal di mana mereka digunakan mulai dari blok saat ini, hingga argumen, variabel yang ditangkap, ketik dan akhirnya ruang lingkup namespace. Pembayangan tidak diizinkan pada variabel apa pun. Namun, untuk argumen / penduduk lokal dalam badan lambda dapat sama dengan nama-nama di badan deklarasi terlampir (mencegah penangkapan penutupan bagian 5.6 Konstruksi Lambda).

Kemampuan untuk melakukan resolusi konstan konjungsi bekerja dengan mencari definisi dari konstanta menggunakan Bar dan Baz. Jika definisi konstan adalah sama untuk keduanya maka ini didefinisikan dengan baik (dan legal) jika tidak maka ini adalah 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 dapat 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 kode pelat yang diperkenalkan oleh konstruktor, dan khususnya konstruktor yang memiliki daftar argumen panjang yang terutama diteruskan ke konstruktor super, bahasa Bosque menggunakan konstruksi melalui inisialisasi bidang langsung untuk membangun nilai entitas (objek). Untuk banyak penggunaan, pendekatan penginisialisasi langsung sederhana ini cukup dan tidak perlu untuk konstruktor kompleks yang menghitung nilai turunan sebagai bagian dari eksekusi 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 kode ini dua entitas Baz dialokasikan melalui konstruktor inisialisasi atom. Dalam kasus kedua bidang h yang dihilangkan diatur ke nilai default true yang diberikan.

Kadang-kadang berguna untuk merangkum logika inisialisasi dan, untuk mencapai ini, Bosque memberikan definisi fungsi pabrik yang beroperasi mirip dengan konstruktor tetapi, dalam beberapa hal, terbalik. Fungsi pabrik mengembalikan catatan dengan semua bidang yang diperlukan 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 contoh kami.

Dengan desain ini kebutuhan untuk melewatkan data melalui panggilan super dihilangkan karena data dapat langsung dimasukkan ke dalam penginisialisasi atau, jika konstruktor super memiliki logika pabrik, maka pabrik super dapat dipanggil dan hasilnya diperluas langsung ke konstruktor atom seperti 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 adalah bahwa hanya argumen yang diperlukan untuk perhitungan internal dari nilai inisialisasi yang harus disebarkan sementara semua yang lain dapat langsung diatur dalam initializer. Penghapusan kode boiler konstruktor dan pengurangan lewat argumen menyederhanakan definisi tipe nominal baru 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 kode untuk tubuh lambda dengan semantik salinan variabel untuk penutupan variabel yang ditangkap pada pembuatan lambda. Definisi tubuh dapat berupa ekspresi atau blok pernyataan. Dalam kasus ambiguitas, badan 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 contoh di atas, tipe ekspresi lambda secara eksplisit dinyatakan melalui deklarasi tipe eksplisit untuk argumen dan nilai balik. Namun, dalam kasus di mana lambda adalah 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 mencakup panggilan ke fungsi global dan fungsi anggota statis. Argumen variasi insulasi 5.1 Argumen dapat 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 akrab dari bahasa berorientasi objek lain tetapi kemampuan untuk melakukan doa statis menggunakan tipe konjungsi unik. Seperti halnya resolusi konstan yang dicakup, ini berfungsi dengan melihat definisi pemanggilan menggunakan Bar dan Baz. Jika definisi konstan adalah sama untuk keduanya maka ini didefinisikan dengan baik (dan legal) jika tidak maka ini adalah kesalahan ketik.[becakcode.site]

5.8 Rantai dan Tanpa Rantai



Menangani nilai-nilai tidak ada (atau null, tidak terdefinisi, dll dalam bahasa lain) adalah tugas yang relatif umum yang dapat mengaburkan maksud mendasar dari bagian kode dengan sarang kasus dan penanganan kondisional untuk kasus khusus.

Definisi Bosque memberikan dukungan untuk nilai-nilai tidak ada hubungan pendek pada semua tindakan yang dapat 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 dapat di rantai (bawah)? evaluasi 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 mendapatkan nilai pada indeks i dalam tuple atau tidak sama sekali jika indeks tidak ditentukan
@ [i, ..., j], buat tuple baru menggunakan 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 akses 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 dapat ditransfer termasuk:

.p untuk mendapatkan nilai yang terkait dengan properti atau tidak ada jika properti tidak didefinisikan
@ {f, ..., g}, buat catatan baru menggunakan 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 akses 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 dapat diakses berantai dengan cara yang sama seperti properti dalam catatan:

.f untuk mendapatkan nilai yang terkait dengan bidang atau kesalahan jika bidang tidak ditentukan pada jenisnya
@ {f, ..., g}, buat catatan baru menggunakan 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 akses ke elemen individual dalam suatu entitas (objek) sementara operator algebraic @ {} massal menyediakan pembentukan kembali nilai data yang ringkas dan sederhana. Perhatikan bahwa tipe hasil adalah catatan.[becakcode.site]

5.12 Proyeksi yang Diketik


Selain mengekstraksi tupel / catatan baru menggunakan notasi @ [] dan @ {} bahasa Bosque juga mendukung memproyeksikan data terstruktur menggunakan tipe melalui notasi Exp # Type. Operator rantai ini dapat 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 adalah 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 berdasarkan bidang per bidang. Namun, dengan pembaruan massal di Bosque dimungkinkan untuk melakukan pembaruan sebagai operasi atom dan tanpa secara manual mengekstraksi dan menyalin bidang. Bosque menyediakan operasi pembaruan yang tidak dapat 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 bantalan lokasi yang diperlukan sementara untuk catatan itu akan memasukkan properti yang ditentukan. Memperbarui bidang yang tidak ada pada tipe nominal adalah 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 gabungan yang dapat di rantai yang mengambil pasangan tuple / tuple, merekam / merekam, atau nominal / merekam dan menggabungkan nilai data menggunakan sintaks Exp <+ (Exp). Peta operasi tuple / tuple untuk ditambahkan, catatan / catatan adalah penggabungan kamus, dan nominal / catatan adalah 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 program ke dalam nilai memungkinkan kita untuk menulis kode pemrosesan data yang ringkas dan menghilangkan penyalinan kode yang berlebihan di sekitar nilai-nilai individual. Selain membantu mencegah bug halus selama pengkodean awal, operator juga dapat menyederhanakan proses memperbarui representasi data saat melakukan refactoring kode dengan mengurangi jumlah tempat 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 -> dapat 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 saat menggunakan 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 bar = 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 dapat digunakan pada nilai apa pun. Lihat bagian ini untuk info lebih lanjut tentang permintaan apa yang didukung.

5.18 Pipa



Pemrosesan koleksi tingkat tinggi adalah aspek mendasar dari bahasa Bosque (bagian) tetapi sering kali chaining filter / peta / dll. bukan cara alami untuk memikirkan serangkaian operasi tertentu dan dapat 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 menyebarkan tidak langsung ke output dalam pipa dan, | ??, yang melakukan hubung singkat pada pemrosesan dan menurunkan nilai. Beberapa contoh 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 berguna untuk menunjukkan 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 berbagai operator biner yang dapat 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 memberikan == dan! = Operator yang bekerja untuk nilai dari tipe berikut:

Tidak ada di mana tidak ada yang dapat dibandingkan dengan nilai-nilai dari jenis lain
Bool
Int
String tempat string yang diketik secara implisit dipaksa ke versi yang tidak diketik
GUID
Enum di mana mereka mengetik dan nilai harus sama
CustomKey tempat 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 referensi dalam bentuk apa pun. Suatu program dapat menggunakan perbandingan eksplisit pada tipe primitif atau pengembang dapat menentukan kunci khusus yang memberikan gagasan tentang kesetaraan, mis. identitas, kunci utama, kesetaraan, dll. yang masuk akal untuk domain mereka.

Kunci khusus dibandingkan dengan menggunakan 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 menggunakan 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 berbagai operator pesanan, <,>, <=, dan> = yang dapat 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 hubungan 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 menggunakan kondisi yang dapat mengembalikan Bool atau Tidak Ada dan menggunakan ini untuk memilih 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 mencakup pernyataan Match, If, dan Block () yang dapat 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 menciptakan lingkup leksikal baru 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 seperti yang dijelaskan dalam.[becakcode.site]

Ketika pernyataan blok digunakan sebagai ekspresi mereka tidak bisa menggunakan 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 mencakup Pencocokan yang diharapkan dan Jika yang dapat digunakan baik sebagai ekspresi dan pernyataan serta penugasan terstruktur untuk mudah merusak nilai kembali. Karena perangkat lunak keandalan tinggi adalah tujuan utama, Bosque memberikan 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 dapat dinyatakan sebagai dapat diperbarui dalam lingkup menggunakan var! formulir deklarasi. Di var! bentuk ekspresi initializer dapat digunakan untuk mengatur nilai awal untuk variabel atau dapat dihilangkan untuk membiarkan variabel tidak diinisialisasi.[becakcode.site]

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

Menggunakan var! formulir memungkinkan untuk pernyataan tugas selanjutnya (6.3 Penugasan Variabel) untuk memperbarui nilai variabel. Ini adalah kesalahan untuk menggunakan 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 introduced
6.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 kode pernyataan pengembalian keluar dari permintaan saat 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 kode kesalahan seringkali dapat mengaburkan aliran inti suatu fungsi dan menghasilkan kesalahan yang halus. Untuk menyederhanakan logika atau mengembalikan nilai dengan kode kesalahan, bahasa Bosque memberikan 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 menimbulkan kesalahan.
assert false; //raise error in debug
assert true;  //no effect
check false;  //raise error always
check true;   //no effect
Semantik kesalahan dalam Bosque adalah unik. Dalam sebagian besar bahasa, kesalahan dapat dibedakan karena pelaporan kesalahan runtime membutuhkan penyertaan informasi yang dapat diobservasi, seperti nomor baris dan pesan kesalahan, untuk mendukung analisis kegagalan dan debugging. Namun, karena eksekusi Bosque sepenuhnya deterministik (Penentuan 0,10) dan dapat diulang, bahasa ini memiliki 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 eksekusi dalam mode debug untuk menghitung kesalahan yang tepat! 6.7 If-Then-Else Pernyataan bersyarat jika di Bosque adalah struktur aliran 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 memiliki blok final lain. Untuk menghindari ambiguitas ketika Jika pernyataan / ekspresi digunakan, tindakan tidak dapat 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 adalah urutan pernyataan. Blok ini memperkenalkan lingkup leksikal baru 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 dapat memberi wawasan dan referensi bahasa pemrograman anda,Wassalam Salam Becak Code.




Assalamu'alaikum, perkenalkan nama saya Yosep alfatah bisa dipanggil Yosep, asal dari Banjar Jawa Barat. Saya mulai mengenal blog pada tahun 2016. Saya suka Belajar Hal baru dan Membagikannya.