woof | Datalog interpreter implementing the Well-Founded semantics | Interpreter library

After you load your stylesheet you are loading a third-party stylesheet from Bootstrap which probably applies its own styles to those elements.

Use the Inspector feature of your web browsers developer tools to look at your h1 element and see which styles are applied to it, in which order, and where they come from.

Remember that styles are applied in the cascade order with rulesets of higher specificity overriding those of lower specificity and when specificity is equal later rulesets overriding earlier ones.

If specifity is equal then simply moving the to your stylesheet so it is added after Bootstrap's will resolve your problem.

You have not only defined the font size (3rem) but you have also specified the line height (1.7rem). Your specified line height is smaller than the 'natural' line height of the 3rem font.

If you don't specify a line height then the default will be selected and characters won't overlap. line-height is the whole height, not just the space between lines.

In the first snippet you have a single metatable for all instances of your class while in the second snippet each instance has its own metatable.

Why have an extra table for every instance if one does the job? Also you have the problem that you cannot change the behaviour of a class without modifying each instances metatable.

Let's say you wanted to change what happens if you convert a Dog instance to a string.

In the first snippet you just implement Dog.__tostring and you're done. In the second snippet you would have to get the metatable of each instance first.

At the end it's a question of personal preference.

In both your snippets you're creating a global instance. You need to make newObj local!

No need to use a regex when Python's standard in operator will do the job, IMO:

ClassType should be declared as

That's because the body of a JavaScript class executes in strict mode. This mode, as its name suggests, is a bit more restrictive. Among the features of this execution mode, this doesn't refer to window inside a function that is being called as a bare function, it returns undefined instead.

While what you wrote is not wrong, the realty is simpler (IMO).

If you try to access a property on an object, the engine will first check whether the object itself (in your case wyatt) has that property. If not, it will look at the object's prototype (which is also an object) and repeat those steps until it finds the property or until an object doesn't have a prototype anymore. That's really all that is to it.

An object can only have one prototype. You can think of it as it being an "internal" property that is assigned a reference to another object.

I guess the next question is, how is a prototype assigned to an object? You already know one way: the extends keyword.
Maybe the point that you are missing is that the default prototype of an object is Object.prototype:

Of course that you can't nest shortcodes one in another, but what you can do is embed a shortcode in a another shortcode as follows:

&Animal is short for &dyn Animal. dyn Animal is a trait object type, and it only exists for a given trait if the trait is object-safe. Traits with associated types are not object-safe, because dyn Animal cannot implement Animal without specifying the associated type Food.¹

This is an inherent limitation of runtime polymorphism (trait objects): you don't know the concrete type, so you can't know its associated type.²

If you want to create a vector of things you can call .talk() on, it's easy enough to create a trait just for that (playground):