Generic programming ב-Ada — חוזה בטיפוסים ו-reuse ב-zero cost

flowchart LR
    accTitle: שלוש דרכים ל-reuse בקוד עם טיפוסים סטטיים
    accDescr: copy-paste נוטה לתיקונים חסרים, void או cast שוברים type safety, ו-generics של Ada נותנים בדיקה בקומפילציה בלי dispatch נוסף בזמן ריצה.
    A["עיבוד שרוצים לעשות לו reuse"] --> B{"איך עושים reuse?"}
    B --> C["copy-paste"]
    B --> D["void* / Object / cast"]
    B --> E["generics של Ada"]

    C --> C1["קל לפספס תיקונים"]
    D --> D1["שגיאות runtime ושבירת טיפוסים"]
    E --> E1["type-safe"]
    E --> E2["בדיקה בזמן קומפילציה"]
    E --> E3["בלי dispatch נוסף בזמן ריצה"]

flowchart LR
    accTitle: knowledge map: generic programming ב-Ada
    accDescr: תרשים שמראה ש-generic subprogram ו-generic package נשענים על חוזה (contract model) של formal parameters מסוג טיפוס, ערך, subprogram ו-package, שהחוזה הזה נבדק ב-instantiation עם new, ואת ההבדל מבעיית השגיאה שמתגלה רק ב-instantiation ש-templates של C++ נשאו היסטורית.
    ada_generics["Ada generics"]
    ada_generic_contract_model["contract model של Ada generics"]
    ada["Ada"]
    ada_generic_subprogram["generic subprogram"]
    ada_generic_package["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["שגיאת template שמתגלה רק ב-instantiation"]
    cpp_templates["C++ templates"]
    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
    Design Ideas
      Contract Model
      Static Checking
      Zero-Cost Abstraction
      Separate Specification and Body

flowchart TB
    accTitle: מבנה קבצי הדוגמאות במאמר
    accDescr: תחת ada-generic-programming נמצאים src/snippets עם קבצי ada ל-swap, stack, sort, statistics, filter ו-key-value store, וגם README.
    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 gnata, ומריצים את הקובץ הבינארי.
    participant Dev as מפתח
    participant Chop as gnatchop
    participant Build as gnatmake
    participant Exe as קובץ הרצה

    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 parameters, גוף, ואז instantiation עם new שנותן subprogram או package רגיל.
    G["הצהרת generic"] --> F["formal parameters"]
    F --> B["גוף ה-generic"]
    B --> I["instantiation עם new"]
    I --> U["שימוש כ-subprogram או package רגיל"]

    F --> F1["טיפוס"]
    F --> F2["ערך"]
    F --> F3["subprogram"]
    F --> F4["package"]

flowchart TB
    accTitle: instantiation של Generic_Swap לפי טיפוס
    accDescr: אותה תבנית Generic_Swap מקבלת Integer, Character או My_Record ויוצרת procedure נפרד לכל אחד.
    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 parameters
    accDescr: טיפוס, אובייקט או ערך, subprogram, ו-package, עם דוגמאות כמו private, digits box, Max_Size ו-with package.
    P[generic formal parameters] --> T["פרמטר טיפוס"]
    P --> O["אובייקט / פרמטר ערך"]
    P --> S["פרמטר subprogram"]
    P --> PKG["פרמטר package"]

    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: החלפת שני ערכים ב-Generic_Swap
    accDescr: לפני הקריאה A הוא 10 ו-B הוא 20; אחרי השמה דרך Temp, A הוא 20 ו-B הוא 10.
    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 ויוצר Int_Stack, Float_Stack ו-String_Stack עם אותן פעולות Push Pop Size.
    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: מצב נפרד לכל instance של Generic_Stack
    accDescr: Int_Stack ו-Float_Stack נוצרים מאותו Generic_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: מעברי מצב של stack
    accDescr: Empty, NonEmpty ו-Full מתחלפים ב-Push ו-Pop; Push מלא מוביל ל-Overflow ו-Pop ריק ל-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 מקבל Item_Type, Index, Item_Array ופונקציית השוואה, ואפשר סדר עולה, יורד, או סדר מותאם.
    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: אותו גוף מיון לסדר עולה וליורד
    accDescr: Sort_Asc עם השוואה רגילה נותן 3 12 47 99, ו-Sort_Desc עם Greater נותן 99 47 12 3.
    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: private, limited private, discrete, range, mod, digits, delta ו-access, עם פיצול ל-enumeration, integer, Float ו-Long_Float.
    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["integer"]
    Float --> F1[Float]
    Float --> F2[Long_Float]
    Float --> F3["טיפוס floating-point שהמשתמש הגדיר"]

flowchart LR
    accTitle: Generic_Statistics על כמה דיוקי floating-point
    accDescr: אותו package עם Real is digits box יוצר 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: עוברים על איברי המערך, מגדילים Count כש-Predicate מחזיר True, ומחזירים את Count.
    Arr["מערך"] --> Loop["עוברים על האיברים"]
    Loop --> P{"Predicate(Item)?"}
    P -->|True| Inc["מגדילים את Count"]
    P -->|False| Skip["לא עושים כלום"]
    Inc --> Next["לאיבר הבא"]
    Skip --> Next
    Next --> Result["מחזירים את Count"]

flowchart TB
    accTitle: שני instantiations של Generic_Count_If
    accDescr: אותם נתונים נספרים ב-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: ה-store מקבל Key_Type, Value_Type, פונקציית שוויון מפתח ו-Max_Entries, ומשמש כמאגר הגדרות, cache קטן, או מילון באורך קבוע ל-embedded.
    KV[Generic_KV_Store] --> K[Key_Type]
    KV --> V[Value_Type]
    KV --> EQ["פונקציית שוויון מפתח"]
    KV --> M[Max_Entries]

    KV --> Ops[Put / Get / Contains]
    Ops --> Use1["מאגר ערכי הגדרה"]
    Ops --> Use2["cache קטן"]
    Ops --> Use3["מילון באורך קבוע ל-embedded"]

sequenceDiagram
    accTitle: Put ו-Get ב-Generic_KV_Store
    accDescr: Put מחפש מפתח קיים או משבצת פנויה ומעדכן Keys Values Used; Get מחפש אינדקס ומחזיר את הערך.
    participant App as צד הקריאה
    participant Store as instance של 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: Generic_Stack נכנס ל-Generic_Stack_Logger
    accDescr: Int_Stack שנוצר מ-Generic_Stack מועבר ל-Generic_Stack_Logger ויוצר instance של לוגר.
    GS[Generic_Stack] --> IS[Int_Stack]
    IS --> Logger[Generic_Stack_Logger]
    Logger --> Logged[Int_Stack_Logger_Instance]

flowchart TB
    accTitle: שתי שכבות של instantiation
    accDescr: בשלב הראשון נוצר Int_Stack מ-Generic_Stack, ובשני Int_Stack_Logger מ-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 הוא החוזה, הגוף ממומש בגבולו ונבדק לבד, וב-instantiation בודקים שה-actual parameters מקיימים את החוזה.
    Spec["generic formal part<br/>החוזה"] --> Body["generic body<br/>מימוש בגבול החוזה"]
    Body --> Check1["בדיקת טיפוסים של הגוף לבד"]
    Spec --> Inst["instantiation"]
    Actual["actual parameters<br/>טיפוס, function וערך ממשיים"] --> Inst
    Inst --> Check2["בדיקה שה-actual parameters מקיימים את החוזה"]
    Check2 --> Instance["package או subprogram רגיל"]

flowchart LR
    accTitle: Ada מול templates של C++
    accDescr: ב-Ada כותבים חוזה ב-formal part ובודקים את הגוף לפני instantiation; ב-C++ הדרישות התגבשו היסטורית ב-instantiation, ועכשיו אפשר concepts.
    subgraph Ada[Ada]
        A1["כותבים חוזה ב-formal part"] --> A2["הגוף נבדק בגבול החוזה"]
        A2 --> A3["ב-instantiation בודקים את ה-actual"]
    end

    subgraph CPP[C++ templates]
        C1["כותבים template body"] --> C2["ב-instantiation מתממשות דרישות"]
        C2 --> C3["אפשר לציין מגבלות ב-concepts"]
    end

flowchart TB
    accTitle: עץ החלטה מה להפוך ל-generic
    accDescr: לפי מה שמשתנה בוחרים פרמטר טיפוס, פרמטר ערך, formal subprogram, generic package, או subprogram רגיל.
    Start["יש עיבוד שרוצים לעשות לו reuse"] --> Q1{"רק הטיפוס שונה?"}
    Q1 -->|Yes| GType["שוקלים פרמטר טיפוס"]
    Q1 -->|No| Q2{"גם גודל או סף שונים?"}
    Q2 -->|Yes| GObject["מוסיפים פרמטר ערך"]
    Q2 -->|No| Q3{"ה-behavior של השוואה או בדיקה שונה?"}
    Q3 -->|Yes| GSubp["מוסיפים formal subprogram"]
    Q3 -->|No| Q4{"רוצים לארוז מצב פנימי ו-API?"}
    Q4 -->|Yes| GPackage["generic package"]
    Q4 -->|No| Normal["מספיק subprogram רגיל"]

flowchart LR
    accTitle: פיצול spec, body ו-formal part
    accDescr: ה-formal part הוא חוזה הטיפוס הערך וה-function; ה-spec הוא API לקורא; ה-body מוסתר.
    Spec["package spec<br/>API ציבורי"] --> User["צד השימוש"]
    Body["package body<br/>מימוש פנימי"] -.מוסתר.-> User
    Formal["generic formal part<br/>חוזה של טיפוס, ערך ו-function"] --> Spec
    Formal --> Body

flowchart LR
    accTitle: השוואה דורשת חוזה ב-formal part
    accDescr: אם הגוף צריך השוואה כותבים function ב-formal part; עם private בלבד הקומפילציה של הגוף נכשלת.
    Need["רוצים השוואה בגוף"] --> Contract["כותבים פונקציית השוואה ב-formal part"]
    Contract --> OK["ב-instantiation בודקים שאפשר להשוות"]
    Need --> NoContract["רק private"]
    NoContract --> Error["שגיאת קומפילציה בגוף ה-generic"]

flowchart TB
    accTitle: exception נפרד לכל instance
    accDescr: Stack_Overflow של Int_Stack ושל Float_Stack שנוצרים מאותו Generic_Stack הם exceptions שונים.
    Generic["Generic_Stack<br/>הצהרת Stack_Overflow"] --> I[Int_Stack.Stack_Overflow]
    Generic --> F[Float_Stack.Stack_Overflow]
    I -.exception אחר.-> F

flowchart LR
    accTitle: כמה instantiations מגדילים קוד
    accDescr: גוף generic אחד יוצר גרסאות Integer Float Long_Float ו-My_Type; נמנעים מבדיקת טיפוס בזמן ריצה אבל הקוד גדל.
    Generic["גוף generic אחד"] --> I1["גרסת Integer"]
    Generic --> I2["גרסת Float"]
    Generic --> I3["גרסת Long_Float"]
    Generic --> I4["גרסת My_Type"]

    I1 --> Code["קוד שנוצר"]
    I2 --> Code
    I3 --> Code
    I4 --> Code

    Code --> Pros["קל להימנע מבדיקת טיפוס ומ-boxing בזמן ריצה"]
    Code --> Cons["אם יש הרבה instances, לשים לב לגודל"]

flowchart LR
    accTitle: Generic_Min דורש פונקציית השוואה
    accDescr: Element מגיע עם פונקציית השוואה ל-Generic_Min, שמחזיר את הקטן יותר.
    T[Element] --> C["צריך פונקציית השוואה"]
    C --> M[Generic_Min]
    M --> R["מחזיר את הקטן יותר"]

flowchart TB
    accTitle: הזרקת Put ב-Generic_Print_Twice
    accDescr: Put מגיע כ-formal subprogram ואפשר לכוון אותו לקונסול, ללוג, או ל-buffer של טסט.
    Print[Generic_Print_Twice] --> Put["מקבלים Put כ-formal subprogram"]
    Put --> Console["פלט לקונסול"]
    Put --> Log["פלט ללוג"]
    Put --> Test["buffer לטסט"]

flowchart LR
    accTitle: Index כ-discrete type
    accDescr: אותו Index יכול להיות Positive, enumeration בשם Day או State, או טיפוס integer משלכם.
    Index[Index is discrete] --> Positive[Positive range]
    Index --> Day["enumeration בשם Day"]
    Index --> State["enumeration בשם State"]
    Index --> Slot["טיפוס integer משלכם"]

flowchart TB
    accTitle: checklist לעיצוב generic
    accDescr: בודקים מינימום formal parameters, פעולות ב-formal part, קטגוריה נכונה, named association, מצב ו-exception לכל instance, גודל קוד, ו-instance לטסט.
    C["בדיקת עיצוב generic"] --> C1["ה-formal parameters במינימום?"]
    C --> C2["הפעולות הדרושות כתובות ב-formal part?"]
    C --> C3["הקטגוריה private / range / digits מתאימה?"]
    C --> C4["אפשר instantiation קריא עם named association?"]
    C --> C5["מודעים למצב ול-exception לכל instance?"]
    C --> C6["אפשר לקבל גידול בגודל הקוד?"]
    C --> C7["יש instance לטסטים?"]

flowchart TB
    accTitle: פיצול דוגמאות ל-generics ול-demos
    accDescr: תחת src יושבים generics עם ads ו-adb לכל רכיב, ו-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: מחוזה עד reuse בלי העתקה
    accDescr: כותבים חוזה, מממשים generic, עושים instantiate עם טיפוס ערך ו-function, ומשתמשים באופן type-safe בלי להעתיק קוד.
    Contract["כותבים חוזה"] --> Generic["כותבים את גוף ה-generic"]
    Generic --> Instance["instantiation עם טיפוס, ערך ו-function"]
    Instance --> Safe["שימוש type-safe"]
    Safe --> Reuse["reuse בלי copy-paste"]