monster | The Art of Template MetaProgramming in Modern C️

As others have pointed out, this isn't really the intended usage for default interface methods. As the documentation states:

The most common scenario is to safely add members to an interface already released and used by innumerable clients.

For the way you want to use it, there's another mechanism available: Static extension methods. As you're probably already aware, this mechanism is used extensively in the CLR for things such as IEnumerable extension methods.

For your case, you could include the following static extension class alongside the interface:

Is there any reason ... why you would write a construct like that?

Only the author knows for sure (even they might not know). If there is source versioning metadata available, then associated commit message might be useful. Without more information, we can only guess what they were thinking. Some potential answers:

• The author assumed that the condition of the if-statement would have some effect, but they were wrong and the mistake wasn't tested.
• It's a vestigial result of some refactoring.
  • Perhaps some code was removed that used to make the statement meaningful.
  • Or perhaps it was copied from elsewhere where it did have a meaning.
  • Or perhaps there used to be a series of if-statements and there was an intention to replace them with a switch, but the change was half-assed.

The curly braces here make this a function, and it's expecting a return value. Your intention is to return an object. To do that, add parentheses.

With a little data manipulation, you could move the labels out to either side of the country an draw segments to connect the labels to the universities:

The only reasonable approach will be to use standalone deriving clauses to derive Generic instances for (most of) the types involved, and generate as many FromJSON/ToJSON instances as possible using the default Generic-based defaults.

I started fiddling with it, and I saw no insurmountable technical barriers, but the amount of boilerplate required is non-trivial. You'll need a boatload of Generic instances. You may also need to work with a modified copy of the ghc-lib source, because some types (e.g., TyCon) are not exported with their constructors, preventing derivation of the instances.

Overall, the Generic instances aren't so bad because most can be derived polymorphically in the phase:

Your class Character is specialized into: NPC (Non-Player Character), Player and Monster and you wonder if you'd need an interface:

• As a Monster seems to be a non-player character, it should probably inherit from NPC instead of Character
• As a human player really is not a character but just happen to be represented by a character in the game, it could be interesting to separate the responsibilities of the Player and the corresponding Character. So you'd have a simple association between the two and not an inheritance. An immediate advantage, is that the player could chose the preferred character to impersonate him/her.
• A mediator could be used to manage the interaction between the all the characters in the game. You could create a Colleague interface, and let different classes implement this interface. But if your Colleagues are necessarily all Characters, you could just rely on the superclass as you did.

More generally, an additional interface is a proven approach if you want to decouple classes. You should definitively consider them if you'd develop a game engine that is to be reused in a lot of different games: you'd then have an engine that relies only interfaces that are independent of any specific game. Each game would then pick the relevant classes to implement the interfaces. But for your specific case, it seems to be an overkill.

This being said, the main challenge you'll be confronted with is that you'll end up with deep class hierarchies that'll be difficult to evolve. This is why, the game industry prefers the entity-component-system pattern that prefer composition over inheritance. But this is a different story, and there are full books on that topic ;-)

Custom constructor is not properly initialized. When call Monster vampire = new Monster("Vampire", 2000, 300, 25); no values are set, so obvious null:string and 0:numbers returns (java default initializers).

Adapt with:

A few things:

(1) You're saving all of inside of a javascript object, not an array, which means that all items are stored as a key, value pair (e.g. game_id: ''). Also, duplicate keys are not allowed.

(2) In your reducer, saveUserGames, you take the object games and it to your initial state with the following piece of code, return { ...state, ...games };. What you're doing here is essentially adding a value to your object without a key, so javascript is giving it the keys you're seeing (e.g. 0, 1, 2, etc.)

To fix your problem you can do one of the following:

(1) If you want to use an array, change your initial state to an array; however, doing so will not allow you to use key, value pairs like you currently are.

(2) I suggest making your initial state an empty object and adding any new objects in your reducer to your initial state like so: state.userGame[game_id] = [action.payload].