I do this for adding methods to record instances:

var Person = Immutable.Record({ name: '' });
Person.prototype.sayHi = function() {
  return this.name;
});

For now, you can also get an efficient structure and methods by defining your own objects with equals and hashCode like so:

function Complex(p)
{
    this.real = p.real;
    this.image = p.image;
}

Complex.prototype.equals = function(other)
{
    return this.real === other.real && this.image === other.image;
};

Complex.prototype.hashCode = function()
{
    return util.hash_int32array([
        this.real,
        this.image,
    ]);
};

Complex.prototype.magnitude = function()
{
    return Math.sqrt(this.real*this.real + this.image*this.image);
};

@copy, I'm glad you've caught onto this pattern! I haven't documented it anywhere yet, but in the next major version, I will document this as a way to define "value" objects that work in the Immutable.js ecosystem (eg, can be used as keys, and are considered values by Immutable.is())

Methods can be added to Record classes as @kentor describes. Simply add methods to the prototype. It is probably not a good idea to add them as values in the Record.

Some ES6 transpilers support extending expressions, in which case you can write:

class Complex extends Record({real:1, image:1}) {
magnitude() { return ...; }
}

For the transpilers that don't support subclassing an expression, but support an identifier, you can write:

var _Complex = Record({...})
class Complex extends _Complex {
...
}

I personally prefer just adding methods to the prototype.

So, we can add hashCode and equals like @copy describes using the way @kentor describes? This would basically work using an immutable Set to guarantee unique Record based object in the Set?

Can we return altered versions of records from Record methods? I have the following:

class MyRecord extends Record({...}) {
    updateIssues = (issues) => this.mergeDeepIn(["items"], Map(issues.map(issue => [issue.id, issue])));
}

as a method of a Record class, and when I call it, I get back something that the debugger claims is an instance of MyRecord, but there is no updateIssues() method on it anymore.

@turnerhayes

I found that declaring methods as properties like that, it works OK within the same file. But the methods do not appear when accessed outside this file.

I had luck rewriting as actual methods:

class MyRecord extends Record({...}) {
    updateIssues(issues) {
        return this.mergeDeepIn(["items"], Map(issues.map(issue => [issue.id, issue])));
    }
}