Looking into Zig(ayende.com)

    // must use named returns so you can observe the returned error
    func yourfunc() (result thingtype, err error) {
      thing := constructIt()

      defer func(){
        if err != nil {
          thing.Close()
        }
      }()

      // use thing to do a few things that could error
      err = thing.setup()
      if err != nil {
        return nil, err
      }
      other, err := thing.other()
      if err != nil {
        return // naked returns are fine too
      }
      // etc
    
      return
    }

    func yourfunc() thingtype {
      thing := constructIt()
      errdefer thing.Close()

      // use thing to do a few things that could error
      try thing.setup()
      other = try thing.other()
    
      return thing
    }

  template<typename T>
  concept HasId =
  requires (T a) {
      T::kId; // "the expression T::kId is a valid expression that will compile"
  };

  // A and B are expected to be structs, where each has an associated integer constant kId and a field "int value".
  template <HasId A, HasId B>
  int min_id(const A a, const B b) {
    if (A::kId < B::kIs) {
        return a.value;
    } else {
        return b.value;
    }
  }

  struct A0 {
    static constexpr int kId = 1;
    int value;
  };

  struct A1 {
    static constexpr int kId = 2;
    int value;
  };

  // etc.

  struct A180 {
    static constexpr int kId = 2;
    int value;
  };

  int main() {
      (void)min_id(A0(), A1());
      (void)min_id(A1(), A2());
      // etc. ending with:
      (void)min_id(A179(), A180());
  }