Pass prototype object to tagged and taggedSum

It would be nice to simply pass in an object as the final parameter.

const Point3D = daggy.tagged('Point3D', ['x', 'y', 'z'], {
  scale(n) {
    return Point3D(this.x * n, this.y * n, this.z * n)
  }
})
Point3D.toString() // 'Point3D'
const a = Point3D(1, 2, 3) // { x: 1, y: 2, z: 3 }
a.x == 1 && a.y == 2 && a.z == 3 // true
a.toString() // 'Point3D(1, 2, 3)'
Point3D.is(a) // true
const b = a.scale(2) // { x: 2, y: 4, z: 6 }
b.toString() // 'Point3D(2, 4, 6)'

const Option = daggy.taggedSum('Option', {
  Some: ['x'],
  None: [],
}, {
  map(f) {
    return this.cata({
      Some: (x) => Option.Some(f(x)),
      None: () => this,
    })
  }
})
const a = Option.Some(1) // { x: 1 }
a.toString() // 'Option.Some(1)'
Option.Some.is(a) // true
Option.is(a) // true
Option.None.is(Option.None) // true
Option.is(Option.None) // true
Option.None.toString() // 'Option.None'
Option.Some.toString() // 'Option.Some'
const b = a.map(x => x+1) // { x: 2 }
b.toString() // 'Option.Some(2)'

It would allow customizing the behavior of toString.

[gabejohnson]

The problem it’s solving is simply reduced boilerplate. I think things could be disambiguated.

const Option = daggy.taggedSum('Option', {
  of(a) {
    return Option.Some(a);
  }
}, {
  Some: [['x'], {}, {
    map(f) {
      return Option.Some(f(x));
    }
  }],
  None: [[], {}, {
    map() {
      return this;
    }
  }],
});

But the added complexity would probably outweigh the benefits.

[safareli]

closing this for now