Handle recursive types?

[pillowsoft]

Is there any way to handle recursive types? I.e.

import {Record, List} from 'typed-immutable';

var Node = Record({
    data: String,
    subNodes: List(Node)
});

One can't do the above, as Node is not defined yet, when defining subNodes. Is there a way to accomplish this now, or do you have plans for this capability?

One possibility would be to add a constant, say "CurrentType", that would tell Record to use it's type for that member when creating new records. I.e.:

import {Record, List, CurrentType} from 'typed-immutable';
var Node = Record({
    data: String,
    subNodes: List(CurrentType)
});

Thoughts?

[angelf]

I think it'd be best to allow the schema parameter to be a callback to the actual types.

As in..

import {Record, List} from 'typed-immutable';
var Node = Record(function() { return {
    data: String,
    subNodes: List(Node)
}})

[Gozala]

Unfortunately I am no longer able to maintain this project, I apologize. If someone wishes to step up and take leadership of this project please respond to #21

[angeloashmore]

I agree this should be doable (although I'm not sure what change are needed), but my workaround is to create a custom Typed. Since a custom Typed hides its type checking behind a function, the type checking occurs after the class/type definition.

Typed.Component = Typed('Component', value =>
  value instanceof Component ? value
                             : TypeError(`"${value}" is not a Component`))

export default class Component extends Record({
  name: String,
  components: List(Typed.Component),
  properties: List(Property)
}) {

// ...

}