the example below is based on one of the test-cases..... using //B in the struct definition //A ... would be my favorite - appears logical for me //B & //B1 ... complains "Variable eventTicket used before being initialized" .... well - ticketPrices has values ?!?!?! //B & //B2 ... works .... " Event()" ... why?

struct Event { //A var ticketPrices: [Int] //B var ticketPrices = [100,200,300] func buy(type: Int) { let cost = ticketPrices[type] print("That'll be $(cost), please") } } //A var eventTicket = Event(ticketPrices: [100,200,300]) //B1 var eventTicket : Event //B2 var eventTicket = Event() eventTicket.buy(type: 1) print (eventTicket.ticketPrices.count)

Can you fix your post so it's easier to read the code? It's a little hard to see what you're talking about with the code all run together in a paragraph.

To format a code block, place three backticks ``` on the line before your code and three backticks ``` on the line after your code so that it will be formatted properly. You can also highlight an entire code block and click the </> button on the toolbar to wrap the block for you.

This makes it far easier to read and also makes it easier for other posters to copy/paste the code in order to test solutions and such.

Doing this will ensure that you end up with something like this:

func printSomething(_ thing: String?) {
    if let thing = thing {
        print(thing)
    } else {
        print("nothing there")
    }
}

instead of this:

func printSomething(_ thing: String?) { if let thing = thing { print(thing) } else { print("nothing there") } }

... this is a rewriting of the original post ...

the example below is based on one of the test-cases..... the ticketPrice Array filled inside the struct definition Using: //1 ... complains "Variable eventTicket used before being initialized" .... well - ticketPrices has values ?!?!?! //2 ... works .... " Event()" ... why?

struct Event {
    var ticketPrices = [100,200,300]
    func buy(type: Int) {
        let cost = ticketPrices[type]
        print("That'll be $\(cost), please")
    }
}
//1 var eventTicket : Event
//2 var eventTicket = Event()
eventTicket.buy(type: 1)
print (eventTicket.ticketPrices.count)

This is another version .... ticketPrices just defined as array of Int Is this not the cleaner why? Specially as the filled array seems not satisfying the "initialization".

struct Event {
    var ticketPrices: [Int]
    func buy(type: Int) {
        let cost = ticketPrices[type]
        print("That'll be $\(cost), please")
    }
}
var eventTicket = Event(ticketPrices: [100,200,300])
eventTicket.buy(type: 1)
print (eventTicket.ticketPrices.count)

Sorry .... just learned more in day9 "memberwise initializers"

One thing is confusing here ... it is said that structs can be seen like types. So I tried the //1 syntax The //2 syntax appears more like calling a function

struct Event {
    var ticketPrices = [100,200,300]
    func buy(type: Int) {
        let cost = ticketPrices[type]
        print("That'll be $\(cost), please")
    }
}
//1 var eventTicket : Event
//2 var eventTicket = Event()
eventTicket.buy(type: 1)
print (eventTicket.ticketPrices.count)

The //2 syntax appears more like calling a function

Well, that's because you are calling a function.

This code:

var eventTicket = Event()

is really a shorthand for:

var eventTicket = Event.init()