Έκδοση 8.6 αναθεώρηση 1

Διορθώθηκε Bug στην προηγούμενη έκδοση (είχε λάθος στα ελληνικά στην ιδιότητα όταν χρησιμοποιούσαμε παράμετρο σε παρένθεση.

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

Κλάση Δες_Ιδιότητα {
Ιδιωτικό:
      Πίνακας Βάση 1, Α(3)
Δημόσιο:
      Ιδιότητα Όνομα$ {Αξία} = "Δες_Ιδιότητα"
      Ομάδα Άλφα {
            Ιδιότητα Όνομα$ {Αξία}= "Άλφα(δείκτης) - Μόνο για ανάγνωση"
      }
      Ιδιότητα Άλφα {
            Αξία (δείκτης1) {
                  Ένωσε γονικό Α() στο Α()
                  Δες οκ {
                        Αξία=Α(δείκτης1)
                  }
                  Άδειασε Λάθος \\ για να κρατήσει μόνο το τελευταίο που δίνουμε αμέσως μετά
                  Αν όχι Οκ τότε Λάθος "Δείκτης εκτός ορίων"
            }
      }
Κλάση:
      Τμήμα Δες_Ιδιότητα {
            .Α():=100,450,1890
      }
}
Μ=Δες_Ιδιότητα()
Τύπωσε Μ.Άλφα(1),Μ.Άλφα(2),Μ.Άλφα(3)
Τύπωσε Μ.Άλφα.Όνομα$
Δες Οκ {
      Τύπωσε Μ.Άλφα(10)
}
Τύπωσε "Το όνομά μου είναι:";Μ.Όνομα$
Αν όχι Οκ τότε Τύπωσε "Λάθος"+Λάθος$

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

Συνάρτηση Γενική ΜΜ (Χ,Υ) {
      =Χ**Υ
}
Τμήμα Γενικό ΚΛΜ (Ι) {
Τύπωσε Ι
}
Ομάδα Άλφα {
      Συνάρτηση ΜΜ (Χ,Υ) {
            =Χ**Υ
      }
      Τμήμα ΚΛΜ (Ι) {
      Τύπωσε Ι
      }
}
Τύπωσε Άλφα.ΜΜ(2,4)
Άλφα.ΚΛΜ 5
Τύπωσε ΜΜ(2,4)
ΚΛΜ 5

και για τις λάμδα:

Α=Λαμδα (Χ1)->Χ1**2
Τύπωσε Α(3)
Β=Λαμδα Χ=(1,2,3,4) (Υ)-> {
            =Πίνακας(Χ,Υ)
}
Τύπωσε Β(3)



Eσωτερικά δεν άλλαξε τίποτα, αλλά για το κώδικα φαίνεται πιο καθαρό το τι ζητάμε σε ορίσματα. Όμως υπάρχουν περιπτώσεις που το Read ή Διάβασε πρέπει να γίνει προοδευτικά ή μετά από καποιες εντολές. Σε άλλες γλώσσες αυτό είναι δύσκολο να γίνει, ή δεν γίνεται καθόλου!

Στην έκδοση 8.6 (αναθ 1) μπορούμε να έχουμε σε μεταβλητές το αντικείμενο Σωρός. Η Διάβασε διαβάζει από το σωρό του Τμήματος/Συνάρτησης και μπορεί να βάζουμε κιόλας με την Push/Βάλε στη κορυφή και την Data/Σειρά στο τέλος. Πάντα διαβάζουμε από την κορυφή, αφαιρόντας το στοιχείο, ή μπορούμε να διαβάσουμε με αριθμό, από το 1 για την κορυφή. Με τις μεταβλητές τύπου σωρού (ο τύπος αναφέρεται ως mStiva).

Στο πρώτο παράδειγμα βλέπουμε ότι μπορούμε να ταξινομήσουμε με ξεχωριστή ρουτίνα (έχει ενδιαφέρον η ρουτίνα, γιατί είναι μια quicksort σε λίστα που κάθε εισαγωγή γίνεται στη κορυφή και υπάρχουν δυο εντολές η Shft και η Shiftback που μεταφέρουν από και προς τη θέση που θέλουμε (εσωτερικά η mStiva είναι συνδεδεμένη λίστα αντικειμένων, τα οποία φέρουν τις τιμές που βάζουμε, και για το παράδειγμα είναι αλφαριθμητικά). Η quicksort έχει γραφτεί με ρουτίνα, και χρησιμοποιεί τον τρέχον σωρό, τον οποίο άλλαξε πρόσκαιρα η Stack .a { }. Σε προηγούμενες εκδόσεις υπήρχε μόνο η Stack New { } που έφτιαχνε έναν προσωρινό σωρό, αλλά τώρα μπορούμε να τον κρατάμε και εδώ μάλιστα τον έχουμε σε μια μεταβλητή σε ένα αντικείμενο Alpha.

Στην DisplayAll έχουμε την Each() που φτιάχνει ένα αντικείμενο με αναφορά στο σωρό (και αυτό είναι ο σωρός .a) και λέμε να μας δείξει κάθε στοιχείο από το τέλος ως την αρχή. Εδώ κοιτάμε το σωρό χωρίς να τον ενώσουμε προσωρινά με το σωρό του τμήματος. Φαίνονται εντολές για να παρεμβάλουμε τιμές στη θέση που θέλουμε.

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

Πρόσθεσα στο παράδειγμα τα Private: και Public:

Class Alpha1 {
Private:
      a=stack:="hello","there","and","good","bye"    
Public:
      module DisplayAll {
            n=each(.a End to Start) \\ each(a,-1,1)
                  While n {
                        Print stackitem$(n), n^+1
                  }
      }
      Property Stacklen {
            Value {
                  Link parent a to a
                  value=Len(a)
            }
      }
      Module PushToBack (Word$) {
            Stack .a { Data Word$ }
      }
      Module PushToFront (Word$) {
            Stack .a { Push Word$ }
      }
      Module ClearStack {
            Stack .a {Flush}
      }
      Module Insert (word$, position) {
            Stack .a {
                  Push word$
                  Shiftback position
            }
      }
      Module Sort {
      Stack .a {
            qsort(1, stack.size)
      }
      Sub qsort(st, ed)
            Local thing$, i=st, lim=ed+1
            If lim >2 Then Shift (lim+i) Div 2
            Read thing$
            lim--
            While i<lim {
                  If thing$<StackItem$(i) Then {
                        lim--
                        If i>1 Then Shift i
                        ShiftBack lim
                  }  Else i++
            }
            If i>lim Then i=lim
            Push thing$ : ShiftBack i
            If i>st Then qsort(st,i-1)
            If ed>i Then qsort(i,ed)
      End Sub
      }
}
Alpha=Alpha1()
Alpha.DisplayAll
Alpha.Insert "zzzzzzzzzzz", 4
Alpha.DisplayAll
Alpha.Sort
Alpha.DisplayAll
Alpha.PushtoBack "Back"
Alpha.PushtoFront "Front"
Print alpha.StackLen

Στο δεύτερο μικρό παράδειγμα φαίνεται ότι μπορούμε να βάζουμε σωρούς και σε πίνακες.

Alfa=Stack
Print Type$(Alfa)
dim a(10)
a(1)=stack
Stack Alfa {
    Push 10, 20
    stack
}
Stack
Stack a(1) {
     Push 1,2,3
}
Stack a(1) {
      stack
      Read A, B
      Stack Alfa {
            Push B, A
            Stack
      }
   
}
list  \\ list of variables

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

flush
Dim a$(10)
a$(1)=stack$(1,"Hello",3,4,5)
stack a$(1), "NS"
Print a$(1)
Stack

Στο επόμενο παράδειγμα βλέπουμε πως βγάζουμε αντίγραφο ενός αντικειμένου σωρού: Η συνάρτηση Stack( ) με ένα όρισμα δίνει το αντικείμενο ως αντίγραφο.

A=stack
Stack A {
      Data 1,2,3,4,5
}
B=Stack(A)
Stack B {
      Print "This is B"
      Stack
      flush
      Print Empty
}
Stack A {
      Print "This is A"
      Stack
}

Το δεύτερο προαιρετικό όρισμα στη Stack() δηλώνει αν είναι αριθμός αν θα πάρουμε ένα αριθμό από την αρχή ή αν είναι αρνητικό από το τέλος με το τελευταίο ως πρώτο, το προτελευταίο ως δεύτερο κ.ο.κ. Αν το όρισμα είναι και αυτό σωρός τότε η Stack() δίνει ένα νέο αντικείμενο με τα στοιχεία του δεύτερου στο τέλος του πρώτου. Ένα απλό Β=Α κάνει το Β να δείχνει το Α

Στο τελευταίο παράδειγμα η b παίρνει ένα νέο σωρό με  ίδια με τα 4 πρώτα στοιχεία του a. Η εντολή Stack χωρίς όρισμα δείχνει τα στοιχεία του σωρού. Μπορούμε να έχουμε φωλιασμένα While (Ενώ) και να διατρέχουμε τον σωρό με ανεξάρτητους κέρσορες (όπως στις Καταστάσεις και στους Πίνακες).

a=stack:=1,2,3,4,5
b=stack:=6,7,8
a=stack(a,b)
Stack a {
      stack
}
b=stack(a, 4)
Stack b {
      stack
}
b=stack(a, -4)
Stack b {
      stack
}
N=each(a, 2, 5)
D=each(a, 6,7)
k=0
While N {
      While D {
            Print stackitem(N), stackitem(D)
      }
}