Feature suggestion: expose a way to unsubscribe in subscribe callback (via this)

[dmail]

Hi,

I'd like to suggest a small ergonomic improvement to Signal.prototype.subscribe.

Currently, subscribe calls fn(value) with no this context. This means you can cause a ReferenceError when the condition is already true on the first (immediate) call:

const valueSignal = signal(true);
const unsubscribe = valueSignal.subscribe((value) => {
  if (value === true) {
    unsubscribe(); // ReferenceError — unsubscribe not assigned yet
  }
});

This is actually a sign my code should be checking before subscribing in the first place:

const valueSignal = signal(true);

if (valueSignal.peek() !== true) {
  const unsubscribe = valueSignal.subscribe((value) => {
    if (value === true) {
      unsubscribe();
    }
  });
}

But with effect() I'd expect to write this more naturally — yet it doesn't work either today. I noticed the TypeScript signature already anticipates it:

type EffectFn = (this: { dispose: () => void }) => void | (() => void)

But the implementation doesn't deliver on it because _callback calls this._fn() without binding.

Proposal: Two small changes:

1. In Effect.prototype._callback, call this._fn.call(this) instead of this._fn():

Effect.prototype._callback = function () {
  const finish = this._start();
  try {
    if (this._flags & DISPOSED) return;
    if (this._fn === undefined) return;
    const cleanup = this._fn.call(this); // bind Effect as `this`
    if (typeof cleanup === "function") {
      this._cleanup = cleanup;
    }
  } finally {
    finish();
  }
};

2. In Signal.prototype.subscribe, use a regular function and capture the signal reference explicitly so this refers to the Effect:

Signal.prototype.subscribe = function (fn) {
  const signal = this;
  return effect(
    function () {
      const value = signal.value;
      const prevContext = evalContext;
      evalContext = undefined;
      try {
        fn.call(this, value); // this = Effect instance
      } finally {
        evalContext = prevContext;
      }
    },
    { name: "sub" }
  );
};

This would allow both effect and subscribe to self-dispose cleanly:

effect(function () {
  const value = valueSignal.value;
  if (value === true) {
    this.dispose();
  }
});

valueSignal.subscribe(function (value) {
  if (value === true) {
    this.dispose();
  }
});