Generic programming ใน Ada — เขียนสัญญาด้วยชนิดข้อมูล เพื่อนำกลับมาใช้ใหม่แบบ zero-cost

flowchart LR
    accTitle: ทางเลือกเมื่อจะนำโค้ดกลับมาใช้ใหม่
    accDescr: เปรียบเทียบการคัดลอกวาง การรับผ่าน void* หรือ cast กับ generic ของ Ada ที่ type-safe ตรวจตอนคอมไพล์ และไม่มี dispatch ส่วนเกินตอนรัน
    A[ตรรกะที่อยากนำกลับมาใช้ใหม่] --> B{จะนำกลับมาใช้ใหม่อย่างไร}
    B --> C[คัดลอกแล้ววาง]
    B --> D[void* / Object / cast]
    B --> E[generic ของ Ada]

    C --> C1[พลาดแก้ไม่ครบได้ง่าย]
    D --> D1[ผิดพลาดตอนรันหรือเสีย type safety ได้ง่าย]
    E --> E1[type-safe]
    E --> E2[ตรวจตอนคอมไพล์]
    E --> E3[ไม่มี dispatch ส่วนเกินตอนรัน]

flowchart LR
    accTitle: แผนที่ความรู้ generic programming ของ Ada
    accDescr: แผนภาพที่แสดงว่า generic subprogram และ generic package ตั้งอยู่บนสัญญา (contract model) ของ formal parameter ที่เป็นชนิดข้อมูล ค่า ซับโปรแกรม และ package ว่าสัญญาถูกตรวจตอน instantiate ด้วย new และความต่างจากปัญหาข้อผิดพลาดตอน instantiate ที่ template ของ C++ มีมาตามประวัติ
    ada_generics["generic ของ Ada (generic unit)"]
    ada_generic_contract_model["contract model ของ Ada generic"]
    ada["Ada (ภาษาโปรแกรม)"]
    ada_generic_subprogram["ซับโปรแกรม generic (Generic Subprogram)"]
    ada_generic_package["แพ็กเกจ generic (Generic Package)"]
    ada_generic_formal_type["พารามิเตอร์ Formal Type"]
    ada_generic_formal_subprogram["พารามิเตอร์ Formal Subprogram"]
    ada_generic_formal_package["พารามิเตอร์ Formal Package"]
    ada_generic_instantiation["การสร้างอินสแตนซ์ (instantiation)"]
    ada_generic_formal_object["พารามิเตอร์ Formal Object (ค่า)"]
    late_instantiation_error["ข้อผิดพลาดเทมเพลตที่รู้ได้ตอนสร้างอินสแตนซ์เท่านั้น"]
    cpp_templates["เทมเพลต C++"]
    gnat["GNAT"]
    alire["Alire"]
    ada -->|"อิมพลีเมนต์"| ada_generics
    ada_generics -->|"ใช้"| ada_generic_subprogram
    ada_generics -->|"ใช้"| ada_generic_package
    ada_generic_subprogram -.->|"ต้องมี"| ada_generic_formal_type
    ada_generics -->|"ใช้"| ada_generic_formal_subprogram
    ada_generics -->|"ใช้"| ada_generic_formal_package
    ada_generics -->|"ต้องมี"| ada_generic_instantiation
    ada_generic_formal_type -->|"กำหนดค่าด้วย"| ada_generic_instantiation
    ada_generic_package -.->|"ต้องมี"| ada_generic_formal_type
    ada_generic_package -.->|"ต้องมี"| ada_generic_formal_object
    ada_generic_formal_subprogram -->|"อิมพลีเมนต์"| ada_generic_contract_model
    ada_generic_formal_type -->|"อิมพลีเมนต์"| ada_generic_contract_model
    ada_generic_contract_model -->|"ป้องกัน"| late_instantiation_error
    cpp_templates -.->|"อาจก่อให้เกิด"| late_instantiation_error
    ada_generic_formal_package -->|"ต้องมี"| ada_generic_instantiation
    gnat -->|"อิมพลีเมนต์"| ada
    gnat -.->|"กำหนดค่าด้วย"| alire
    ada_generic_subprogram -.->|"ใช้"| ada_generic_formal_subprogram
    ada_generic_package -.->|"ใช้"| ada_generic_formal_subprogram
    ada_generic_instantiation -.->|"ต้องมี"| ada_generic_formal_object
    ada_generic_formal_object -->|"อิมพลีเมนต์"| ada_generic_contract_model

mindmap
    root((Ada Generics))
      Generic Subprogram
        Swap
        Count_If
        Sort
      Generic Package
        Stack
        Statistics
        KV Store
      Formal Parameters
        Type
          private
          limited private
          range box
          mod box
          digits box
          delta box
          discrete box
        Object
          Max_Size
          Threshold
        Subprogram
          Less function
          Equals function
          Predicate
        Package
          with package P is new Generic
      แนวคิดออกแบบ
        Contract Model
        Static Checking
        Zero-Cost Abstraction
        แยก Specification กับ Body

flowchart TB
    accTitle: โครงไฟล์ตัวอย่าง
    accDescr: ตัวอย่างอยู่ใน ada-generic-programming/src/snippets เป็นไฟล์ .ada ทีละหัวข้อ พร้อม README.md ที่ราก
    R[ada-generic-programming/] --> S[src/]
    S --> N[snippets/]
    N --> A[01_swap.ada]
    N --> B[02_stack.ada]
    N --> C[03_sort.ada]
    N --> D[04_statistics.ada]
    N --> E[05_filter.ada]
    N --> F[06_kv_store.ada]
    R --> README[README.md]

sequenceDiagram
    accTitle: ลำดับ gnatchop แล้ว gnatmake
    accDescr: ผู้พัฒนาส่งไฟล์ .ada ไฟล์เดียว ให้ gnatchop แยกเป็น .ads .adb และ main แล้ว gnatmake bind กับ link จนได้ไฟล์ executable
    participant Dev as ผู้พัฒนา
    participant Chop as gnatchop
    participant Build as gnatmake
    participant Exe as ไฟล์ executable

    Dev->>Chop: ส่งไฟล์ .ada ไฟล์เดียว
    Chop-->>Dev: แยกเป็น .ads / .adb / main
    Dev->>Build: gnatmake -gnata main
    Build-->>Dev: bind และ link จนจบ
    Dev->>Exe: ./main
    Exe-->>Dev: ผลลัพธ์การรัน

flowchart LR
    accTitle: โมเดลสามขั้นของ generic ใน Ada
    accDescr: จากประกาศ generic ผ่าน formal parameter และ body ไปสู่ instantiation ด้วย new แล้วใช้เป็น subprogram หรือ package ปกติ
    G[ประกาศ generic] --> F[formal parameter]
    F --> B[generic body]
    B --> I[instantiation ด้วย new]
    I --> U[ใช้เป็น subprogram หรือ package ปกติ]

    F --> F1[ชนิดข้อมูล]
    F --> F2[ค่า]
    F --> F3[ซับโปรแกรม]
    F --> F4[package]

flowchart TB
    accTitle: Instantiation ของ Generic_Swap ตามชนิด
    accDescr: Generic_Swap ที่รับ Element เป็น private ถูก instantiate เป็น Swap ของ Integer Character และ My_Record แล้วสลับตัวแปรชนิดนั้น
    Template[Generic_Swap<br/>type Element is private] -->|ส่ง Integer| SwapInt[Swap_Integer]
    Template -->|ส่ง Character| SwapChar[Swap_Character]
    Template -->|ส่ง My_Record| SwapRecord[Swap_My_Record]

    SwapInt --> ICall[สลับตัวแปร Integer]
    SwapChar --> CCall[สลับตัวแปร Character]
    SwapRecord --> RCall[สลับตัวแปร My_Record]

flowchart TB
    accTitle: ชนิดของ formal parameter
    accDescr: Formal parameter ของ Ada มีชนิดข้อมูล ค่าวัตถุ ซับโปรแกรม และ package พร้อมตัวอย่างเช่น private digits box และ with function
    P[generic formal parameters] --> T[type parameter]
    P --> O[object / value parameter]
    P --> S[subprogram parameter]
    P --> PKG[package parameter]

    T --> T1[type Element is private]
    T --> T2[type Index is box]
    T --> T3[type Real is digits box]
    O --> O1[Max_Size : Positive]
    O --> O2[Default_Value : Element]
    S --> S1[with function Less...]
    S --> S2[with procedure Put ...]
    PKG --> P1[with package P is new ...]

flowchart LR
    accTitle: การสลับค่าด้วยตัวแปรชั่วคราว
    accDescr: ก่อนเรียก A เป็น 10 และ B เป็น 20 หลังคัดลอกผ่าน Temp ค่าของ A และ B สลับกัน
    subgraph Before[ก่อนเรียก]
        A1[A = 10]
        B1[B = 20]
    end

    A1 --> T[Temp = A]
    B1 --> A2[A = B]
    T --> B2[B = Temp]

    subgraph After[หลังเรียก]
        A2[A = 20]
        B2[B = 10]
    end

flowchart TB
    accTitle: Generic_Stack รับชนิดกับขนาด
    accDescr: Generic_Stack รับ Element_Type กับ Max_Size แล้วให้ Push Pop Size และถูก instantiate เป็นสแตก Integer Float และสตริง
    G[Generic_Stack] --> P1[Element_Type]
    G --> P2[Max_Size]
    G --> Ops[Push / Pop / Size / Is_Empty / Is_Full]

    G --> I1[Int_Stack<br/>Element=Integer<br/>Max_Size=5]
    G --> I2[Float_Stack<br/>Element=Float<br/>Max_Size=3]
    G --> I3[String_Stack<br/>Element=Unbounded_String<br/>Max_Size=20]

flowchart LR
    accTitle: สถานะของ Int_Stack กับ Float_Stack แยกกัน
    accDescr: Generic_Stack สร้าง Int_Stack และ Float_Stack แต่ละตัวมี Top และ Data ของตัวเอง ไม่แชร์สถานะ
    Template[Generic_Stack] --> IntStack[Int_Stack]
    Template --> FloatStack[Float_Stack]

    subgraph I[สถานะของ Int_Stack]
        ITop[Top]
        IData[Data : อาร์เรย์ Integer]
    end

    subgraph F[สถานะของ Float_Stack]
        FTop[Top]
        FData[Data : อาร์เรย์ Float]
    end

    IntStack --> I
    FloatStack --> F

stateDiagram-v2
    accTitle: การเปลี่ยนสถานะของสแตก
    accDescr: สแตกเคลื่อนระหว่าง Empty NonEmpty และ Full ด้วย Push กับ Pop และไป Overflow หรือ Underflow เมื่อทำนอกสัญญา
    [*] --> Empty
    Empty --> NonEmpty: Push
    NonEmpty --> NonEmpty: Push / Pop
    NonEmpty --> Empty: Pop ตัวสุดท้ายออก
    NonEmpty --> Full: Push จนถึง Max_Size
    Full --> NonEmpty: Pop
    Full --> Overflow: Push
    Empty --> Underflow: Pop

flowchart LR
    accTitle: ฉีดฟังก์ชันเปรียบเทียบเข้า Generic_Insertion_Sort
    accDescr: Generic_Insertion_Sort รับชนิดสมาชิก ดัชนี อาร์เรย์ และฟังก์ชันเปรียบเทียบ เพื่อเรียงน้อยไปมาก มากไปน้อย หรือลำดับที่กำหนดเอง
    A[Generic_Insertion_Sort] --> T[Item_Type]
    A --> I[Index]
    A --> ARR[Item_Array]
    A --> CMP[ฟังก์ชันเปรียบเทียบ]

    CMP --> ASC[ใช้การเปรียบเทียบมาตรฐาน]
    CMP --> DESC[ส่ง Greater เพื่อเรียงมากไปน้อย]
    CMP --> CUSTOM[ส่งลำดับที่กำหนดเอง]

flowchart TB
    accTitle: ขั้นตอน insertion sort
    accDescr: หยิบ Key จากซ้าย เลื่อนสมาชิกก่อนหน้าไปทางขวาจนกว่าจะเจอที่แทรก แล้วทำซ้ำจนอาร์เรย์เรียงแล้ว
    Start[อาร์เรย์ยังไม่เรียง] --> Pick[หยิบ Key จากซ้ายไปขวา]
    Pick --> Compare{Key มาก่อนสมาชิกก่อนหน้าหรือไม่? }
    Compare -->|Yes| Shift[เลื่อนสมาชิกก่อนหน้าไปทางขวา]
    Shift --> Compare
    Compare -->|No| Insert[แทรก Key]
    Insert --> Done{ทำจนตัวสุดท้ายแล้วหรือยัง?}
    Done -->|No| Pick
    Done -->|Yes| End[อาร์เรย์เรียงแล้ว]

flowchart LR
    accTitle: เรียงน้อยไปมากและมากไปน้อยจาก body เดียวกัน
    accDescr: ข้อมูลชุดเดียวกันถูก Sort_Asc ด้วยการเปรียบเทียบมาตรฐาน และ Sort_Desc ด้วย Greater ได้ลำดับกลับกัน
    Data[99, 3, 47, 12] --> A[Sort_Asc<br/>การเปรียบเทียบมาตรฐาน]
    Data --> D[Sort_Desc<br/>ส่ง Greater เป็นฟังก์ชันเปรียบเทียบ]
    A --> AO[3, 12, 47, 99]
    D --> DO[99, 47, 12, 3]

flowchart TB
    accTitle: หมวดของ formal type
    accDescr: Formal type แยกเป็น private limited private discrete range mod digits delta และ access พร้อมตัวอย่างชนิดที่เข้าแต่ละหมวด
    FormalType[Formal Type] --> Private[private]
    FormalType --> Limited[limited private]
    FormalType --> Discrete[discrete box: discrete type]
    FormalType --> Signed[range box: signed integer]
    FormalType --> Modular[mod box: modular integer]
    FormalType --> Float[digits box: floating-point]
    FormalType --> Fixed[delta box: fixed-point]
    FormalType --> Access[ชนิด access]

    Discrete --> Enum[enumeration]
    Discrete --> Int[ชนิดจำนวนเต็ม]
    Float --> F1[Float]
    Float --> F2[Long_Float]
    Float --> F3[ชนิดทศนิยมลอยตัวที่ผู้ใช้กำหนด]

flowchart LR
    accTitle: Generic_Statistics ใช้กับความละเอียดต่างกัน
    accDescr: Generic_Statistics ที่ Real เป็น digits box ถูก instantiate เป็น Float_Stats Long_Stats และ My_Real_Stats เพื่อคำนวณ Mean กับ Variance
    Stats[Generic_Statistics<br/>Real is digits box] --> FS[Float_Stats]
    Stats --> LS[Long_Stats]
    Stats --> MS[My_Real_Stats]

    FS --> FCalc[Mean / Variance ด้วย Float]
    LS --> LCalc[Mean / Variance ด้วย Long_Float]
    MS --> MCalc[Mean / Variance ด้วย Real ที่ผู้ใช้กำหนด]

flowchart LR
    accTitle: การฉีด predicate เข้า Generic_Count_If
    accDescr: ไล่สมาชิกอาร์เรย์ ถ้า Predicate เป็นจริงเพิ่ม Count แล้วคืน Count
    Arr[อาร์เรย์] --> Loop[ไล่แต่ละสมาชิก]
    Loop --> P{"Predicate(Item)?"}
    P -->|True| Inc[เพิ่ม Count]
    P -->|False| Skip[ไม่ทำอะไร]
    Inc --> Next[ไปสมาชิกถัดไป]
    Skip --> Next
    Next --> Result[คืน Count]

flowchart TB
    accTitle: นับเลขคู่กับนับเกินเกณฑ์จากตัวเดียวกัน
    accDescr: Generic_Count_If ถูก instantiate เป็น Count_Even ด้วย Is_Even และ Count_Large ด้วย Is_Large บนข้อมูลชุดเดียวกัน
    G[Generic_Count_If] --> E[Count_Even<br/>Predicate = Is_Even]
    G --> L[Count_Large<br/>Predicate = Is_Large]

    Data[12, 7, 88, 3, 56, 91, 44, 19, 62] --> E
    Data --> L
    E --> ER[จำนวนเลขคู่]
    L --> LR[จำนวนที่มากกว่า 50]

flowchart TB
    accTitle: Generic_KV_Store ประกอบหลายพารามิเตอร์
    accDescr: Generic_KV_Store รับชนิดคีย์ ชนิดค่า ฟังก์ชันเทียบคีย์ และ Max_Entries แล้วให้ Put Get Contains สำหรับ settings store แคชเล็ก และพจนานุกรมความยาวคงที่งานฝังตัว
    KV[Generic_KV_Store] --> K[Key_Type]
    KV --> V[Value_Type]
    KV --> EQ[ฟังก์ชันเทียบคีย์]
    KV --> M[Max_Entries]

    KV --> Ops[Put / Get / Contains]
    Ops --> Use1[settings store]
    Ops --> Use2[แคชขนาดเล็ก]
    Ops --> Use3[พจนานุกรมความยาวคงที่งานฝังตัว]

sequenceDiagram
    accTitle: ลำดับ Put ของ KV store
    accDescr: ฝั่งที่เรียก Put แล้วสโตร์หาดัชนีคีย์ ถ้ามีอยู่แล้วเขียนทับค่า ถ้าเป็นคีย์ใหม่หาช่องว่างแล้วบันทึก Keys Values Used จากนั้น Get คืนค่าที่ Pos
    participant App as ฝั่งที่เรียก
    participant Store as อินสแตนซ์ Generic_KV_Store
    participant Data as Keys/Values/Used

    App->>Store: Put(Key, Value)
    Store->>Data: Find_Index(Key)
    alt มีคีย์อยู่แล้ว
        Store->>Data: Values(Pos) := Value
    else คีย์ใหม่
        Store->>Data: Find_Free
        Store->>Data: Keys(Pos) := Key
        Store->>Data: Values(Pos) := Value
        Store->>Data: Used(Pos) := True
    end
    App->>Store: Get(Key)
    Store->>Data: Find_Index(Key)
    Data-->>Store: Pos
    Store-->>App: Values(Pos)

flowchart LR
    accTitle: สแตกถูกส่งต่อเข้า logger
    accDescr: Generic_Stack ถูก instantiate เป็น Int_Stack แล้วส่งต่อเข้า Generic_Stack_Logger จนได้ Int_Stack_Logger_Instance
    GS[Generic_Stack] --> IS[Int_Stack]
    IS --> Logger[Generic_Stack_Logger]
    Logger --> Logged[Int_Stack_Logger_Instance]

flowchart TB
    accTitle: ประกอบ Generic_Stack กับ Generic_Stack_Logger
    accDescr: ขั้นที่ 1 สร้าง Int_Stack จาก Generic_Stack ขั้นที่ 2 ส่ง Int_Stack เข้า Generic_Stack_Logger เพื่อได้ Print_Size
    subgraph Layer1[ขั้นที่ 1]
        T1[Generic_Stack] --> I1[Int_Stack]
    end

    subgraph Layer2[ขั้นที่ 2]
        T2[Generic_Stack_Logger] --> I2[Int_Stack_Logger]
    end

    I1 --> T2
    I2 --> API[Print_Size]

flowchart TB
    accTitle: Contract model ของ generic ใน Ada
    accDescr: Formal part เป็นสัญญา body ถูกตรวจชนิดภายในสัญญานั้น และตอน instantiate จะตรวจว่า actual parameter ทำตามสัญญา แล้วได้ package หรือ subprogram ปกติ
    Spec[generic formal part<br/>สัญญา] --> Body[generic body<br/>อิมพลีเมนต์ภายในสัญญา]
    Body --> Check1[ตรวจชนิดด้วยตัว body เอง]
    Spec --> Inst[instantiation]
    Actual[actual parameters<br/>ชนิดจริง ฟังก์ชันจริง ค่าจริง] --> Inst
    Inst --> Check2[ตรวจว่า actual parameter ทำตามสัญญาหรือไม่]
    Check2 --> Instance[package / subprogram ปกติ]

flowchart LR
    accTitle: Ada กับ C++ template ต่างกันตรงไหน
    accDescr: Ada เขียนสัญญาใน formal part แล้วตรวจ body ภายในสัญญา ก่อนตรวจ actual ตอน instantiate ส่วน C++ template ตามประวัติ concretize ข้อกำหนดตอน instantiate และระบุข้อจำกัดด้วย concepts ได้
    subgraph Ada[Ada]
        A1[เขียนสัญญาใน formal part] --> A2[ตรวจ body ภายในสัญญา]
        A2 --> A3[ตรวจ actual ตอน instantiation]
    end

    subgraph CPP[C++ templates]
        C1[เขียน template body] --> C2[ตอน instantiate ข้อกำหนดถูกทำให้เป็นรูปธรรม]
        C2 --> C3[ระบุข้อจำกัดด้วย concepts ได้]
    end

flowchart TB
    accTitle: จะทำให้ส่วนไหนเป็น generic
    accDescr: แยกกรณีที่ต่างกันแค่ชนิด ขนาดหรือเกณฑ์ พฤติกรรมเปรียบเทียบ หรือสถานะภายใน API เพื่อเลือก type parameter value parameter formal subprogram หรือ generic package
    Start[มีตรรกะที่อยากนำกลับมาใช้ใหม่] --> Q1{ต่างกันแค่ชนิด?}
    Q1 -->|Yes| GType[พิจารณา type parameter]
    Q1 -->|No| Q2{ขนาดหรือเกณฑ์ก็ต่าง?}
    Q2 -->|Yes| GObject[เพิ่ม value parameter]
    Q2 -->|No| Q3{พฤติกรรมเปรียบเทียบหรือตัดสินต่าง?}
    Q3 -->|Yes| GSubp[เพิ่ม formal subprogram]
    Q3 -->|No| Q4{อยากรวมสถานะภายในหรือ API?}
    Q4 -->|Yes| GPackage[generic package]
    Q4 -->|No| Normal[subprogram ปกติก็พอ]

flowchart LR
    accTitle: แยก spec กับ body ของ generic package
    accDescr: Formal part เป็นสัญญาของชนิด ค่า และฟังก์ชัน ไปเลี้ยงทั้ง spec ที่ผู้ใช้เห็น และ body ที่ซ่อนจากผู้ใช้
    Spec[package spec<br/>API สาธารณะ] --> User[ฝั่งผู้ใช้]
    Body[package body<br/>อิมพลีเมนต์ภายใน] -.ซ่อน.-> User
    Formal[generic formal part<br/>สัญญาของชนิด ค่า ฟังก์ชัน] --> Spec
    Formal --> Body

flowchart LR
    accTitle: ต้องใส่ฟังก์ชันเปรียบเทียบในสัญญา
    accDescr: ถ้า body ต้องการเปรียบเทียบต้องเขียนฟังก์ชันเปรียบเทียบใน formal part เพื่อตรวจตอน instantiate ถ้ามีแค่ private จะคอมไพล์ body ไม่ผ่าน
    Need[อยากใช้การเปรียบเทียบใน body] --> Contract[เขียนฟังก์ชันเปรียบเทียบใน formal part]
    Contract --> OK[ยืนยันว่าเปรียบเทียบได้ตอน instantiate]
    Need --> NoContract[มีแค่ private]
    NoContract --> Error[คอมไพล์ generic body ไม่ผ่าน]

flowchart TB
    accTitle: exception ของแต่ละ instance เป็นคนละตัว
    accDescr: Stack_Overflow ที่ประกาศใน Generic_Stack กลายเป็น Int_Stack.Stack_Overflow และ Float_Stack.Stack_Overflow ซึ่งเป็นคนละ exception
    Generic[Generic_Stack<br/>ประกาศ Stack_Overflow] --> I[Int_Stack.Stack_Overflow]
    Generic --> F[Float_Stack.Stack_Overflow]
    I -.คนละตัว.-> F

flowchart LR
    accTitle: ขนาดโค้ดเมื่อมีหลาย instance
    accDescr: Generic body เดียว generate โค้ด Integer Float Long_Float และ My_Type ข้อดีคือเลี่ยงการตรวจชนิดตอนรัน ข้อเสียคือ instance เยอะแล้วขนาดโต
    Generic[generic body เดียว] --> I1[ฉบับ Integer]
    Generic --> I2[ฉบับ Float]
    Generic --> I3[ฉบับ Long_Float]
    Generic --> I4[ฉบับ My_Type]

    I1 --> Code[โค้ดที่ถูก generate]
    I2 --> Code
    I3 --> Code
    I4 --> Code

    Code --> Pros[เลี่ยงการตรวจชนิดตอนรันและการ boxing ได้ง่าย]
    Code --> Cons[ถ้า instance เยอะ ต้องระวังขนาดที่โต]

flowchart LR
    accTitle: Generic_Min ต้องการฟังก์ชันเปรียบเทียบ
    accDescr: ชนิด Element ต้องมีฟังก์ชันเปรียบเทียบ จึงให้ Generic_Min คืนค่าที่เล็กกว่าได้
    T[Element] --> C[ต้องการฟังก์ชันเปรียบเทียบ]
    C --> M[Generic_Min]
    M --> R[คืนตัวที่เล็กกว่า]

flowchart TB
    accTitle: ฉีด Put เพื่อสลับช่องทางส่งออก
    accDescr: Generic_Print_Twice รับ Put เป็น formal subprogram แล้วชี้ไปคอนโซล log หรือบัฟเฟอร์ทดสอบได้
    Print[Generic_Print_Twice] --> Put[รับ Put เป็น formal subprogram]
    Put --> Console[ส่งออกคอนโซล]
    Put --> Log[ส่งออกเป็น log]
    Put --> Test[บัฟเฟอร์สำหรับทดสอบ]

flowchart LR
    accTitle: ไม่ตรึงชนิดดัชนีของอาร์เรย์
    accDescr: Index ที่เป็น discrete ใช้ได้ทั้งช่วง Positive enumeration ชื่อ Day หรือ State และชนิดจำนวนเต็มที่กำหนดเอง
    Index[Index is discrete] --> Positive[Positive range]
    Index --> Day[enumeration Day]
    Index --> State[enumeration State]
    Index --> Slot[ชนิดจำนวนเต็มที่กำหนดเอง]

flowchart TB
    accTitle: เช็กลิสต์ออกแบบ generic
    accDescr: ตรวจว่า formal parameter น้อยที่สุด ปฏิบัติการที่ต้องใช้ถูกเขียนใน formal part หมวดชนิดเหมาะสม instantiate อ่านง่าย และรับได้ทั้งสถานะ exception และขนาดโค้ด
    C[เช็คการออกแบบ generic] --> C1[formal parameter น้อยที่สุดหรือยัง]
    C --> C2[เขียนปฏิบัติการที่ต้องใช้ใน formal part แล้วหรือยัง]
    C --> C3[หมวดอย่าง private / range / digits เหมาะหรือยัง]
    C --> C4[instantiate อ่านง่ายด้วย named association ได้หรือยัง]
    C --> C5[คิดถึงสถานะและ exception ต่อ instance หรือยัง]
    C --> C6[รับการโตของขนาดโค้ดได้หรือยัง]
    C --> C7[มี instance สำหรับทดสอบหรือยัง]

flowchart TB
    accTitle: โครงไฟล์ตัวอย่างทั้งชุด
    accDescr: ราก ada-generic-programming มี src/generics สำหรับ spec กับ body และ src/demos สำหรับโปรแกรมสาธิตแต่ละหัวข้อ
    Root[ada-generic-programming] --> Src[src]
    Src --> G[generics]
    Src --> D[demos]

    G --> SwapSpec[generic_swap.ads]
    G --> SwapBody[generic_swap.adb]
    G --> StackSpec[generic_stack.ads]
    G --> StackBody[generic_stack.adb]
    G --> SortSpec[generic_insertion_sort.ads]
    G --> SortBody[generic_insertion_sort.adb]
    G --> StatsSpec[generic_statistics.ads]
    G --> StatsBody[generic_statistics.adb]
    G --> CountSpec[generic_count_if.ads]
    G --> CountBody[generic_count_if.adb]
    G --> KVSpec[generic_kv_store.ads]
    G --> KVBody[generic_kv_store.adb]

    D --> SwapDemo[swap_demo.adb]
    D --> StackDemo[stack_demo.adb]
    D --> SortDemo[sort_demo.adb]
    D --> StatsDemo[statistics_demo.adb]
    D --> CountDemo[count_if_demo.adb]
    D --> KVDemo[kv_demo.adb]

flowchart LR
    accTitle: จากสัญญาถึงการนำกลับมาใช้ใหม่
    accDescr: เขียนสัญญา แล้วเขียน generic body ส่งชนิด ค่า ฟังก์ชันเพื่อ instantiate ใช้แบบ type-safe แล้วนำกลับมาใช้ใหม่โดยไม่คัดลอก
    Contract[เขียนสัญญา] --> Generic[เขียน generic body]
    Generic --> Instance[ส่งชนิด ค่า ฟังก์ชันแล้ว instantiate]
    Instance --> Safe[ใช้แบบ type-safe]
    Safe --> Reuse[นำกลับมาใช้ใหม่โดยไม่คัดลอก]