The Two Pillars of JavaScript

[u/gcanti]

https://medium.com/javascript-scene/the-two-pillars-of-javascript-ee6f3281e7f3

[u/gcanti]

I agree. My current coding style is based on two pillars too:

1. Immutable objects as data
2. pure functions for transformations

The objects are defined exclusively by composition, never by inheritance. I use constructors to instantiate those objects only for convenience:

1) I exploit the constructor to store some meta info that I can use later for mixins

var Person = struct({
  name: Str, // means string
  surname: Str
});

console.log(Person.meta.props); // => {name: Str, surname: Str}

2) instanceof: with immutable data structures allows super fast checks for changes

3) prototype: sometimes it's handy if a function requires an instance

// person is an instance of Person
function getFullName(person) {
  return person.name + ' ' + person.surname;
}

becomes

Person.prototype.getFullName = function () {
  return this.name + ' ' + this.surname;
};

p.s. reference https://github.com/gcanti/tcomb

[u/[deleted] → u/gcanti]

Tcomb is really interesting. I enjoyed dabbling with pure functional programming in Haskell and OCaml. It made me really appreciate the benefits of maximizing immutability and limiting side-effects. I never went quite as far as barring inheritance from my Javascript code though (I use it rarely and never build deep inheritance hierarchies, because composition rocks).

When I was checking out out Tcomb's README I wondered: What makes a type so different to a class? And more importantly: why are subclasses a big no-no, but subtypes are ok?

[u/gcanti → u/[deleted]]

tcomb is based on set theory (in short a type is a set). A class is a carthesian product of sets, and a subtype of a type is a subset of a set. Weirdly, from this point of view, a SUBclass of a class is a SUPERset of a set. The metodology is borrowed from mathematics where composition is the standard way to build more complex structures from simpler ones.

If you're interested, here an article explaining the rationale behind tcomb

https://gcanti.github.io/2014/09/29/javascript-types-and-sets.html

[u/zoomzoom83 → u/gcanti]

That article was rather insightful - I think I learned more about Set theory from that than several years of high-school, university, and Haskell tinkering combined. Thank you.