MED Send Message

Create a SendMessage method for the User struct.

It should take a message string and messageLength int as inputs.

If the messageLength is within the user's message character limit, return the original message and true (indicating the message can be sent), otherwise, return an empty string and false.

package main


func (u User) SendMessage(message string, messageLength int) (string,bool){
	
	inLimit := messageLength <= u.MessageCharLimit

	if inLimit == true{
		return message, inLimit
	}else{
		return "",inLimit
	}
}

// don't touch below this line

type User struct {
	Name string
	Membership
}

type Membership struct {
	Type             string
	MessageCharLimit int
}

func newUser(name string, membershipType string) User {
	membership := Membership{Type: membershipType}
	if membershipType == "premium" {
		membership.MessageCharLimit = 1000
	} else {
		membership.Type = "standard"
		membership.MessageCharLimit = 100
	}
	return User{Name: name, Membership: membership}
}

Test

---------------------------------
Test Passed:
* user:               Syl
* membership type:    standard
* message:            Hello, Kaladin!
* expected result:    Hello, Kaladin!
* expected success:   true
* actual result:      Hello, Kaladin!
* actual success:     true
---------------------------------
Test Passed:
* user:               Pattern
* membership type:    premium
* message:            You are not as good with patterns... You are abstract. You think in lies and tell them to yourselves. That is fascinating, but it is not good for patterns.
* expected result:    You are not as good with patterns... You are abstract. You think in lies and tell them to yourselves. That is fascinating, but it is not good for patterns.
* expected success:   true
* actual result:      You are not as good with patterns... You are abstract. You think in lies and tell them to yourselves. That is fascinating, but it is not good for patterns.
* actual success:     true
---------------------------------
Test Passed:
* user:               Dalinar
* membership type:    standard
* message:            I will take responsibility for what I have done. If I must fall, I will rise each time a better man.
* expected result:    I will take responsibility for what I have done. If I must fall, I will rise each time a better man.
* expected success:   true
* actual result:      I will take responsibility for what I have done. If I must fall, I will rise each time a better man.
* actual success:     true
---------------------------------
3 passed, 0 failed, 2 skipped
PASS

1

1. Structs

type User struct {
    Name string
    Membership
}

• User represents a person with a name and a membership.

• Membership is embedded, meaning User can access its fields directly (like u.MessageCharLimit).

2

2. Membership limits

type Membership struct {
    Type             string
    MessageCharLimit int
}

• A standard user can send messages up to 100 characters.

• A premium user can send up to 1000 characters.

3

3. Creating a new user

func newUser(name string, membershipType string) User

Example:

user1 := newUser("Alice", "standard")
user2 := newUser("Bob", "premium")

4

4. SendMessage method

func (u User) SendMessage(message string, messageLength int) (string, bool)

• (u User) means this function belongs to the User type.

• (string, bool) are the two return values — the message and whether it’s valid.

• It compares the message’s length (messageLength) to u.MessageCharLimit.

5

5. Logic

inLimit := messageLength <= u.MessageCharLimit

• inLimit becomes true if message length is small enough.

• If true, send the message.

• If false, block it and return an empty string.

---

Example Usage

func main() {
	user := newUser("Alice", "standard")

	msg, ok := user.SendMessage("Hello, world!", 13)
	println(msg, ok) // Output: Hello, world! true

	msg2, ok2 := user.SendMessage("This message is way too long to fit inside the limit...", 200)
	println(msg2, ok2) // Output:  false
}

Key Takeaways

• func (u User) → defines a method attached to the User struct.

• Return types (string, bool) → Go supports returning multiple values.

• Embedded structs → allow direct field access like u.MessageCharLimit.

• Logical check → use <= to compare message length with limit.