Verschiedene Möglichkeiten, Enum-Datentyp in Julia-Lang zu deklarieren

Question

Verwendet @enum die einzige Möglichkeit, Julia Enum-Datentyp zu deklarieren? Wenn ja warum?

Answer 1

Es ist der einzige (einfache) Weg, ja. Die Antwort, wie oft (oder besser immer) in Julia, kann durch den Blick auf die source code gefunden werden. Das kann anfangs ein bisschen gruselig sein, aber man gewöhnt sich nach einiger Zeit daran!

Um ein Objekt eines bestimmten Typs zu erstellen, rufen Sie normalerweise den Konstruktor des Typs auf. So könnte man erwarten, dass ein Objekt vom Typ Enum tun

Enum(...) 

und erstellen.

In diesem Fall ist Enum jedoch ein abstrakter Typ, so dass Sie das nicht tun können.

Was bedeutet @enum tun, dann? Das Beispiel aus dem manual ist

julia> @enum FRUIT apple=1 orange=2 kiwi=3 

Das tatsächlich schafft eine völlig neue Art, genannt FRUIT, ist, dass ein Subtyp von Enum und Objekte dieses Typs apple genannt, orange und kiwi, die denen umgewandelt werden Zahlen durch den Aufruf Int(apple) usw. Dies wird durch die Generierung der Julia-Code, um dies zu tun, innerhalb des Makros getan.

Im Prinzip könnte man, sich selbst, die ganze Arbeit, die das Makro tut, aber das Makro ist es unser Leben leichter zu machen!

Answer 2

... und dann gibt es den missbrauchenden Weg, es zu tun; dass ich gestolpert, während die Typen als Name für Sätze zu denken:

typealias Sunday Val{:Sunday} 
typealias Monday Val{:Monday} 
typealias Tuesday Val{:Tuesday} 
typealias Wednesday Val{:Wednesday} 
typealias Thursday Val{:Thursday} 
typealias Friday Val{:Friday} 
typealias Saturday Val{:Saturday} 

typealias Days Union{ 
    Type{Sunday}, 
    Type{Monday}, 
    Type{Tuesday}, 
    Type{Wednesday}, 
    Type{Thursday}, 
    Type{Friday}, 
    Type{Saturday} 
} 

function daynumber(d::Days) 
    if d == Sunday return 0 
    elseif d == Monday return 1 
    elseif d == Tuesday return 2 
    elseif d == Wednesday return 3 
    elseif d == Thursday return 4 
    elseif d == Friday return 5 
    elseif d == Wednesday return 6 
    end 
    -1 
end 

> daynumber(Friday) 
    5 
> daynumber(:Friday) 
    > MethodError:`daynumber` has no method matching (::Symbol) 

Beachten Sie, dass die Verwendung von Symbolen nur ein ziemlich wenig Reflexion ist, und ist völlig überflüssig. Sie können alles in dort setzen, und es dann durch

Typ Inspektion erholen

> x = Saturday.parameters[1] 
    :Saturday 
> typeof(x) 
    Symbol 
> eval(x) == Saturday 
    true 

ich ziemlich sicher bin der Dokumentation empfiehlt ausdrücklich against diese. Dennoch büßt @code_warntype dieses Konstrukt nicht besonders ein.

In satztheoretischen Begriffen ist jeder Tag-Alias ​​ein Singletontyp und somit ein Name für eine Menge von genau einem Element. Die "Union" von "Typ" s ist dann die mengentheoretische Vereinigung einzelner Elementmengen, die den enumerierten endlichen Settyp bilden.

... und noch mehr Art Mangeln Weisen

Aufzählung tun

abstract Fruits{N} <: Enum 
immutable Apples <: Fruits{1} end 
immutable Oranges <: Fruits{2} end 
immutable Bananas <: Fruits{3} end 

fruitsalad{N}(x::Fruits{N}) = N 

> anorange = Oranges() 
> fruitsalad(anorange) 
    2 

Wieder scheint @code_warntype nicht dies überhaupt in den Sinn. Schließlich noch eine letzte Technik, die auch einen geschützten Namensraum für die Zählung liefert

immutable Fruits{N} <: Enum 
    apples::Fruits 
    bananas::Fruits 
    oranges::Fruits 
    function Base.call(::Type{Fruits}) 
     new{"anything"}(
      Fruits{"crunchy"}(), 
      Fruits{"mushy"}(), 
      Fruits{"tangy"}() 
     ) 
    end 
    function Base.call{N}(::Type{Fruits{N}}) 
     if N != "crunchy" && N != "mushy" && N != "tangy" 
      error("Invalid enumeration parameter") 
     end 
     new{N}() 
    end 
end 

fruitsalad{N}(x::Fruits{N}) = N 

> fruitsalad(Fruits().apples) 
    "crunchy" 

In diesem letzten Beispiel die Bequemlichkeit Eigenschaft zuzugreifen, die eine Instanz einer bestimmten Frucht gibt mussten wir zunächst den allgemeinen Früchte Typen instanziiert. Im Jargon des objektorientierten Designs hat Julia keinen Sinn für statische Eigenschaften von Typen.Die Eigenschaften von Typen sind nur verfügbar, wenn eine explizite Instanz dieses Typs erstellt wurde. Der Gedanke, dass alles, was über einen bestimmten Typ statisch verfügbar ist, sollte in einer Form der Methodenüberladung dargestellt werden.