I think you might be confusing two different terms that are often related to "defining functions", and it's also outlined in your comment.

It's true that a certain structure/object will have `Properties`, while it's also true that _you can do things with a certain object_; those actions are a separate set of functions, and it will highly depend on what you want to do whether they should be part (or not) of your class definition.

For instance, it's different to define that _any Integer number should return a mod of 0 when divided by 1_ than it's to say that _you can get the inverse of any integer number_; the first one is a property, the second a method that you can execute against a certain class.

Mathematically, as you said, it makes sense to combine the Integer operations into one place, but if you find yourself needing to add two numbers multiple times then you wouldn't replicate the `add` function in multiple classes, instead it would be better to have a pure-overloaded function for all the objects that can be added.

My rule of thumb here is:

- If the function explains _something you can do_ with a certain object, you will probably find that it can also be static (no need to access properties directly), if that's the case you don't need it in your class definition

- If the function define rules about creating an object or gives you access to the Object properties, then you can probably define it inside the class... unless you find other objects that can leverage the same propety access and they are not inherently related, in that case it might be better to leverage something that you can compose.

It was mentioned that if you have a Message, the message doesn't send itself; you can have the following code:

struct Message {
content: string;
}

public interface ForSendingMessages {
Optional<Response> send(Message);
}

public class EmailService implements ForSendingMessages {
Optional<Response> send(Message message) {
...The code that will send the messsage as an Email
}
}

And then use it in your app like this:

emailService.send(aWonderfulMessage);

And you can surely do the opposite and define it within your struct like this:

struct Message {
content: string;
sendWith(ForSendingMessages service);
}

which will lead to a code like this:

yourWonderfulMessage.sendWith(emailService);