Πέμπτη, 19 Οκτωβρίου 2017

Πολλαπλή Εξαγωγή από Συνάρτηση


Σε αυτή την ανάρτηση έχω μερικά παραδείγματα για πολλαπλή εξαγωγή από συνάρτηση. Μπορούμε να δώσουμε την επιστροφή ως πίνακα, ως σωρό τιμών και ως κατάσταση.

Επιπλέον υπάρχει ένα παράδειγμα που δείχνει πως με μια λάμδα συνάρτηση μπορούμε να εμφανίζουμε έναν πίνακα να έχει βάση το 100 (να ξεκινάει το πρώτο στοιχείο από το 100).



\\ πολλαπλή εξαγωγή από συνάρτηση με τέσσερις τρόπους:
Συνάρτηση ΠολλαπλήΕξαγωγή (Α,Β,Γ,Δ) {
      =Δ,Γ,Β,Α \\ επιστροφή πίνακα μονοδιάστατου
}
Τύπωσε ΠολλαπλήΕξαγωγή(1,2,3,4) \\ άμεση εμφάνιση 4 3 2 1

Συνάρτηση ΠολλαπλήΕξαγωγή2 (Α,Β,Γ,Δ) {
      \\ το Δ μπαίνει στη κορυφή του σωρού, στη θέση 1
      Άδειασε  \\ τυχόν άλλα ορίσματα
      Βάλε Α,Β,Γ,Δ
      =[] \\ επιστροφή σωρού (ειδική στοίβα)
}

Συνάρτηση ΠολλαπλήΕξαγωγή2_1 {
      \\ και αυτό δουλεύει αλλά γυρνάει ότι έχει ο σωρός, όχι μόνο αριθμούς.
      =[] \\ επιστροφή σωρού (ειδική στοίβα)
}
Τύπωσε ΠολλαπλήΕξαγωγή2(1,2,3,4) \\ άμεση εμφάνιση 4 3 2 1
Τύπωσε ΠολλαπλήΕξαγωγή2_1(1,2,"οκ",4) \\ άμεση εμφάνιση 4 οκ 2 1

Συνάρτηση ΠολλαπλήΕξαγωγή3 (Α,Β,Γ,Δ) {
      \\ η κατάσταση ουρά, επιτρέπει διπλά κλειδιά,
      \\ και εξασφαλίζει ότι κάθε νέο θα μπει στο τέλος της.
      \\ Η επιτυχής αναζήτηση κλειδιού δείχνει παντα το τελευταίο εισάχθηκε
      \\ αλλά δεν επιτρέπει την εντολή Αφαίρεση,
      \\ αντί αυτού έχει την εντολή Πέτα (σε διαμόρφωση για το αντικείμενο)
      \\ η οποία περάει μόνο από το τέλος όσα κλειδιά θέλουμε.
      \\ μια κατάσταση μπορεί να έχει κλειδιά, ή κλειδιά και τιμές, ή και τα δύο
      \\ όταν δεν υπάρχει τιμή σε ένα κλειδί, τότε το κλειδί είναι τιμή
      \\ τα νούμερα των Α,Β,Γ,Δ γίνονται κλειδιά εδώ και τιμές
      Κατάσταση Ουρά Αλφα =Δ, Γ, Β, Α
      =Αλφα
}
Τύπωσε ΠολλαπλήΕξαγωγή3(1,2,3,4) \\ άμεση εμφάνιση 4 3 2 1

\\ όπου θέλουμε βάζουμε το Έξοδος
\\ για να παρακολοθούμε την εκτέλεση
Σημ 1: Έξοδος

\\ με χρήση δείκτη σε πίνακα
\\ η σειρά θα αλλάξει σε 4,3,20, 1
Ν1=ΠολλαπλήΕξαγωγή(1,20,3,4)
Τύπωσε Πίνακας(Ν1,2) \\ βάση 0, άρα το 2 είναι το 3ο στοιχείο
Σ1=ΠολλαπλήΕξαγωγή2(1,20,3,4)
Τύπωσε ΤιμήΣωρού(Σ1,3) \\ βάση 1 άρα το 3 είναι το 3ο στοιχείο
Κ1=ΠολλαπλήΕξαγωγή3(1,20,3,4)
\\ το ! χρησιμοποιείται για να δίνουμε τον αριθμό σειράς, αλλιώς δίνουμε το κλειδί.
Τύπωσε Κ1(2!) \\ βάση 0, άρα το 2 είναι το 3ο στοιχείο
\\ Μπορούμε να διαβάσουμε το κλειδί με το Εκφρ$(Κ1, 2), και να το επιστρέψουμε ως αριθμό.
Τύπωσε Τιμή(Εκφρ$(Κ1,2))
\\ Δουλεύει σε δυο βήματα, το πρώτο κάνει αναζήτηση, και το δεύτερο γυρνάει το ζητούμενο
\\ εδώ το κλειδί είναι το 20 και είναι και τιμή ταυτόχρονα.
Αν Υπάρχει(Κ1, 20) Τότε Τύπωσε Εκφρ(Κ1), Εκφρ$(Κ1)

\\ η εντολή Επιστροφή δουλεύει για αντικείμενα πίνακες, σωρούς και καταστάσεις.
\\ στους πίνακες το κλειδί είναι η θέση (υπολογίζεται η βάση αν είναι 0 ή 1) ως μονοδιάστατος πίνακας

Επιστροφή Κ1, 20:="Μόνο λέξη"
\\ δουλεύει και με τα Κ1() και Κ1$()
\\ αλλά το Κ1(20) δίνει 0 γιατί τώρα η τιμή είναι αλφαριθμητικό που δεν έχει αριθμό
Τύπωσε Κ1(20), Κ1$(20)
\\ Κλειδί μπορούμε να δώσουμε και με μεταβλητή:
Α=20
Επιστροφή Κ1, Α:="100"
\\ αυτόματα αναγνώρισε ότι το 100 είναι αριθμός οπότε δίνει και τον αριθμό και το αλφαριθμητικό:
Τύπωσε Κ1(20), Κ1$(20)
Λίστα
\\ Οι λάμδα συναρτήσεις μπορούν να έχουν κλεισίματα, μεταβλητές τοπικές σε αυτές,
\\ αλλά οι Καταστάσεις, οι Σωροί, είναι δείκτες, με συνέπεια να μπορούμε να τους πάρουμε
\\ και να κάνουμε αλλαγές. Ομοίως το ίδιο μπορούμε να κάνουμε με δείκτες σε πίνακες.
Συνάρτηση ΠολλαπλήΕξαγωγή4 {
      Αν κενό τότε Λάθος "Ο σωρός είναι άδειος"
      Α=Σωρός \\ άδειος
      Β=[] \\ αδειάζει τον τρέχον στο Β
      Β1=Κάθε(Β)
      Ενώ Β1 { Σωρός Α { Βάλε ΤιμήΣωρού(Β1)}}
   
      =λάμδα Α -> {
            Αν όχι κενό Τότε {
                  Διάβασε Που
                  =ΤιμήΣωρού(Α, Που)
            } Αλλιώς =Α
      }
}
Μ=ΠολλαπλήΕξαγωγή4(1,20,3,4)
Τύπωσε Μ() \ 4 3 20 1
Τύπωσε Μ(3)
\\ επειδή το Μ() γυρίζει δείκτη, μπορούμε να αλλάξουμε στοιχείο του σωρού
Επιστροφή Μ(), 3:=1000
\\ το οποίο θα φανεί με τη χρήση της λάμδα, ότι άλλαξε εντός της λάμδα:
Τύπωσε Μ(3)
Συνάρτηση ΠολλαπλήΕξαγωγή5 {
      Αν Μέγεθος.Σωρού<2 τότε Λάθος "Πρόβλημα στο σωρό"
      Διάβασε ΒάσηΠινακα%
      Πίνακας Βάση 0, Α(Μέγεθος.Σωρού)
      Για Χ=0 έως Μέγεθος.Σωρού-1 {
            Φέρε Μέγεθος.Σωρού
            Διάβασε Α(Χ)
      }
      =λάμδα Α(), ΒάσηΠινακα% -> {
            Αν όχι κενό Τότε {
                  Διάβασε Που%
                  =Α(Που%-ΒάσηΠίνακα%)
            } Αλλιώς =Α()
      }
}

\\ Πώς θα φτιάξουμε πίνακα με βάση διαφορετική το 0 ή το 1
\\ κανονικά μόνο 0 και 1 δέχεται η Μ2000
\\ επειδή εξωτερικά μια λάμδα συνάρτηση μοιάζει με πίνακας
\\ και αφού μπορούμε να κλείσουμε έναν πίνακα μέσα της,
\\ θα κάνουμε μια λάμδα να φαινεται σαν πίνακας!
\\ δίνουμε εδώ την βάση (100) και τέσσερα στοιχεία,
\\ που θα τα βάλουμε ανάποδα όπως στα προηγούμενα παραδείγματα!
\\ Μπορούμε να βάλουμε όσα θέλουμε αλλά τουλάχιστον ένα!
\\ έτσι θα πρέπει να βάλουμε την βάση και μετά ένα αριθμό.

Μ=ΠολλαπλήΕξαγωγή5(100, 1,20,3,4)
Τύπωσε Μ()
\\ η Μ() είναι μια λάμδα που φαίνεται ως πίνακας
\\ με βάση το 100
Τύπωσε Μ(102) \\ βάση 100 για τον πίνακα
Για Ι=100 εως 103 {
      Τύπωσε Μ(Ι)
}
Ν=Μ()
ΜΜ=Κάθε(Ν Τέλος Έως Αρχή)
Ενώ ΜΜ {
      Τύπωσε Πίνακας(ΜΜ),
}
ΜΜ=Κάθε(Ν,1, -1)
Τύπωσε
Ενώ ΜΜ {
      Τύπωσε Πίνακας(ΜΜ),
}
Τύπωσε
Δες {
      \\ αυτό δεν γίνεται γιατί η Μ() είναι συνάρτηση
      \\ δεν μπορεί να είναι σε αριστερή έκφραση σε εκχώρηση!
      Μ(102)=100
}
\\ μπορούμε να αλλάξουμε τιμή με χρήση του δείκτη
\\ αλλά εδώ δουλεύει με βάση το 0 άρα το 2 είναι το 3ο στοιχείο
Επιστροφή Ν, 2:=1234
Τύπωσε Μ()

\\θα δοκιμάσουμε να περάσουμε την λάμδα, σαν μεταβλητή, με αντιγραφή στο τμήμα δοκιμή1
Τμήμα δοκιμή1 {
      Διάβασε Τι
      Τύπωσε "Μέσα στη Δοκιμή"
      Τύπωσε Τι() \\ 4 3 1234 1
      Τυπωσε Τι(101) \\ 3
      Ν=Τι()
      \\ το Ν() είναι αναφορά του Ν, του δείκτη στο πίνακα
      \\ και ο σκοπός είναι να πάρουμε τις δυνατότητες που έχουν οι πίνακες με παρενθέσεις
      Ένωσε Ν στο Ν()
      \\ όπως το +=
      Ν(2)+=5000
      \\ στο Ν το Ν+=5000 αλλάζει όλα τα στοιχεία.
   
}
\\ το Μ θα περάσε με τιμή, αλλά ο δείκτης στο πίνακα παραμένει μέσα!
δοκιμή1 Μ
Τύπωσε Μ() \\ 4 3 6234 1



Για την ΠολλαπλήΕξαγωγή5:

Η εντολή Φέρε Μέγεθος.Σωρού, φέρνει το τελευταίο στοιχείο του σωρού στη πρώτη θέση, αμέσως μετά τον διαβάζουμε με την Διάβασε Α(Χ) και το μέγεθος μειώνεται κατά ένα. Αυτό θα γίνει τέσσερις φορές και θα στρώσουμε τον πίνακα, αδειάζοντας τον σωρό, ανάποδα (αλλά πάντα το άδειασμα γίνεται από την κορυφή, απλά εδώ μεταφέρουμε από τον πυθμένα, το τελευταίο στοιχείο, στο κορυφή, και μετά το τραβάμε, άρα είναι σαν να τραβάμε από το τέλος).



Τρίτη, 17 Οκτωβρίου 2017

Revision 41, Version (8.9)

Ελληνικά:
Αναθεώρηση 41, έκδοση 8.9.
Σε αυτήν την αναθεώρηση λύθηκε μερικώς ένα ζήτημα που προέκυψε από την χρήση της υπερκλάσης. Με την λύση αν προβούμε σε διπλό άνοιγμα της υπερκλάσης θα βγει λάθος. Αυτό συμβαίνει γιατί μια διαδικασία αντιγράφει τιμές τις υπερκλάσης για χρήση, και μετά τις επαναφέρει, οπότε αν γίνει "φωλιασμένα" θα έχουμε επαναφορά, και μετά νέα επαναφορά τιμών, άρα η πρώτη θα χαθεί. Αυτό φαίνεται στο τρίτο παράδειγμα, όπου δεν μπορεί να πιάσει το ζήτημα ο διερμηνευτής, όπως το πιάνει στη περίπτωση των πρώτων παραδειγμάτων. Εκεί λοιπόν το πιάνει γιατί γνωρίζει ότι πάει να ανοίξει τη υπερκλάση, από την υπερκλάση!
Η υπερκλάση στη Μ2000 είναι η κλάση σε άλλες γλώσσες. Αυτό το πρόβλημα σε άλλες γλώσσες λύνεται με την συνεχή χρήση του self (βλέπε Python). Δηλαδή εκεί δουλεύει αντίστροφα. Όλα τα αναγνωριστικά της κλάσης δουλεύουν για την κλάση, και πρέπει να χρησιμοποιεί κανείς το Self για την "παρουσία" (Instance) του αντικειμένου.

English:
A new revision for a solution when we open a superclass to access superclass members, and this happen when already is open.

Three examples show this situation .One solution is given by raise an error if we do double open, but as we see in third example there is a situation that this didn't work.

Just open m2000.exe (interpreter), write Edit A, press enter, copy first script, then press Esc to exit, then write Edit B and continue with the second, then repeat for the third in a module say C.
We can anyone by name: Write A and press enter
Use this: Save example1
and after: New  (or Start for a software reset)






you can use Clear and Flush (clear variables if any, and flush stack for values)

Load axemple1 
to reload modules.


Also these examples show how to migrate a Superclass in a lambda function to produce instances.
Also keep in mind that Group objects in M2000 are not referenced entities, are always values.  (internal there is a pointer for each object, only one, and this pointer never doubled)

\\ First Example
\\ return error
\\ We can't open Superclass in Superclass;
Function Super1 {
      SuperClass S {
            name$="Hello"
            Module Super {
                  For SuperClass {
                        Read .name$
                  }
            }
            Module PrintData {
                  For SuperClass {
                        Print .name$;" "; This.name$
                        .name$<=.name$+"."
                        Print .name$
                  }
            }
        
      }
      =Lambda S (n$) -> {
            make_it=S
            group make_it { name$=n$}
            =make_it
      }
}
CreateSuper1=Super1()
A=CreateSuper1("World")
Group a {
      \\ change an object module
      \\ which use SuperClass
      Module PrintData {
            For SuperClass {
                  .PrintData "??????"
                  .PrintData "!!!!!!!!"
            }
      }
}
A.PrintData


This is the second example:

\\ Second example
\\ Error of first example now removed
\\ There are two Modules, one as Super.PrintData (tha name can be anything)
\\ and another as PrintData. If we want to change PrintData now is possible to do,
\\ and we can call the original PrintData as the second part


Function Super1 {
      global temp$="Hello"
      Read ? temp$
      \\ we can pass im construction values
      \\ using global temporary values.
      SuperClass S {
            name$=temp$
            Module Super {
                  For SuperClass {
                        Read .name$
                  }
            }
            Module Super.PrintData (aname$){
                  \\ this part has local items and the Supetclass items
                  For SuperClass {
                        Print .name$;" ";aname$
                        .name$<=.name$+"."
                        Print .name$
                  }
            }
            Module PrintData {
                        \\ for using it as Virtual module
                        \\ we have to split it
                        \\ this part has the instance members
                        .Super.PrintData .name$
            }
        
      }
      =Lambda S (n$) -> {
            make_it=S
            group make_it { name$=n$}
            =make_it
      }
}
CreateSuper1=Super1()
CreateSuper2=Super1("Master")
A=CreateSuper1("World")
Z=A
Group a {
      \\ change an object module
      \\ which use SuperClass
      Module PrintData {
            .Super.PrintData "??????"
            .Super.PrintData "!!!!!!!!"
      }
}
A.PrintData
A=CreateSuper2("George")
A.PrintData
Z.PrintData
List


And this is the final example:

\\ Third Example
\\ Here we check if we can call SuperClass from different  objects
\\ As we can see, this can be happen
\\ The problem is that Interpreter can't find it
Function Super1 {
      Global What$="Hello"
      Read ? What$
      SuperClass S {
            name$=What$
            Function Super.Name$ {
                  For SuperClass {
                        =.name$
                  }
            }
            Module Third {
                  .PrintData
            }
            Module Second (&M) {
                 \\ For SuperClass work with Copies and at the exit, these copies copied back
                 For SuperClass {
                        Print .name$;" ";M.name$
                        Try {
                              .PrintData
                              \\ error
                        }
                        Try {
                              .Third
                              \\ error - try shadow Try
                        }
                        M.PrintData
                        \\ no error but changed .name$ now lost.
                        ? .name$
                  }
            }
            Module PrintData {
                   For SuperClass {
                        Print .name$;" ";This.name$
                        .name$<=.name$+"."
                        Print .name$
                  }
            }
        
      }
      =Lambda S (n$) -> {
            make_it=S
            group make_it { name$=n$}
            =make_it
      }
}
L1=Super1("Hello There")
N1=L1("George")
N1.PrintData
N2=L1("Bob")
N2.PrintData
\\ here is the problem
\\N1 take a reference of N2
\\ then open SuperClass, and before close it
\\ call N2.printdata which opens the same SuperClass
\\ We make a change in .name$
\\ And that change lost;
N1.Second &N2
Print N1.Super.Name$(), N2.Super.Name$()
Print valid(@N2 as N1) \\ -1 Same SuperClassess, and N1 members names exist in N2
\\ here we put fresh lambda functions
\\ old lambdas destroyed. But N1 and N2 have both a pointer to SuperClass
L1=Super1("Hello There")
L2=Super1("Hello There")
\\ and here we merge new groups, and passing new SuperClass, differnet to each one
N1=L1("George")
N1.PrintData
\\ here the last pointer to hold first SuperClass changed, so first Superclass destroyed
N2=L2("Bob")
N2.PrintData
\\ Here there is no problem
\\ because N1 Superclass is different from N2
\\ Although each Superclass are equal, for members and functionality, and state.
\\ They are real different objects.
N1.Second &N2
Print N1.Super.Name$(), N2.Super.Name$()
Print valid(@N2 as N1) \\ 0 Different Superclasses (no search for members names existance)
' at the exit of this module (name isn't provided here, choose one, then write Edit MyName and paste this code. Then press Esc and write MyName and press Enter to run it)


Δευτέρα, 16 Οκτωβρίου 2017

20 Things About M2000 (new)

This is a paper for 20 things about M2000, you have to Know.
https://drive.google.com/open?id=0BwSrrDW66vvvdzcyTjBoSktXYkU


Remove Page Numbers from PDF so we can copy code without problem.
Added Json Parser Library.

Αναθεώρηση 40 (έκδοση 8.9)

Σε αυτήν την αναθεώρηση βελτίωσα την συνάρτηση Εγκυρο(). Δούλευε μόνο με αριθμητικές παραστάσεις αλλά ήθελα μια λειτουργία που δεν θα εκτελούσε μια παράσταση, απλά θα επέσρεφε αληθές (-1) αν ένα αναγνωριστικό υπάρχει στη λίστα μεταβλητών και μπορεί να την δει το πρόγραμμα από το σημείο που τη ζητάμε.
Το παρακάτω παράδειγμα έχει επεξηγήσεις


Ομάδα Μετρητής {
Ιδιωτικό:
      μετρητής=1
Δημόσιο:
      Αξία {
            =.μετρητής
            .μετρητής++
      }
}
\\ λειτουργία ελέγχου λάθους σε παράσταση
Τύπωσε Έγκυρο(10/0) \\ 0 γιατί έχει λάθος
Τύπωσε Έγκυρο(10>500) \\ -1 γιατί δεν έχει λάθος
Τύπωσε Μετρητής, Μετρητής, Μετρητής
Τυπωσε Έγκυρο(Μετρητής) \\ δίνει -1 αλλά ο μετρητής άλλαξε
Τύπωσε Μετρητής, Μετρητής, Μετρητής
\\ λειτουργία ελέγχου ότι το αναγνωριστικό είναι θεατό ως μεταβλητή/πίνακας
Τυπωσε Έγκυρο(@Μετρητής) \\ δίνει -1 χωρίς να αλλάξει ο μετρητής
Τύπωσε Μετρητής, Μετρητής, Μετρητής

\\ τώρα ορίζουμε διάφορες μεταβλητές
σταθερή Μ=1000
Χ=10
Ζ$="αλφα"
Πίνακας Α(10)=1
Ν=(1,2,3,4,5)
Λ=Σωρός:=1,2,3,4,5
Ομάδα Αλφα { Χ=10, Υ=50, Α$="οκ"}
\\ όλα τα παρακάτω είναι έγκυρα
Τύπωσε Έγκυρο(@Χ), Έγκυρο(@Ζ$), Έγκυρο(@Α()), Έγκυρο(@Μ)
Τύπωσε Έγκυρο(@Ν), Έγκυρο(@Λ), Έγκυρο(@Αλφα.Χ), Έγκυρο(@Αλφα.Α$)

\\ Μπορούμε να δούμε το τύπο οποιουδήποτε με την Τυπος$()
\\ αλλά όχι το Α(), ενώ ναι το Α(0)
Τύπωσε Τυπος$(Ν), Τυπος$(Α(0)) \\ mArray  double
\\ Μπορούμε να φτιάξουμε μια συνάρτηση με ίδιο όνομα με έναν πίνακα:
Κάνε Α(Χ)=Χ**2
\\ με το @ λέμε στο διερμηνευτή ότι θέλουμε την συνάρτηση.
Τύπωσε Α(@10), Α(1) \\ 100   1
\\ Γενικά ο διερμηνευτής δίνει προτεραιότητα στους πίνακες.
\\ οπότε αν δώσουμε εδώ Α(100) επειδή υπάρχει πίνακας θα βγει λάθος!
\\ μπορούμε όμως να καλέσουμε την ρουτίνα με την εντολή Διαμέσου
Διαμέσου Α(100)
\\ Δηλαδή τώρα έχουμε τρια αναγνωριστικά Α() που ανήκουν σε διαφορετικές λίστες.

\ για τμήματα και συναρτήσεις χρησιμοποιούμε την Τμήμα()
Τύπωσε Τμήμα(Α()) \\ δίνει -1 γιατί υπάρχει συνάρτηση Α()

\\ Η τρίτη λειτουργία της Έγκυρο είναι με την προσθήκη της ως

Ομάδα Βήτα {
      Χ=10, Υ=50
}

Τύπωσε Έγκυρο(@ Αλφα ως Βήτα) \\ -1 γιατί η Αλφα έχει ότι η Βήτα (και παραπάνω)
Τύπωσε Έγκυρο(@ Βήτα ως Αλφα) \\ 0 γιατί η Αλφα έχει περισσότερα στοιχεία!

Τύπωσε Έγκυρο(@ Ν ως Α()) \\ δίνει 0 γιατί το Ν είναι δείκτης σε πίνακα, ενώ το Α()  είναι πίνακας!
Α=Α()
Τύπωσε Έγκυρο(@ Ν ως Α) \\ δίνει -1, και οι δύο είναι δείκτες σε πίνακες!
Στη Β()=Α \\ η Στη (LET) εκτελεί δυο εντολές: Βάλε Α : Διάβασε Β()
\\ η Β() έχει αντίγραφο των στοιχείων του Α, είναι άλλος πίνακας!
Τύπωσε Έγκυρο(@ Β() ως Α()) \\ -1 έγκυρο

\\ θα προσπαθήσουμε να το μπερδέψουμε!
\\ θα φτιάξουμε μια αναφορά του Ν ως πίνακας με παρενθέσεις:
Ένωσε Ν στο Ν() \\ είναι ίδιο με το Βάλε &Ν : Διάβασε &Ν()
Τύπωσε Έγκυρο(@Ν() ως Α()) \\ 0 δεν είναι
Τύπωσε Έγκυρο(@Ν() ως Α) \\ -1 είναι, αν και το Ν() φαίνεται απλός πίνακας είναι δείκτης σε πίνακα!
\\ όμως λειτουργεί με το  τρόπο που λειτουργούν οι κανονικοί πίνακες:
Τύπωσε Μήκος(Ν), Μήκος(Ν()), Μήκος(Α()) \\ 5   5  10
Τύπωσε Έγκυρο(@Ν() ως Α) \\ -1 είναι, αν και το Ν() φαίνεται απλός πίνακας είναι δείκτης σε πίνακα!
Ν=(10,20,30)
Τύπωσε Μήκος(Ν), Μήκος(Ν()), Μήκος(Α()) \\ 3   3  10
\\ όταν χρησιμοποιούμε πίνακα με παρενθέσεις αριστερά του ίσον παίρνουμε αντίγραφο πίνακα.
\\ η επιλογή του Ν() σαν πρόσθετο όνομα για το Ν έγινε για την διεπαφή.
\\ το Ν() έχει άλλη διεπαφή με τον διερμηνευτή και αυτό δεν το γνωρίζει το αντικείμενο, αλλά ο διερμηνευτής.
Ν()=Α()
Τύπωσε Μήκος(Ν), Μήκος(Ν()), Μήκος(Α()) \\ 10   10  10
Ν+=20 \\ οι δείκτες σε πίνακα έχουν τελεστές για όλα τα στοιχεία, με την μια!
Τύπωσε Ν(4), Α(4) \\ 21  4
ΝΝ=Ν \\ κρατάμε τον δείκτη
Ν=(1,2,3,4,5)
Τύπωσε Ν(4), Α(4) \\ 5  4
Ν=ΝΝ \\ παίρνουμε πίσω τον παλιό πίνακα
Τύπωσε Ν(4), Α(4) \\ 21  4
\\ η Τύπωσε μπορεί να τυπώνει όλα τα στοιχεία ενός αντικειμένου πίνακα (και κατάστασης και σωρού)
Τύπωσε Ν
Τύπωσε ΝΝ
Τύπωσε Ν()
Τύπωσε Α()
\\ το (1,2,3,4,5) δεν υπάρχει πια γιατί δεν υπάρχει κανείς δείκτης να το κρατήσει!

Ρουτίνα Α(Χ)
      Τύπωσε "Κλήση ρουτίνας "; Χ
Τέλος Ρουτίνας

Κυριακή, 15 Οκτωβρίου 2017

Αναθεώρηση 39 (έκδοση 8.9) bug removed

Σε αυτήν την αναθεώρηση βρήκα ένα Bug και το διόρθωσα το οποίο με λίγα λόγια δεν επέτρεπε να εκτελεστεί ένα ιδιωτικό τμήμα μιας ομάδας σε μια συνάρτηση! Το πρόβλημα ήταν η χρήση μια Like μέσα στη VB6 και ότι αυτό που κοίταζε είχε το [1] ή κάποιο άλλο αριθμό, και αυτό η Like το έβλεπε σαν ταμπλέτα για ένα χαρακτήρα το 1 εδώ και όχι τους τρεις χαρακτήρες [1].

Το πρόβλημα υπήρχε από την έκδοση 8.1 και μετά που μπήκαν τα ιδιωτικά μέλη στις ομάδες, και μόνο για τα τμήματα!

Στο παράδειγμα παρακάτω, το help1 δεν μπορούσε να τρέξει!

 function mm {
      group a {
      private:
                  module help1 {
                        Print "ok"
                  }
      public:
                  Function check {
                       .help1
                  }
            }
            =a.check()
     
}
a=mm()

Σάββατο, 14 Οκτωβρίου 2017

Υπερκλάση (Superclass) νέα δυνατότητα για την Μ2000.

Αναθεώρηση 38 (Έκδοση 8.9)
Μετά από ωραίες σκέψεις κατάφερα να υλοιποιήσω την δυνατότητα οι ομάδες μεταξύ τους να έχουν ένα δικό τους χώρο για κοινές μεταβλητές. Άλλοι θα το δουν ότι κληρονομούν ιδιότητες και μεθόδους, αλλά αυτό ίσχυε και πριν, επειδή τα βασικά ντικείμενα της Μ2000, οι ομάδες είναι αυτό που λέμε prototyped objects.
Οι ιδιότητες των αντικειμένων της Μ2000, λεγόμενων ομάδων, ως πρωτοτύπων είναι:
  • Μπορούν να δώσουν αντίγραφό τους και έτσι λειτουργούν ως πρωτότυπα. Αυτό που δίνουν είναι ένα αντίγραφο με την τωρινή κατάσταση. Αν το δίνουν σε μια ομάδα, τότε θα έχουμε συγχώνευση στο προορισμό. Όταν δίνουν αντίγραφο σε θέση πίνακα, κατάστασης, ή σε επιστρέφουν τιμή σε σωρό τιμών, τότε δεν έχουμε συγχώνευση, αλλά αντικατάσταση.
  •  Μπορούν να δημιουργούνται, με μέλη, στην πορεία. Η εντολή δημιουργίας, η Ομάδα Όνομα {] μπορεί να δοθεί και άλλες φορές. Αυτό σημαίνει ότι μπορούν να αλλάξουν ορισμούς σε τμήματα και συναρτήσεις.
  • Δεν μπορούμε άμεσα να διαγράψουμε μέλη. Υπάρχει τρόπος να ορίσουμε προσωρινά ένα όνομα ως αναφορά σε μια ομάδα (με όνομα) και να αυξήσουμε αυτήν, οπότε όταν διαγραφεί, θα αφήσει ότι αλλαγές έχει κάνει στην αναφορέμονη ομάδα.
  • Μπορούν να έχουν ή όχι όνομα. Όταν δεν έχουν όνομα βρίσκονται σε θέσεις που προσδιορίζονται με κάποιους δείκτες, όπως σε θέση πίνακα, σε κατάσταση βάσει κλειδιού, σε σωρό τιμών.
  • Μπορούν να έχουμε ομάδες μέσα σε ομάδες. Οι ιδιότητες είναι ομάδες σε ομάδες που γυρνούν τιμές.
  • Μπορούμε να ορίσουμε οποιαδήποτε ομάδα να παίρνει τιμή, ή να δίνει τιμή, ή και τα δύο. Εξ ορισμού δίνει το αντίγραφό της.
  • Μπορούμε να ορίσουμε τελεστές (πράξεις) τόσο ως μοναδιαίες όπως το Α++, όσο και κανονικά, αλλά όταν δεν έχουμε ορίσει αξία (γιατί αν το έχουμε κάνει ισχύουν οι τελεστές που έχει η "αξία"). Έτσι μια έκφραση Α=Β+Γ μπορεί να αποτελείται από τρεις ομάδες όπου η Α φτιάχνεται από την Β και και Γ
  • Σε αυτήν την αναθεώρηση μπήκε και η Υπερκλάση. Έτσι με το μπλοκ Για Υπερκλάση { } μποορύμε να προσεγγίσουμε τις μεταβλητές/πίνακες της υπερκλάσης. Η υπερκλάση ακολουθεί και σε αυτό που αντιγράφουμε την ομάδα μας.
  • Υπήρχαν τρεις διαφορετικές ζώνες στο μπλοκ δημιουργίας των ομάδων, το Ιδιωτικό, Δημόσιο, και η Κλάση. και τώρα προστέθηκε το Μοναδικό. Μπορούμε στις Υπερκλάσεις να ορίσουμε μοναδικά πεδία, ώστε να μην έχουν ένα παρόμοιο τα αντικείμενα που φτιάχνουμε από αυτή, αλλά να βλέπουν αυτά τα κοινά πεδία όλα τα αντικείμενα της υπερκλάσης. Μόνο τα Μοναδικά και τα Δημόσια μπορούμε να τα βλέπουμε ως μέλη της Υπερκλάσης. Όλα εκτός από τα μοναδικά θα υπάρχουν για τα αντικείμενα. Η ζώνη της κλάσης χρησιμοποιείται για προσωρινά στοιχεία, τμήματα, συναρτήσεις, που δεν θέλουμε να μην αντιγράφονται.
  • Η Κλάση Όνομα {} δημιουργεί γενική συνάρτηση που δημιουργεί ομάδες και η ζώνη της κλάσης παραγράφεται από το τελικό προιόν. Μπορούμε με το ίδιο όνομα να δώσουμε ένα τμήμα ως κατασκευαστής. Δεν υπάρχει ειδικός "διαλύτης" ομάδων.
  • Η Υπερκλάση δεν είναι συνάρτηση, αλλά όταν φτιάχνεται δημιουργείται σε μια μεταβλητή ένα αντικείμενο χωρίς μέλη, αλλά με δυο στοιχεία, ένα που λέει ότι είναι υπερκλάση, και ένα άλλο που είναι ο δείκτης στο αντικείμενο. Το αντικείμενο χρησιμοποιείται για να φτιάχνουμε νέα αντικείμενα, και για να σώνουμε τις μεταβλητές/πίνακες της υπερκλάσης. Προς το παρόν δεν υπάρχει κάτι για να δηλώνει αν μια ομάδα έχει μια συγκεκριμένη υπερκλάση. Αυτό μπορεί να γίνει "συμβατικά" δηλαδή να ορίσουμε μια μεταβλητή να κρατάει το όνομα της κλάσης, και να μην την "εμπλουτίζουμε".
  • Οι ομάδες δεν είναι αντικείμενα με δείκτες, δηλαδή δεν τις κρατάμε σε ενέργεια με δείκτες (αναφορές) σε αυτές. Οι επώνυμες ομάδες διαγράφονται στο μπλοκ που δημιουργήθηκαν (τμήμα ή μπλοκ Για αντικείμενο { }), ενώ οι ανώνυμες διαγράφονται όταν διαγραφεί ο φορέας τους (πχ ο Πίνακας). Μπορούμε να χρησιμοποιούμε πίνακες που είναι αντικείμενα με δείκτες και να φτιάξουμε ολόκληρη δομή συνδεδεμένων ομάδων. Οι πίνακες μπορούν να έχουν πίνακες, καταστάσεις, σωρούς, ομάδες, λάμδα συναρτήσεις,και φυσικά τιμές που δεν είναι αντικείμενα. 
  • Δεν γίνεται μια ομάδα να δείχνει τον εαυτό της με δέικτη. Μπορούμε να χρησιμοποιήσουμε την Αυτό (This) για να την περάσουμε με αναφορά ή με αντιγραφή  την ομάδα μέσα από ένα τμήμα της ομάδας, ή μια συνάρτηση.
  • Μια εσωτερική ομάδα δεν βλέπει την γονική, δεν μπορεί να καλέσει τμήματα και συναρτήσεις της γονικής, ή άλλης διπλανής ομάδας. αλλά βλέπει ότι έχει περιεχόμενο, και είναι δημόσιο για τις περιεχόμενες ομάδες. Υπάρχει μια ειδική εντολή που επιτρέπει να συνδεθεί με αναφορά μια τιμή/πεδίο τηςγονικής ομάδας, και με αυτήν φτιάχνουμε πολύπλοκες ιδιότητες ομάδων.
  • Υπάρχουν ισχνές αναφορές αν θέλουμε να "συνδέσουμε" ομάδες. Αυτές είναι το πραγματικό όνομα κάθε ομάδας, και μας το δίνει η συνάρτηση Ισχνή$(), Weak$(). Αυτές γράφονται σε αλφαριθμητικά.

 Υπερκλάση ΑΛΦΑ {
      Μοναδικό:
            Χ, Υ
            Πίνακας Α(20)
      Δημόσιο:
      \\ η Κ θα υπάρχει και ως Κ της υπερκλάσης και ως Κ του αντικειμένου
            Κ=10
            Τμήμα Εμφάνισε {
                  Για Υπερκλάση, Αυτό {
                        \\ εμφανίζουμε το Κ της κλάσης και του αντικειμένου
                        Τύπωσε .Κ, ..Κ
                        \\ Τα .Χ και .Υ είναι μόνο για τη κλάση
                        ++
                        Τύπωσε .Χ,
                        \\ Και πίνακες μπορούμε να βάλουμε ως μοναδικά στοιχεία.
                        Τύπωσε .Α()
                  }
            }
}
Κ=ΑΛΦΑ
Κ.Εμφάνισε

Κλάση Δέλτα {
      Ιδιότητα ΜόνοΑνάγνωση {Αξία} = 1234321
      Τμήμα Δέλτα (Αυτό) {}
}
Μ=Δέλτα(ΑΛΦΑ)
Μ.Εμφάνισε
Τύπωσε Μ.ΜόνοΑνάγνωση
\\ εδώ ο Α() έχει τα τμήματα κοινά για όλα τα στοιχεία.
\\ και επιπλέον όλα τα στοιχεία έχουν σύνδεση με την κλάση του ΑΛΦΑ
\\ ακόμα και να "χαθεί" το ΑΛΦΑ, η σύνδεση διατηρεί το αντικείμενο με τα στοιχεία.
Πίνακας Α(100)=Δέλτα(Αλφα)
Α(4).Εμφάνισε

Και ένα δεύτερο, όπου ένα αντικείμενο έχει δυο ομάδες, και σε κάθε ομάδα μια υπερκλάση:

ΥπερΚλάση Κάπα1 {
      χ=10
      Τμήμα Εμφάνισε {
            Για ΥπερΚλάση {
                  ++
                  Τύπωσε .χ, Αυτό.χ
            }
      }
}
ΥπερΚλάση Κάπα2 {
      χ=50
            Τμήμα Εμφάνισε {
            Για ΥπερΚλάση {
                  ++
                  Τύπωσε .χ, Αυτό.χ
            }
      }
}
Ομάδα Άλφα {
      Ομάδα Βήτα {
            \\ δεν θα βάλουμε εδώ ορισμούς γιατί έχει η ΥπερΚλάση
            \\ αλλά θα μπορούσαμε να ξαναπαίξουμε τον ορισμό και να αλλάξουμε
            \\ ακόμα και ένα τμήμα που ορίστηκε στην υπερκλάση για τη συγκεκριμένη ομάδα.
      }
}
\\ Πρώτα θα συγχωνεύσουμε τη ΥπερΚλάση (θα φτιάξει νέα μέλη και θα δώσει και ένα δείκτη)
Άλφα.Βήτα=Κάπα2
Άλφα=Κάπα1
\\ Τώρα έχουμε δυο ΥπερΚλάσεις, μια για την εξωτερική Ομάδα, και μια για την εσωτερική Ομάδα
Άλφα.Εμφάνισε              \\ 11 10
Άλφα.Βήτα.Εμφάνισε   \\ 51 50

Ζ=Άλφα

Ζ.Εμφάνισε                      \\ 12 10
Ζ.Βήτα.Εμφάνισε           \\ 52 50
Άλφα.Εμφάνισε              \\ 13 10
Άλφα.Βήτα.Εμφάνισε   \\ 53 50

Πίνακας Α(10)
Α(3)=Ζ
Α(3).Εμφάνισε \\ 14 10
Α(3).Βήτα.Εμφάνισε \\ 54 50

Κατάσταση Κατ1= 100:=Ζ
\\ τα κλειδιά είναι αλφαριθμητικά, απλά φαίνονται και ως αριθμοί!
Κατ1("100").Εμφάνισε \\ 15 10
Κατ1(100).Βήτα.Εμφάνισε \\ 55 50



Παραδείγματα με αγγλικές εντολές:
Superclass Alpha {
      Unique:
            x, y
            Dim A(20)
      Public:
      \\ k created for superclass and for object (two different things, two differnet values)
            k=10
            Module DisplayInfo {
                  For Superclass, This {
                        .k++
                        \\ in one prin we can handle k from superclass and k from object.
                        Print .k, ..k
                        \\  .x and .y are unique here
                        .x++
                        Print .x, .y
                         \\ Here we print arrays (only from Superclass, because we dedined in Unique part)
                        Print .A()
                  }
            }
}
\\ there is no Alpha.DisplayInfo, or other value. Alpha is closed, only can create/merge other objects (groups)
k=Alpha
k.DisplayInfo
Class Delta {
      Property ReadOnly {Value} = 1234321
      Module Delta (This) {}
}
m=Delta(Alpha)
m.DisplayInfo
Print m.ReadOnly
\\ here Array A() has a special holder for all items (are groups), for code only.
\\ because all Delta() get Alpha as SuperClass (merged to This in constructor)
\\ all have SuperClass common variables/arrays through a dedicated pointer
\\ so we can export this array, and return from this block (maybe a module)
\\ and Alpha erased, but not data if there are objects who hold pointer to them
Dim A(100)=Delta(Alpha)
A(4).DisplayInfo

Another one (the same as the programms with greek commands, M2000 has double vocabulary. Greek and English):

 
Superclass Kappa1 {
      x=10
      Module Display {
            For Superclass {
                  .x++
                  Print .x, This.x
            }
      }
}
Superclass Kappa2 {
      x=50
            Module Display {
            For Superclass {
                  .x++
                  Print .x, This.x
            }
      }
}
\\ we can create groups using Group command
Group Alfa {
      Group Beta {
            \\ no definitions yet we get from superclass
      }
}
\\ first we bind superclass for each group
Alfa.Beta=Kappa2
Alfa=Kappa1
\\ now we have two superclass, one for outer group, and one for inner group
Alfa.Display            \\ 11 10
Alfa.Beta.Display   \\ 51 50

Z=Alfa

Z.Display                 \\ 12 10
Z.Beta.Display        \\ 52 50
Alfa.Display            \\ 13 10
Alfa.Beta.Display   \\ 53 50

Dim A(10)
A(3)=Z
A(3).Display \\ 14 10
A(3).Beta.Display \\ 54 50

Inventory Inv1 = 100:=Z
\\ keys for inventories are strings, but we can handle like numbers if they are like numbers
Inv1("100").Display \\ 15 10
Inv1(100).Beta.Display \\ 55 50