Grammar - Chetabahana/method GitHub Wiki

Diagram Grammar adalah interface Diagram Channel yang merupakan pewarisan dari Diagram Sequence, dimana Diagram Sequence adalah pewarisan dari Diagram Flowchart.

Table of Contents

Struktur

Abstraksi adalah konsep pemindahan fokus dari detail dan implementasi konkret ke operasi yang tersedia sehingga membuat struktur pemrograman lebih sederhana dan lebih abstrak.

Seperti yang sudah dijelaskan pada topik Type Diagram, Diagram Grammar adalah pewarisan dari penelusuran Pola Enkapsulasi yang dilakukan pada Diagram Sequence.

Sesuai dengan karakternya sebagai diagram syntax maka berdasarkan Konsep Abstraction terpilih diagram yang digunakan untuk visualisasi abstrak dari Pola Kerja sebagai warisan dari Diagram Sequence dengan menggunakan pustaka javascript: Lexer dan Parser.

Diagram ini akan kita alokasikan dengan id: 59 yang akan berfungsi dalam mengungkap benteng komunikasi rahasia yang tersirat secara abstrak dalam komposisi bilangan² prima pada id: 58.

Pada sesi ini kita akan batasi pembahasan kedalam penggunaan diagram ini saja, mengenai detil paketnya akan dibahas terpisah dibagian dokumentasi repository terkait.

Model

Pewarisan ini akan digunakan sebagai interface dari Diagram Channel guna penelusuran class dengan Polymorphism.

Limit

Ketika mengenkapsulasi maka implementasi ke Diagram Sequence hanya menunjukkan urutan dan definisi dari Pola Kerja, berarti konsep nya adalah menyembunyikan detail.

Untuk mengatur identifikasi dari proses penelusuran tersebut maka berdasarkan Konsep Dasar pada Diagram Grammar ini dilakukan konfigurasi terhadap instance dari Pola Abstraction.

Contoh pada Diagram Grammar sebenarnya penelusuran dilakukan menggunakan detail dari Lexer dan Parser. Informasi ini ditunjukkan (tidak disembunyikan), tetapi dikemas dan diperlihatkan secara Abstrak dengan menggunakan diagram.

Range

Bahasa terbagi menjadi dua jenis yaitu Bahasa Natural dan Bahasa Formal. Secara terminologi, bahasa formal dapat diuraikan dengan suatu prosedur berupa aturan (metalanguage) yang terdiri dari dua bagian yang disebut dengan context-free languages and regular languages.


Produk dari prosedur ini disebut dengan Tata bahasa (Grammar). Dalam Bahasa Pemrograman produk dari prosedur ini disebut dengan Syntax. Sedangkan aturannya disebut Metasyntax.

Layout

Tata bahasa (Grammar) adalah seperangkat aturan untuk dalam menata kata dalam bahasa formal.

Senada dengan teori bahasa, maka jenis grammar yang terpenting adalah context-free grammars and regular grammars.

Context-free grammars adalah yang dipakai untuk membuat syntax dalam membangun suatu algoritma. Formasi yang banyak digunakan adalah Backus – Naur Form (BNF).

Dalam project ini kita akan gunakan EBNF yaitu salah satu keluarga notasi Metasyntax BNF yang digunakan untuk mengekspresikan (visualisasi) dari Context-free_grammars.

grammar = rule, newline;
rule = lhs, [ ws ], "=", rhs, ";";
lhs = identifier;
rhs = [ [ ws ], alternation, [ ws ], { ",", [ ws ], alternation, [ ws ] } ];
alternation = [ [ ws ], element, [ ws ], { "|", element, [ ws ] } ];
element = optional | repeated | group | terminal | identifier;
optional = "[", [ ws ], rhs, [ ws ], "]";
repeated = "{", [ ws ], rhs, [ ws ], "}";
group = "(", [ ws ], rhs, [ ws ], ")";
terminal = dq_string | sq_string;
dq_string = '"', dq_string_char, '"';
sq_string = "'", sq_string_char, "'";
dq_string_char = "'" | character;
sq_string_char = '"' | character;
identifier = letter, { identifier_character };
identifier_character = "_" | letter | digit;
letter = "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L"
       | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X"
       | "Y" | "Z" | "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j"
       | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v"
       | "w" | "x" | "y" | "z";
digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
character = "[" | "]" | "{" | "}" | "(" | ")" | "|" | "," | "=" | ";"
          | symbol | newline | ws | identifier_character;
symbol = "~" | "`" | "!" | "@" | "#" | "$" | "%" | "^" | "&" | "*" | "-" | "+"
       | "\" | ":" | "<" | ">" | "?" | "." | "/";
newline = { [ "\r" ], "n" };
ws = { "\t" | " " };
Bash-util
Koleksi utilitas Bash menggunakan chevrotain dan eslint-plugin-bashutils untuk display dari grammar bash.
CoffeScript
Implementation Languages Examples
VRML Loader
VRML (Virtual Reality Modeling Language, diucapkan vermal atau dengan inisialnya, awalnya — sebelum 1995 — dikenal sebagai Virtual Reality Markup Language) adalah format file standar untuk mewakili grafik vektor interaktif 3-dimensi (3D), yang dirancang khusus dengan World Wide Web. Saat ini VRML akan digantikan oleh X3D.

Chart

Format

SELECT column1 FROM table2
SELECT name, age FROM persons WHERE age > 10

Hirarki

const createToken = chevrotain.createToken

// using createToken API
const Select = createToken({
    name: "Select",
    pattern: /SELECT/,
    longer_alt: Identifier
})
const From = createToken({
    name: "From",
    pattern: /FROM/,
    longer_alt: Identifier
})
const Where = createToken({
    name: "Where",
    pattern: /WHERE/,
    longer_alt: Identifier
})

Formasi

// note we are placing WhiteSpace first as it is very common thus it will speed up the lexer.
let allTokens = [
    WhiteSpace,
    // "keywords" appear before the Identifier
    Select,
    From,
    Where,
    Comma,
    // The Identifier must appear after the keywords because all keywords are valid identifiers.
    Identifier,
    Integer,
    GreaterThan,
    LessThan
]
let SelectLexer = new Lexer(allTokens)

let inputText = "SELECT column1 FROM table2"
let lexingResult = SelectLexer.tokenize(inputText)

Diagram

Metode

Proses

Berikut ini kita bahas hubungan 114 dengan 168 dan 618.


Hubungan antara sembilanbelas (19) ke sistem formasi 114 via bilangan duapuluhempat (24) dapat digambarkan seperti dua (2) segitiga yang berbentuk bintang dengan enam (6) sudut.

48
└── 4 + 8 = 12
            └── 1 + 2 = 3
---
48 = dr(3)

Hubungan antara sembilanbelas (19) ke sistem formasi 114 via bilangan duabelas (12) dapat digambarkan seperti tujuh (7) hexagon dengan enam (6) sudut seperti berikut ini:

Pada bentuk pentagram akan terdapat hubungan 618 dengan angka 108.

108 = 6²+6²+6² = 36 + 36 + 36
                           └── 9:9:9 = 27

9→81→63→27→45→9

99² = 9801
      └── 98 + 01 = 99

99 = 124875(142857)

Faktorisasi dengan angka prima 37 akar muncul akar digital vortex: 3, 6, 9.

Faktorisasi dengan angka composite 18 akar muncul hubungan segitiga: 48, 60, 108.

3,6,9

3 x 37 = 111
6 x 37 = 222
9 x 37 = 333
------------ +
         666

48 => dr(3) 3 x 37 = 111
60 => dr(6) 6 x 37 = 222
108 => dr(9) 9 x 37 = 333

(6+6+6)×37 = 666 = 111 + 222 + 333
3 + 6 + 9 = 18 => dr(18) 18 x 37 = 666
Setelah ditelusuri lebih lanjut ternyata formasi 168 ada pada proses distribusi bilangan prima yang menghasilkan diagram berikut.


Kontras dengan π(1000)=168 maka diagram ini adalah hasil dari pendistribusian π(89²) = 1000. Dimana jika dijumlahkan akar digitalnya:

dr(3) + dr(6) = 48 + 60 = 108
dr(6) + dr(9) = 60 + 108 = 168

Dengan demikian formasi dari angka 168 dan 618 ini adalah juga representasi dari distribusi bilangan prima akan tetapi dalam bentuk saling berpasangan atau berkaitan.

Semua gugus ini membentuk Sistem DNA masing² dalam konfigurasi empat (4) pasang dengan struktur utama tiga (3) layar hexagon:

Bases (yellow) :
60 = 9 x 4 + 6 x 4 = 36 + 24

Sugar (red):
48 = 8 x 5 + 8 x 1 = 40 + 8

Sistem (center layers hexagon):
114 = 6 + 48 + 60

Jumlahnya 114 cocok dengan angka kunci ketiga..
Selanjutnya kita sebut saja formasi ini sebagai formasi 1-1-4

Anda lihat formasi 1-1-4 pada kombinasi ini dibentuk dari gabungan angka 48 dan 60 dengan angka enam (6) yang disini berfungsi secara unit hexagon sebagai pengatur dan penyimpan informasi genetik dari semua proses.

Karena 168 dan 618 sendiri adalah juga representasi dari suatu distribusi bilangan maka sistemnya dapat kita duga sebagai bagian dari suatu konfigurasi yang sangat kompleks.

Berikutnya kita lihat peta composite & prime.
Entah kebetulan atau tidak, sedikit banyak ada korelasi. Coba simak kalimat berikut:

The number 4 multiplies itself trough the system as a Equilateral Triangles. It bounces from position 4, 8, and 12. All multiplies of 4 are found in these positions (Red: illustrated by a triangle covering number 4).

Disini Anda bisa melihat bahwa angka empat (4) disebar dalam bentuk sebagai segitiga yang pada proses di atas ini dibentuk secara keseluruhan dengan formasi 1-1-4.

Sampai disini kita sudah menentukan metoda untuk kunci ketiga yaitu 114.

Scope

Pada Sistem DNA konfigurasi ini dapat ditunjukkan dengan proses dari bangun strukturnya sendiri.

Warna kuning mewakili gugus Nitrogen yang dinamakan Adenine (A), Guanine (G), Cytosin (C), dan Thymin (T).

Struktur C dan T yang berbentuk hexagon dibangun dengan enam (6) ikatan:

Struktur A dan G dengan bentuk gabungan hexagon dan segilima dibangun dengan sembilan (9) ikatan:

Warna merah mewakili gugus yang dinamakan polinukletida. Strukturnya dibangun dengan kombinasi gula dengan lima (5) ikatan berbentuk segilima dan fosfat dengan satu (1) grup ikatan tanpa bentuk khusus.

Semua gugus ini membentuk Sistem DNA masing² dalam konfigurasi empat (4) pasang dengan struktur utama tiga (3) layar hexagon:

Bases (yellow) :
60 = 9 x 4 + 6 x 4 = 36 + 24

Sugar (red):
48 = 8 x 5 + 8 x 1 = 40 + 8

Sistem (center layers hexagon):
114 = 6 + 48 + 60

Extend

Synergy

Simetri

Typical

Matriks

  • CONSUME - ambil Token.
  • SUBRULE - referensi ke aturan lain.
  • OR - Alternatif
  • OPTION - produksi opsional
  • MANY - repetisi nol atau lebih
  • AT_LEAST_ONE - pengulangan satu atau lebih
  • MANY_SEP - pengulangan (nol atau lebih) dengan pemisah antara dua item
  • AT_LEAST_ONE_SEP - pengulangan (satu atau lebih) dengan pemisah antara dua item
Grammar:
selectStatement
   : selectClause fromClause (whereClause)?
Grammar Rule:
// selectStatement

const $ = this
$.RULE("selectStatement", () => {
    $.SUBRULE($.selectClause)
    $.SUBRULE($.fromClause)
    $.OPTION(() => {
        $.SUBRULE($.whereClause)
    })
})

Layout

const { CstParser } = require("chevrotain")
const allTokens = [
    WhiteSpace,
    Select,
    From,
    Where,
    Comma,
    Identifier,
    Integer,
    GreaterThan,
    LessThan
]

class SelectParser extends CstParser {
    constructor() {
        super(allTokens)

        const $ = this

        $.RULE("selectStatement", () => {
            $.SUBRULE($.selectClause)
            $.SUBRULE($.fromClause)
            $.OPTION(() => {
                $.SUBRULE($.whereClause)
            })
        })

        this.performSelfAnalysis()
    }
}

Output akan berupa visual abstrak yang dikenal dengan istilah Abstract syntax tree (AST)

Dalam ilmu komputer, Abstract syntax tree (AST), atau hanya syntax tree, adalah representasi pohon dari struktur sintaksis abstrak dari kode sumber yang ditulis dalam bahasa pemrograman. Setiap simpul pohon menunjukkan konstruksi yang terjadi dalam kode sumber.

Dimensi

GAST (Grammar AST) data structure:

Interaksi

Internal

Standar

Proporsi

Pada bagian ini kita akan bahas tentang detil pewarisan dari Diagram Grammar berikut dengan instantiation dan implementasinya.

Interface

Sesuai metode di atas maka Diagram Grammar akan berlaku sebagai interface dari Pola Abstraction. Pewarisan ke Diagram Channel dilakukan via identifikasi berdasarkan pola Pola Polymorphism:

Polymorphism dapat berarti banyak bentuk, yaitu kita dapat menimpa (override) suatu method, yang berasal dari parent class (super class) dimana object tersebut diturunkan, sehingga memiliki kelakuan yang berbeda.

Dalam konsep yang lebih umum sering kali polymorphism disebut dalam istilah satu interface banyak aksi.

Dapat menggunakan kelas-kelas yang kita buat (sebagai super kelas) dan membuat subkelas baru berdasar superkelas tersebut dengan karakteristik yang lebih khusus dari behaviour umum yang dimiliki superkelas.

Subkelas-subkelas dari kelas ini yang disebut kelas konkret, mengimplementasikan behaviuor abstrak tersebut sesuai dengan kebutuhan masing-masing.

Dapat membuat super kelas yang hanya mendefinisikan behaviuor namun tidak memberikan implementasi dari metode-metode yang ada. Hal ini berguna jika ingin membuat template kelas, kelas ini disebut kelas abstrak karena behaviournya masih abstrak dan belum diimplementasikan.

Menghindari duplikasi object, yang dapat menciptakan class baru dari class yang sudah ada, sehingga tidak perlu menuliskan code dari nol ataupun mengulangnya, namun tetap bisa menambahkan attribute dan atau method unik dari class itu sendiri.

Kategori

Sesuai prinsip dasar piramida maka delegasi dan Interaksi dari Diagram Grammar akan diproses berdasarkan Konsep Polymorphism.


Guna mengeksplorasi tentang sifat-sifat abstrak instance secara lebih sederhana maka sesuai yang telah dijelaskan, sebelumnya perlu dilakukan optimasi dengan memodelkan tipe dan struktur modul secara Monomorphism.

Cakupan dari masing² Tier dapat diuraikan sebagai berikut:

  1. Presentation tier, mencakup Model, Viewers dan Controller
  2. Bussines Logic tier, mencakup Lexer, Parser dan Syntax Tree
  3. Data layer atau library, mencakup Database, Tree bank dan Storage

Pemodelan yang diterapkan adalah dengan metode Model-View-Controller seperti terlihat pada gambar berikut.

Model-View-Controller atau MVC adalah sebuah metode untuk membuat sebuah aplikasi dengan memisahkan data (Model) dari tampilan (View) dan cara bagaimana memprosesnya (Controller).

  1. Model mewakili struktur data. Biasanya model berisi fungsi-fungsi yang membantu seseorang dalam pengelolaan basis data seperti memasukkan data ke basis data, pembaruan data dll
  2. Viewers adalah bagian yang mengatur tampilan ke pengguna berupa halaman web.
  3. Controller merupakan bagian yang menjembatani model dan view. Controller berisi perintah-perintah yang berfungsi untuk memproses suatu data dan mengirimkannya ke halaman web
Tier
Layer disusun mengikuti konsep Three Tier Architecture:
  1. tier1: presentation layer, direpresentasikan oleh Viewer
  2. tier2: bussines logic layer, direpresentasikan oleh Controller
  3. tier3: data access layer atau library, direpresentasikan oleh Model
Layer
Hubungan antar tiap Layer dapat diuraikan sebagai berikut:
  • Viewer hanya mengatur tampilan via logic/rules, prosesnya dilakukan via Controller
  • Model hanya mewakili data atau library, tidak mencakup process seperti halnya Controller
  • Interaksi antara Viewer dan Model ke masing² tier1, tier2, dan tier3 adalah via Controller
Sesuai Pola Abstraction yang menekankan visualisasi dari setiap object maka pola identifikasi model diberlakukan untuk setiap object pada pewarisan dari Diagram Sequence dan disetel untuk fokus ke pola dari Diagram Flowchart:
Model
Dengan demikian Model disusun berdasarkan pola dari yang mewakili struktur data:
  1. model1: hanya proses alir atau simpan data (start / end)
  2. model2: proses satu input dan satu output (input / output)
  3. model3: dua input dan satu output (sub input / sub output / fix input)
  4. model4: satu input dan dua output (uji input / uji hasil / fix output)
  5. model5: proses data dari/ke Viewer
  6. model6: proses data dari/ke Controller
Viewer
Viewer disusun mengikuti konsep Model-View-Controller:
  1. viewer1: proses data dari/ke model1
  2. viewer2: proses data dari/ke model2
  3. viewer3: proses data dari/ke model3
  4. viewer4: proses data dari/ke model4
  5. viewer5: proses data dari/ke model5
  6. viewer6: proses data dari/ke Controller
Controller
Controller disusun berdasarkan Module:
  1. controller1: hanya proses alir atau simpan data
  2. controller2: proses data dari module1 ke tier3 (via model2)
  3. controller3: proses data dari module2 ke tier1 (via viewer2)
  4. controller4: proses data dari/ke tier2

Parameter

Pada bagian ini kita akan masuk ke detil tentang cara penyusunan struktur yang dilakukan untuk menerapkan konsep dan metode yang diuraikan di atas ke dalam bahasa pemrograman.

Realisasi dari uraian berikut ini dapat dilihat pada file script Grammar.js.

Eksternal

Berikut ini bagan yang akan digunakan untuk visualisasi hubungan antar kelas.

Pada bagan ini, Kelas dasar adalah form. Sedangkan form1,2,3 dan model1,2,3,4 adalah kelas turunan yang telah mewarisi hubungan serta pemisahan dengan kelas dasar.

Disini form1,2,3 merupakan kelas baru yang secara berurut memiliki karakteristik Lexer, Parser dan Syntax yang diwariskan dari Prinsip Polimorfism pada Diagram Grammar. Sedangkan model1,2,3,4 adalah pemisahan class terhadap bentuk (model) dari property dan method yang dimilikinya.

Formulasi

Bagan di bawah ini menjelaskan fungsionalitas setiap peran, bagaimana peran tersebut dipetakan ke topologi fisik yang diperlukan untuk manajemen solusi, integrasi nirkabel, dan aplikasi kebijakan. Model ini dipilih karena umumnya lebih mewakili tren dan relevansi penyebaran.

Identifikasi

id: 40

---+-----+-----
 1 | 1   | 22
---+-----+-----
 2 | 23  | 27
---+-----+-----
 3 | 28  | 54
---+-----+-----
 4 | 55  | 76
---+-----+-----
 5 | 77  | 85
---+-----+-----
7 + 11 + 13 + 17 + 19 = 67 = 19th prime
----+-----+-----+-----+-----+
 786| 1,2 |  2  | 2,3 | 3,4 | {19}
----+-----+-----+-----+-----+
  86|  4  | 4,5 | 5,6 |{6,7}| 17
    +-----+-----+-----+-----+
  78| 7,8 | 8,9 | 12 (M dan F)
    +-----+-----+-----+
{67}| 9,11|11,12|12,14| 11
----+-----+-----+-----+-----+
 {6}|15,16|17,18|18,20|21,22| 19
    +-----+-----+-----+-----+
  8 |23,25|25,27|27,29| 18
    +-----+-----+-----+-----+-----+-----+-----+-----+-------+
 {7}|29,33|33,36|36,39|39,41|41,45|46,51|51,57|58,66|{67,77}| 43 (C1 dan C2)
----+-----+-----+-----+-----+-----+-----+-----+-----+-------+
      1     2     3     4     5     6     7     8      9

Cyclic: 
66 + 1 = 67
66 + 11 = 77
66 + 19 = 85

Permutations:
19,(6,7),7
   └ ∑(6,7) = 13
19 x 13 x 7 = 1729

Coba kita lihat lagi peta composite & prime.

Entah kebetulan atau tidak, sedikit banyak ada korelasi. Coba simak kalimat berikut:

11 is the top left prime position it cascades out to the left and circles back around the system.
1 + 11 + 44 + 71 = 1 + 11 + 115 = 1 + 11 + (1 + 114)
Sekian.

SALAM Sukses!
© Chetabahana Project

Referensi

⚠️ **GitHub.com Fallback** ⚠️