Creating atoms without initial values would be useful

[akkadaska]

Currently, we need to set an initial value when defining primitive atoms. However, if the atom will always be hydrated by useHydrateAtoms, the initial value is no longer necessary.
I believe it would be very useful to have atoms that can be created without an initial value and throw an error when attempting to get their value before the first setting (such as with useHydrateAtoms).

An easy workaround is setting an arbitrary initial value like:

const someAtom = atom<number>(0); // 0 is not important and never used.

However, if the atom's value type is complex, it becomes messy to set a complex initial value that will never be used.

Another simple approach is setting null as a non-initialized value:

const someAtom = atom<SomeComplexType | null>(null);

The drawback here is that we need to write null-case logic wherever we use this atom because the atom's value type becomes nullable.

This discussion #581 gave me an idea using atomFamily, but it requires passing an initial value wherever we use the atom.

To reiterate, for atoms that should be hydrated, it would be very useful if they could be initialized without an initial value, and if read before initial writing, they would throw an error.
I would like to see this feature officially supported.

Appendix: my workaround code

import { atom } from 'jotai';

const INITIAL_VALUE_NON_PRIMITIVE = {} as const;
type InitialValueNonPrimitive = typeof INITIAL_VALUE_NON_PRIMITIVE;

/**
 * Create an atom without initial value that throws an error if read before initialization.
 * @returns An atom that throws an error if read before initialization.
 */
export const atomWithNoInitialValue = <Value>() => {
  const baseAtom = atom<Value | InitialValueNonPrimitive>(
    INITIAL_VALUE_NON_PRIMITIVE,
  );

  return atom<Value, [newValue: Value], void>(
    (get) => {
      const value = get(baseAtom);
      if (value === INITIAL_VALUE_NON_PRIMITIVE) {
        throw new Error(
          'atomWithNoInitialValue was read before initialization',
        );
      }
      return value as Value;
    },
    (_get, set, newValue) => {
      set(baseAtom, newValue);
    },
  );
};

[dai-shi]

Your workaround seems good. I would use Symbol() instead of {}.

We have atomWithPending (in jotai-suspense, but it can be defined pretty easily.)
But, I'm not sure if it works with useHydrateAtoms.

[akkadaska]

Thank you for your quick response! I really appreciate your feedback.
I understand now that using Symbol() would be more appropriate than {} in my workaround. That's a great suggestion.
Regarding atomWithPending, I've actually tested it with useHydrateAtoms, and I'm pleased to report that it works well for my use case. I think I'll proceed with using atomWithPending in my project.
Thank you again for your helpful insights and for taking the time to review my idea. Your feedback has been invaluable.