Βασικές γνώσεις (Τμήματα) στη Μ2000

Ανανενεώθηκε  με νέα στοιχεία βάσει της έκδοσης 10.

Σημ 1.' Μπορούμε να γράφουμε σημειώσεις με την Σημ (REM)
\\ και χωρίς αυτήν με το \ ή και το '  στη έκδοση 10 και αυτό // είναι σημείωση
' και αυτή είναι σημείωση
Σημ { Σημείωση με πολλαπλές γιραμμές
      Σημ 1.1 για να εκτελέσουμε αυτό το παράδειγμα:
      τρέχουμε το m2000.exe
      γράφουμε   σ α   (ανοίγει ο διορθωτής για το τμήμα α)
      κάνουμε επικόλληση και πατάμε Esc
      γράφουμε το όνομα του τμήματος:  α (και πατάμε Enter)
      τόσο απλά.
      Με βελάκια πάνω-κάτω βλέπουμε τις παλαιότερες εντολες.
      Σώνουμε με Σώσε ενα_ονομα
      Φορτώνουμε με Φόρτωσε ενα_ονομα
      Βλέπουμε τι τμήματα έχουμε με Τμήματα  και Τμήματα ?
      Για συναρτήσεις γενικές γράφουμε Σ α( ή Σ α$( ή Σα%(
      (πρέπει να δηλώνουμε τι επιστρέφει αριθμό ή γράμματα
      Μπορούν να επιστρέφουν πίνακες και αντικείμενα, αλλά αυτό
      δεν φαίνεται από το όνομα αλλά από το πρόγραμμα!
      Γράψε: Βοήθεια Όλα και κάνε κλικ σε κάτι απ' όλα!
}
Σημ 2. ' Εδώ θα δούμε την έννοια του σκοπού μιας μεταβλητής
// εδώ σε πίνακα και σε τμήμα.
// Τα τμήματα μοιάζουν με τις διαδικασίες σε άλλες γλώσσες
// Μπορούμε να δουλεύουμε μόνο με τοπικά τμήματα
// και τμήματα σε τμήματα, καθώς και σε ζήτηση να φορτώνουμε
// με αυτήν την έννοια μπορούμε κάθε τμήμα να το βλέπουμε ως
// ένα πρόγραμμα. Η είσοδος και έξοδος μπορεί να είναι κοινή
\\ και αυτό γιατί η Μ2000 έχει ένα σωρό Τιμών που μέσω αυτού
\\ περνάει ενώνει τα τμήματα που καλεί με δεδομένα, και σε αυτό
\\ μπορούν να επιστρέψουν τιμές.
\\ Τα τμήματα δεν έχουν αναδρομή με την απευθείας κλήση
\\ Έχουν αν τα καλέσουμε με την Κάλεσε. Η διαφορά υπάρχει στο
\\ τρόπο που ονομάζεται εσωτερικά ένα τμήμα, και έχει επίπτωση
\\ σε αυτό που λέμε χώρο ονομάτων Δες παρακάτω.

Σημ 3. 'Μπορούμε να φτιάχνουμε γενικούς πίνακες με μια τιμή
θεσε πίνακας α(10,5)=100

Σημ 3.1.' Ή χωρίς τιμή
Γενικό β(10,10), δ(20,20), κ()
Πίνακας β(5,5) =20 \\ εδώ σκιάσαμε τον γενικό με ένα τοπικό
κ()=β() \\ αλλά εδώ βγάλαμε ένα αντίγραφο και τον δώσαμε στον γενικό
Τύπωσε β(3,3) \\ τοπικό

Σημ 4. Τεκμηρίωση: καλούμε το τμήμα άλφα και βλέπουμε αποτελέσματα
τμήμα γενικό άλφα { \\ στον ορισμό συνάρτησης βάζουμε συνάρτηση γενική
      τυπωσε 123, α(1,1), β(3,3), κ(3,3)
}

άλφα    \\ καλούμε την άλφα

Σημ 5. Τώρα θα καλέσουμε την άλφα από ένα τοπικό τμήμα βήτα

Τμήμα βήτα {
      διάβασε οδηγία$
      αν οδηγία$="οκ" τότε {
            άλφα
      } αλλιώς.αν οδηγία$="" τότε κάλεσε άλφα \\ άλλος τρόπος κλήσης
}

βήτα "οκ"
βήτα ""

Σημ 6. Τα τμήματα διαβάζουν τον σωρό τιμών

βάλε "οκ"
βήτα   \\ τώρα το "οκ" το βρήσκει στον σωρό
βάλε ""
κάλεσε βήτα

Σημ 7. Μπορούμε να περνάμε τιμές με αναφορά

Τμήμα δέλτα {
      Διάβασε &κάτι
      κάτι+=100
}
γενικό Άλφα
τοπική βήτα \\ εξ ορισμού είναι όλα τοπικά στο τμήμα   - δεν υπάρχει εντολή τοπικό!
Άλφα<=40 \\ τα γενικά θέλουν <= στην αντικατάσταση τιμής, αλλιώς θα φτιαχτεί τοπική
                  \\ Οι πίνακες δεν χρειάζονται το <= για αντικατάσταση σε γενικό
Στη Άλφα=50
                  \\ η Στη (LET) δουλεύει αλλιώς οπότε δεν φτιάχνει τοπική αν υπάρχει γενική
Άλφα+=20
Άλφα++ \\ =71
δέλτα &Άλφα
Τύπωσε Άλφα \\  171
δέλτα &βήτα
Τύπωσε βήτα

\\ Περί Τμημάτων (βασικά θέματα):
\\  Τα τμήματα διαφέρουν από τις Διαδικασίες άλλων γλωσσών γιατί:
\\  1. Μπορούν να επιστρέφουν τιμές εκτός με αναφορά και σε σωρό
\\  2. Βλέπουν μόνο τις δικές τους μεταβλητές και εκείνες του γενικού σκοπού.
\\  3. Μπορούν να δημιουργούν άλλα τμήματα ή να τα φορτώνουν
\\  4. Μπορούν να δημιουργούν σκιάζοντας γενικές μεταβλητές
\\ 5. Δεν έχουν αναδρομή εκτός και αν κληθούν ως συναρτήσεις (προχωρημένο θέμα).
\\ 6. Τα τμήματα μοιράζονται τον ίδιο σωρό αν είναι στην ίδια σειρά κλήσης
\\ 7. Τα τμήματα που ορίζουμε με τη συγγραφή (π.χ. σ Α) είναι γενικού σκοπού.

\\Περί σειράς κλήσης
\\ Αν το Α καλέσει το Β και το Β το Γ τότε λέμε ότι το Γ είναι σε σειρά κλήσης με το Α
\\ Επειδή η Μ2000 έχει νήματα...ενδέχεται ένα νήμα στη Γ να καλέσει την Α
\\ Αυτό το νήμα ξεκινάει νέα σειρά κλήσης. Η Α που κάλεσε έχει απλά το ίδιο πρόγραμμα.
\\ Αυτό που τρέχει ως Α στο νήμα του Γ και οι μεταβλητές του....
\\ .......(τα ονόματά του) είναι σε άλλο "χώρο ονομάτων", και επιπλέον έχουν άλλο σωρό.
\\ Εκτός από τα νήματα αυτό συμβαίνει και με τις συναρτήσεις που φτιάχνουμε.
\\ Κάθε δική μας συναρτηση όταν τρέχει ξεκινάει την δική της σειρά κλήσης με δικό της σωρό.
\\ Ακόμα και αν καλέσει τον εαυτό της, κάθε κλήση θα είναι μια νέα σειρά κλήσης, νέος σωρός.
            Συνάρτηση Άλφα {
                  διάβασε Α
                  =Α+1
            }
            Τύπωσε Άλφα(Άλφα(Άλφα(1))) \\ κάθε διάβασε στην Άλφα γίνεται σε νέο σωρό.
\\                                  4
\\ μπορούμε να φτιάχνουμε και συναρτήσεις σε μια γραμμή, αλλά θα δώσουμε τις παραμέτρους
\\ αυτή είναι μακροεντολή γιατί φτιάχνει ουσιαστικά μια Συνάρτηση βήτα {Διάβασε Χ : =Χ+1}
\\ επιπλέον αυτός ο τρόπος της μια γραμμής (από το DEF FN της παλιάς Basic) δεν παίρνει σήμα Γενική
\\ def beta(x)=x+1   \\ από την παλιά Basic (χωρίς το FN, η παλιά Basic το είχε απλά πρόσθετο στο όνομα)
κάνε βήτα(Χ)=Χ+1
Τύπωσε βήτα(2)

\\ Οι συναρτήσεις μπορούν να περαστούν με αναφορά (όμως θα είναι απλά πέρασμα ο κώδικας, όχι οι μεταβλητές)

// Λάμδα Συναρτήσεις Πολίτες πρώτης τάξεως
Λαμδα1=Λάμδα (χ)-> {
      // η χ θα γίνει κλείσιμο στην επιστρεφόμενη λάμδα
      =Λάμδα χ (ψ) -> {
            =χ*ψ
      }
}
Γενική Λ=Λάμδα1(5)
Τύπωσε Λ(10),Λ(20), Λ(50)
// 50   100   250

// Τα Γεγονότα είναι λίστες συνρτήσεων.
// Θα περάσουμε το αντικείμενο ΑκόμαΈνα σε ένα τμήμα
// και από εκεί θα κληθεί το γεγονός
// εδώ δουλεύουμε με "τοπικές Γενικές"
// Η Σούμα θα σβηστεί στο πέρας εκτέλεσης του προγράμματος (του τμήματος)
// Αν υπάρχει ήδη μια γενική Σούμα, θα σκιαστεί η παλιά.

Γενική Σούμα=20
Συνάρτηση ΓιαΓεγονός(χ) {
      // εδώ οι συναρτήσεις καλούνται σαν τμήματα (με δικό τους όνομα χώρου)
      Σούμα+=χ
      Τύπωσε Λ(Σούμα), Λ(Σούμα*2), Λ(Σούμα*2.5)
      
}
Γεγονός ΑκόμαΈνα {
      Διάβασε κ
}
Γεγονός ΑκόμαΈνα Νέο ΓιαΓεγονός(), ΓιαΓεγονός()

Τμήμα έψιλον {
       \\ η διάβασε ξεχωρίζει αν έχουμε αναφορά πίνακα ή συνάρτησης
      Διάβασε &Οποιοδήποτε_Όνομα(), &ΚάτιΑλλο(), Εκείνο
      ? Οποιοδήποτε_Όνομα(ΚάτιΑλλο(1)) \\ το ? είναι Τύπωσε
      Κάλεσε Γεγονός Εκείνο, 20
}
πίνακας κλ(10)=20
\\ Το &κλ(1) είναι --ΛΑΘΟΣ--- δεν μπορούμε να το περάσουμε, αναφορές σε στοιχεία πίνακα δεν γίνονται
\\ ούτε αναφορές συνάρτησης με πέρασμα μεταβλητών έτσι &βήτα(1,2,4) ---ΛΑΘΟΣ---
έψιλον &βήτα(), &κλ(), ΑκόμαΈνα
\\              21
\\            200           400       500  (κλήση γεγονότος, multicast, μια κλήση με πολλούς αποδέκτες)
\\            300           600       750  (εδώ εκτελείται ο δεύτερος αποδέκτης, είναι η ίδια συνάρτηση)
Τύπωσε Σούμα
\\              60
Σημ 8. ' Επαναπρογραμματισμός Τμήματος
Αν Αληθής τότε
Τμήμα έψιλον (&Οποιοδήποτε_Όνομα(), &ΚάτιΑλλο()) {
      ? Οποιοδήποτε_Όνομα(ΚάτιΑλλο(1)), "Νέο" // το ? είναι Τύπωσε
}
τέλος αν
έψιλον &βήτα(), &κλ()
\\              21Νέο
Στατική("οκ")

\\ Περί Σκοπού:
\\  Αν  τα παρακάτω έχουν οριστεί γενικού σκοπού φαίνονται παντού
\\  Μεταβλητές, Πίνακες, Τμήματα, Συναρτήσεις, Κλάσεις
\\ (οι κλάσεις στην Μ2000 είναι συναρτήσεις που κατασκευάζουν αντικείμενα)
\\ Βασικοί Κανόνες:

\\*** Οτιδήποτε τοπικό με ίδιο όνομα κρύβει το αντίστοιχο γενικό****
\\ Αν ορίζουμε γενικές μεταβλητές ή πίνακες με την θέσε τότε κάνουμε αντικατάσταση
\\ Αν ορίζουμε με την γενικό (ή γενική) τότε δημιουργούμε νέα μεταβλητή/πίνακα
\\  που σκιάζει το προηγούμενο. Η σκίαση φεύγει αν η τοπική βγει εκτός σκοπού, σβηστεί.

\\ ***Οτιδήποτε ορίζεται εντός τμήματος, ακόμα και γενικό, θα σβηστεί στο πέρας**
\\ Ο σωρός τιμών δεν έχει όνομα! Έτσι δεν εμπίπτει στο κανόνα.
\\ μπορούμε να φτιάξουμε ένα πίνακα σε ένα τμήμα και να αφήσουμε ένα αντίγραφο στο σωρό.
\\ όμως ο αρχικός θα χαθεί! Θα μείνει το αντίγραφο. Λογικά λοιπόν μπορούμε να φτιάξουμε
\\ κάτι και να εξάγουμε. Άλλο σημαίνει φτιάχνω και άλλο ορίζω!

Κλάση ΚάτιΜεΓεγονός {
      Γεγονός "Δείξε"
      Τμήμα ΚάνεΚάτι {
            Κάλεσε Γεγονός "Δείξε", "Αυτό"
      }
}

Ομάδα ΜεΓεγονότα Μ=ΚάτιΜεΓεγονός()
ΜΜ=2000
// στις συναρτήσεις εξυπηρέτησης γεγονότων (δεν επιστρέφουν τιμές, καλούνται σαν ρουτίνες)
Συνάρτηση Μ_Δείξε {
      // θα μπορούσε να γίνε σε μια γραμμή:
      Σημ 9: Τύπωσε Γράμμα$
      Διάβασε Νέο α$
      Τύπωσε α$, ΜΜ
      ΜΜ++
}
Μ.ΚάνεΚάτι
Μ.ΚάνεΚάτι

Βάλε 100
Συνάρτηση ΚλήσηΠροςΤαΠίσω {
      // Ουσιαστικά το μέρος τους κώδικα εκτελείται σαν να είναι στο τμήμα
      Διάβασε Νέο &Αλλο
      Μ.ΚάνεΚάτι
      Μ.ΚάνεΚάτι
      Αλλο++
      Σωρός // εμφανίζεται το 100 // την άλλη φορά το 500
}
Κάλεσε Τοπικά ΚλήσηΠροςΤαΠίσω(&Σούμα)
Τύπωσε Σούμα, Αριθμός=100
//          61 Αληθές

Τμήμα ΚάλεσέΜε (&α(), &β()) {
      ΚάτιΆλλο=100
      Βάλε 500 ' θα το εμφανίσει η α()  στη Σωρός
      Κάλεσε α(&ΚάτιΑλλο)
      Τύπωσε ΚάτιΆλλο, β()
      // 101, 6100
}
// η οκν$ παίρνει μια έκφραση ή μια αναφορά σε συνάρτηση και τις κάνει συναρτήσεις
// που εκτελούνται στο όνομα χώρου που εκτελέσαμε την οκν$()
// η Ένδειξη είναι τοπική, και θα πάρει την τιμή της Σούμα
Ένδειξη=Σούμα
οκ$=οκν$(Ένδειξη*100)
ΚάλεσέΜε Οκν$(&ΚλήσηΠροςΤαΠίσω()), οκ$ 'η Οκν$()  (οκνηρή αποτίμηση) μετατρέπει την συνάρτηση
Τύπωσε Ένδειξη, Αριθμός=500 \\ η αριθμός σηκώνει το 500 από το σωρό
//          61 Αληθές
Ένδειξη++
Τύπωσε Συνάρτηση(οκ$)
//       6200

// αυτού του είδους οι  κλήσεις γίνονται στους εξυπηρετητές γεγονότων

// Στην έκδοση 10 υπάρχουν Ρουτίνες και Συναρτήσεις που δεν αλλάζουν κώδικα
// Γράφονται στο τέλος. Τις ρουτίνες τις καλούμε με παρενθέσεις Στατική("αλφα")
// Τις συναρτήσεις αυτού του τύπου τις καλούμε με @ΈναΌνομα(). Δεν παιρνάνε με αναφορά, όπως οι άλλοι τύποι συναρτήσεων!
Ρουτίνα Στατική(α$)
      Τοπική ι
      // η ρουτίνα βλέπει ότι έχει το τμήμα
      // οι α$ και ι είναι τοπικές στη ρουτίνα
      \\ (σκιάζουν άλλες με ίδιο όνομα αν ήδη υπάρχουν)
      Για ι=1 εως 3: Τύπωσε α$, κλ(ι), @ΈναΌνομα(ι): Επόμενο
Τέλος Ρουτίνας
Συνάρτηση ΈναΌνομα(κ)
      =κ**3
Τέλος Συνάρτησης