I'm just a bit confused

You got the struct right !

Lucky guess! :-)

Or just to good at coding ? lol

I need to get out more, that's true! :-)

To be fair, Treehouse naming conventions are so strong that it isn't difficult to guess roughly what they'll call things.

That is true, but somethings the instructions can be a bit confusing. Specially if you are new to the language.

Thanks! This worked!

True - it does all take a little time to sink in.

No problem, Cobie Fisher - glad it worked. :-)

Steve Hunter do you have an e-mail address ? If so can you e-mail me at jhoannarango@msn.com

Hi Steve, correct me if im wrong, but the job could be easily done without the struct right? then whats struct exactly for?

This code still doesn't pass the challenge.

Hi Josh,

Can you post a link to the current challenge? Swift has changed a lot since this thread was created. Looking at the comments on here, the code did pass the challenge so something must have changed. A link would help.

Thanks,

Steve.

Steve Hunter https://teamtreehouse.com/library/objectoriented-swift-3/complex-data-structures/adding-instance-methods

Thanks Josh,

One reason that the above code doesn't work in this challenge (a different challenge to the one you're doing - Swift 3 didn't exist back then!) is that the original challenge wanted a function named getFullName(). The challenge you're doing just wants one called fullName(). So, changing that for step one gives you:

struct Person {
    let firstName: String
    let lastName: String

    func fullName() -> String {
      return "\(firstName) \(lastName)"
    }
}

That should work for you.

Steve.

Hey Steve Hunter Replying a year later, and still hoping I get an answer :)

I was wondering if we could pass in values in the Person struct WITHOUT specifying the variable type. I know in past courses I have watched instructors enter _ before the variable type.

Can we do this? so when I call the getFullName method I can do the following below: aPerson = Person("Steve", "Hunter")

rather than: aPerson = Person(firstName: "Steve", lastName: "Hunter")

Neiko Frye ,

You can, you just need to ignore the "argument label" in the initializer's body with the underscore.

In this example, I created an extension of the Struct "Person" so that you do not lose the memberwise initializer that comes standard in the Struct type. This way, you can have 2 initializers to choose from.

struct Person {
    var firstName: String
    var lastName: String
}

extension Person {

    init(_ firstName: String, _ lastName: String) {
        self.firstName = firstName
        self.lastName = lastName
    }
}

// Custom initializer 
let person = Person("Jhoan", "Arango")


// memberwise initializer (default)
let person = Person(firstName: "Jhoan", lastName: "Arango")

Hope this helps

Hi Steve Just a thought: Wouldn't it be possible and make more sense to do something like this:

  func getFullName(first: String, last: String) -> String {

If you can see what I mean by this.. I just think it would make more sense to write the names when actually creating the instance instead of in the method?

Hi Marina,

The getFullName() method is an accessor method. It enables easy, but indirect, access to the properties of a struct instance, or the member variables of a class instance. Let's stick to a struct for now as that's what's relevant to the point. The Person struct is initialized by setting its two properties, firstName and lastName such that we can create an instance of Person, as above like:

let myIdentity = Person(firstName: "Steve", lastName: "Hunter")

So, now we have an instance of the Person struct called myIdentity. We can access the properties that have been set using dot notation:

myIdentity.firstName // this outputs "steve"
myIdentity.lastName // guess what this outputs ;-)

Accessor methods, and helper methods, are used within the struct to enable better, more relevant, access to the properties. It isn't a strange requirement to want to have access to a person's full name - that's kinda what it's for! So, we create a function to help with accessing the instance's full name. We pass nothing into this method as we just want to get something out of the instance. We just want the full name; the instance already has all the information it needs to return this - so there's no need to pass in any parameters; there's no new information here. So, this accessor method simply returns the above two lines of code in one string from within the instance (allowing it to access the properties directly).

  func getFullName() -> String {
    return "\(firstName) \(lastName)"
  }

This works for every instance of Person.

Your example has two parameters passed into the instance - that information already exists within the instance so there no requirement to add extra.

I hope I explained my understanding of that OK!

Steve.

thanks Steve? what a silly mistake...

Wow, that worked. Wonder why the treehouse compiler rejected the (String) version though? It seems odd that it worked in Xcode, but not in the compiler. Is the method you suggested a better way or is this just a limitation of the treehouse compiler?

Thanks for your help, Steve!

I'm not sure what best practice is; maybe Jhoan can help with that. But for single returned values, I never use brackets. It is possible to return more than one value, a tuple for example, which then does need the brackets around the returned data types.

Steve.

Just copied your code, had the same error as you when put inside the function but if you put it after all the code outside of it then it is correct :)

Hi there,

You need to assign the return value of getFullName into a constant called fullName - just doing that inside the method isn't what it is after.

let aPerson = Person(firstName: "Vivien", lastName: "Gauthier")
let fullName = aPerson.getFullName() // assign this

You can simplify your return inside the method to just this (if you use concatentation):

    func getFullName() -> String {
        return firstName + " " + lastName
    }

Or, if you prefer interpolation:

    func getFullName() -> String {
        return "\(firstName) \(lastName)"
    }

But creating the constant fullName inside the struct is not what the challenge is looking for.

I hope that helps,

Steve.

I think you need to put inverted commas around the strings like "Raphael" and "Reiter" everything else seems fine :D

As far as I know, the init method is called implicitly, not explicitly. You don't need to call the method in your code. It works as a constructor of each class instance which the class itself triggers.

I think the correct code has been posted in this thread for quite some time. I hope you enjoy your Treehouse experience!

The slash is the syntax for string interpolation. The format \(var_name) is the way of inserting the value of var_name into a string. It's covered in the videos. As far as I know this hasn't changed with the later versions of Swift; this response does relate to the Swift language from 2015 - there have been many revisions of it since then!

And the space between the first & last name is between the closing bracket of firstName) and the slash of \(lastName:

return "\(firstName) \(lastName)"
                    ^

Or you can use concatenation which is a little ugly:

return firstName + " " + lastName

but the space is more obvious.

I hope that explains.

Steve.

Hi Nathalie,

The reason the function is inside the struct is so that every instance of the struct can have that functionality.

In this challenge, we create an instance of the struct called aPerson. That, and every, instance has the getFullName() function which returns the full name of the created struct instance. We are able to create as many instances of Person as we like and all of them will have the getFullName() function accessible with dot notation. So ...

let steve = Person(firstName: "Steve", lastName: "Hunter")
steve.getFullName()

... will work just fine. Yes, you could write the same functionality outside the struct:

let fullName = steve.firstName + " " + steve.lastName

But you'd have to do that for every instance. Using the internal function avoids duplication of code. Plus, this is an example - it is using very simple code. In the real world, the function could be doing some complex maths on stored properties. or accessing the internet to gather data, or controlling an external device - anything! So, internalising the func allows each instance of the struct possess built-in functionality which is consistent across all instances of the struct.

I hope that makes sense!

Steve.

No problem!

Hi Nathalie,

The func doesn't need the parameters as it is part of that instance of the struct. Internal functions can access the stored properties in the struct so there's no need to pass them in as parameters.

Some functions do need parameters if they aren't able to directly access the variables/constant they need. But for functions inside a struct or a class, the stored properties or member variables are directly accessible from inside.

I hope that help,

Steve.