res1, err := NewResource1()
if err != nil {
    return nil, err
}
res2, err := NewResource2(res1)
if err != nil {
  res1.Close()
  return nil, err
}
res3, err := NewResource3(res2)
if err != nil {
  res2.Close()
  res1.Close()
  return nil, err
}
v, err := res3.DoSomething()
if err != nil {
  res3.Close()
  res2.Close()
  res1.Close()
  return nil, err
}
res3.Close()
res2.Close()
res1.Close()
return v, nil

res1, err := NewResource1()
if err != nil {
  return nil, err
}
defer res1.Close()
res2, err := NewResource2(res1)
if err != nil {
  return nil, err
}
defer res2.Close()
res3, err := NewResource3(res2)
if err != nil {
  return nil, err
}
defer res3.Close()
return res3.DoSomething()

res, cleanup, err := NewResource()
if err != nil {
  return err
}
// Если не вызвать cleanup, то программа просто не скомпилируется.
if err := res.DoSomething(); err != nil {
  return err
}

func Finalize(finalizers ...func()) {
  // Вызываем финализаторы в обратном порядке.
  for i := len(finalizers) - 1; i >= 0; i-- {
    func() {
      defer func() {
        // Для примера проигнорируем панику так же, как любые ошибки финализации.
        // В реальном коде нужно использовать любую реализацию multierror и:
        // 1) возвращать ошибку из финализатора;
        // 2) превращать панику в ошибки.
        recover()
      }()
      finalizers[i]()
    }()
  }
}
func NewResource3() (*Resource3, func(), error) {
  var (
    finalizers []func() // Массив финализаторов внутренних ресурсов
    successful bool     // Флаг успешного создания ресурса
  )
  defer func() {
    // Если флаг успешного создания ресурса не поднят,
    // освобождаем все созданные в процессе внутренние ресурсы -
    // работа конструктора завершилась ошибкой и больше некому.
    if !successfull {
      Finalize(finalizers...)
    }
  }()
  res1, fin1, err := NewResource1()
  if err != nil {
    return nil, nil, err
  }
  finalizers = append(finalizers, fin1)
  res2, fin2, err := NewResource2(res1)
  if err != nil {
    return nil, nil, err
  }
  finalizers = append(finalizers, fin2)
  res3 := &Resource3{
    resource2: res2,
  }
  fin3 := func() {
    Finalize(finalizers...)
  }
  // Поднимаем флаг успешного создания ресурса и возвращаем результат.
  // С этого момента внутренние ресурсы будут освобождены только
  // при вызове финализатора внешним кодом.
  successful = true
  return res3, fin3, nil
}

func NewResource(...) (res Resource, dtor kdone.Destructor, err error) {
  defer kerror.Catch(&err)               // Превращаем панику в ошибку
                                         // с помощью KError.
                                         // Можно опустить этот обработчик.
  reaper := kdone.NewReaper()            // Создаём reaper.
  defer reaper.MustFinalize()            // Финализируем внутренние ресурсы
                                         // в случае ошибки.
  // ... reaper.MustAssume(dtor) ...     // Возлагаем на reaper ответственность
                                         // за вызов деструктора внутреннего
                                         // ресурса.
  return res, reaper.MustRelease(), nil  // Освобождаем reaper от ответственности
                                         // за вызов деструкторов и передаём её
                                         // вышестоящему коду.
}