const x = Z.call.fac((e: Error) => {
  console.log(e);
})

// Impossible
run(x(effectResolvesToAnError()))

// Should bubble up effect to root as if the result of an effect
run(x(new Error()))

const p_ = Symbol();
const p = Z._<string | number | boolean>()(p_);

const root = Z.call(p, (pr) => {
  return pr;
});

const result = Z.runtime()(root, (_) => _(p.a("HELLO")));

const n_ = Symbol();
const n = Z._<number>(n_);

const squared = Z.call(n, (n) => {
  return n * n;
});

const applied = squared.apply(n, 2);

const result = applied.run();

const add = Z.atomf((a: number, b: number) => {
  return a + b;
});

declare const a: number;
declare const b: Promise<number>;

const root = add(a, b);

export function metadata<Rest extends [blockHash?: Z.$<U.HexHash | undefined>]>(
  config: Config,
  ...[blockHash]: [...Rest]
) {
  return Z.call(
    rpcCall(config, "state_getMetadata", [blockHash]),
    function metadataImpl(call) {
      try {
        return M.fromPrefixedHex(call.result);
      } catch (e) {
        return e as $.CodecError;
      }
    },
  ).attachMethods({
    pallet<PalletName extends Z.$<string>>(palletName: PalletName) {
      return palletMetadata(this, palletName);
    }
  });
}

attachMethods = <Methods extends Record<PropertyKey, (...rest: any[]) => unknown>>(
  methods: Methods & ThisType<Methods & this>,
): this & Methods => {
  return {
    ...this,
    ...methods,
  };
};