Methods are implemented as multi-methods, which allow a form of
ad-hoc polymorphism. Duck typing is another example of ad-hoc
polymorphism, but only allows a single implementation at a time, via
prototype mutation.

A method instance is a product of a name, a predicate and an
implementation:

var env =fantasy.environment()

.method(

// Name

'negate',

// Predicate

function(n){

returntypeof n =='number';

},

// Implementation

function(n){

return-n;

}

);

env.negate(100)==-100;

We can now override the environment with Some more implementations:

var env2 = env

.method(

'negate',

function(b){

returntypeof b =='boolean';

},

function(b){

return!b;

}

);

env2.negate(100)==-100;

env2.negate(true)==false;

Environments are immutable; references to env won't see an
implementation for boolean. The env2 environment could have
overwritten the implementation for number and code relying on env
would still work.

Properties can be accessed without dispatching on arguments. They
can almost be thought of as methods with predicates that always
return true: