representation of enum member values in swift? -

enum compasspoint { case north, east, south, west }  var compassheading = compasspoint.west 

i've read "the case values of enumeration actual values, not way of writing raw values." i'm confused statement. if cases new types themselves, shouldn't initialized as:

var compassheading = compasspoint.west() 

according apple, enums don't include implicit initializers.. confuses me more.

tldr;

if typing out case of enum case has associated values, type of case higher order function arguments matching associated values , return type matching enum itself. since different cases allowed have different types (and number) of associated values, naturally type of typed out enum case can differ. importance here differ between enum instance (which have given case value) , explicit types of cases (when not values).

---

an enum instance associated case, , have type of enum

i don't know source of quotations, the language guide quite straightforward on describing each case value:

an enumeration defines common type group of related values , enables work values in type-safe way within code.

the typed cases of enum:s cases of different associated values define different types of higher order function types, returning type of enum

but in addition value-view of case instance of enum, might noted each case (typed out!) has type (although not "new" type in sense struct foo {} would), may differ between different cases of same enum. if cases have no associated value(s), type equals enum itself, if case use associated values, type of case higher order function type arguments typed associated values , return type being enum type itself. since different cases can have different associated values, naturally follows different cases can correspond different types.

alternatively, enumeration cases can specify associated values of type stored along each different case value, unions or variants in other languages. can define common set of related cases part of 1 enumeration, each of has different set of values of appropriate types associated it.

...

you can define swift enumerations store associated values of given type, and value types can different each case of enumeration if needed.

enum foo {     case bar     case baz(int) // int associated value     case bax()    // void associated value }  print(type(of: foo.bar)) // foo print(type(of: foo.baz)) // (int) -> foo print(type(of: foo.bax)) // () -> foo  func foo(_ closure: (int) -> foo) -> foo {     return closure(42) }  let foobaz = foo(foo.baz) // 'foobar' 'foo.baz' (ass. value 42)  let foobar = foo(foo.bar) // wont compile, type mismatch let foobax = foo(foo.bax) // wont compile, type mismatch 

now, since different cases have different types (when typed out, not when part of foo instance), "initialization" of given case given enum instance different depending on whether case have associated values or not.

enum foo {     case bar     case baz(int) // int associated value     case bax()    // void associated value }  var foo = foo.bar // no associated values foo = foo.baz(42) // expects int associated value: needs _invoked_(/called) foo = foo.bax()   // expects empty tuple '()' associated value: needs _invoked_(/called) 

as can see, case instance without associated value instantiated typing out enum type , case (since type of case enum itself: compare foo.bar), whereas cases associated values (even ()) need invoked when instantiated. invokation, particularly bax() case above, might lot implicit initialization, invokation of closure type receive instance of return type foo.

let avoidfooclosure = foo.bax let afooinstance = avoidfooclosure()   // invoke! have value 'foo.bax' (empty tuple '()' associated value)