Enum

Gli enum sono un altro tipo rispetto alle classi e sono dichiarati con un numero finito di costruttori. Ecco un piccolo esempio:

    enum Color {
        red;
        green;
        blue;
    }

    class Colors {
        static function toInt( c : Color ) : Int {
            return switch( c ) {
                case red: 0xFF0000;
                case green: 0x00FF00;
                case blue: 0x0000FF;

            }
        }
    }

Quando vuoi assicurarti che solo un prefissato numero di valori sono usati allora gli enum sono la cosa migliore perché garantiscono che gli altri valori non possono essere costruiti.

Parametri dei Costruttori

Il precedente esempio di Color mostra tre costruttori costanti per un enum. È anche possibile avere parametri per i costruttori:

    enum Color2 {
        red;
        green;
        blue;
        grey( v : Int );
        rgb( r : Int, g : Int, b : Int );
    }

In questo modo ci sono un infinito numero di possibili Color2, ma sono cinque differenti costruttori possibili per esso. I seguenti valori sono tutti Color2:

    red;
    green;
    blue;
    grey(0);
    grey(128);
    rgb( 0x00, 0x12, 0x23 );
    rgb( 0xFF, 0xAA, 0xBB );

Possiamo anche avere un tipo ricorsivo, per esempio aggiungendo alpha:

    enum Color3 {
        red;
        green;
        blue;
        grey( v : Int );
        rgb( r : Int, g : Int, b : Int );
        alpha( a : Int, col : Color3 );
    }

I seguenti sono valori validi di Color3:

    alpha( 127, red );
    alpha( 255, rgb(0,0,0) );

Switch su Enum

Gli Switch hanno una speciale semantica quando usati con un enum. Se non c'è il case default allora controllano che tutti i costruttori di enum siano usati, e riceverai un errore altrimenti. Ad esempio, usando il primo enum Color:

    switch( c ) {
        case red: 0xFF0000;
        case green: 0x00FF00;
    }

Questo causa un errore di compilazione dicendo che il costruttore blue non è usato. In questo caso puoi sia aggiungere un caso per esso od aggiungere un case di default che fa qualcosa. È molto utile poiché quando aggiungi un nuovo costruttore al tuo enum, gli errori di compilazione mostreranno nel tuo programma i posti dove il nuovo costruttore deve essere gestito.

Switch con Parametri dei Costruttori

Se il costruttore di enum ha parametri, essi devono essere elencati come nome variabile in un case di uno switch. In questo modo tutte le variabili diventano localmente accessibili nell'espressione case e corrispondono al tipo del parametro del costruttore enum. Ad esempio, usando l'enum Color3

    class Colors {
        static function toInt( c : Color3 ) : Int {
            return switch( c ) {
                case red: 0xFF0000;
                case green: 0x00FF00;
                case blue: 0x0000FF;
                case grey(v): (v << 16) | (v << 8) | v;
                case rgb(r,g,b): (r << 16) | (g << 8) | b;
                case alpha(a,c): (a << 24) | (toInt(c) & 0xFFFFFF);
            }
        }

    }

Usare switch è il solo modo possibile per accedere ad i parametri del costruttore enum.

Parametri di Tipo di Enum

Un enum, come le classi, può anche avere parametri di tipo. La sintassi è la stessa, qui c'è un piccolo esempio di una linked List parametrizzata usando un enum per immagazzinare le celle:

    enum Cell<T> {
        empty;
        cons( item : T, next : Cell<T> );
    }

    class List<T> {
        var head : Cell<T>;

        public function new() {
            head = empty;
        }

        public function add( item : T ) {
            head = cons(item,head);
        }

        public function length() : Int {
            return cell_length(head);
        }

        private function cell_length( c : Cell<T> ) : Int {
            return switch( c ) {
            case empty : 0;
            case cons(item,next): 1 + cell_length(next);
            }
        }

    }

Usare sia enum che le classi insieme può essere abbastanza potente in alcuni casi.

«« Type Parameters - Packages and Imports »»

version #4198, modified 2008-09-07 10:55:54 by Kris