3 ms·

I deeply miss C++ templates in most other languages, excepting fully dynamic languages, and D. Have you tried Zig? Comptime templating it one of its selling po

• moth-fuzz 5y ago
  I loooove Zig - my only gripe with Zig is that it feels somewhat arcane at times, and the documentation was borderline absent last I checked. I follow Andrew Kelley on twitter and am fascinated by his exploits. Crystal has a similar macro system that I enjoy, from what I've used of it. Rust macros are similarly satisfying in what you can accomplish with them, but the implementation is so immeasurably difficult, it's almost never worth it to bother, from a general design standpoint. As far as C replacements go, Zig has my vote for the most approachable but also the most well thought-out. I couldn't sing its praises enough.
• lenkite 5y ago
  Would love Zig if it had RAII.
  • AndyKelley 5y ago
    RAII works fine in Zig
    • lenkite 5y ago
      No it doesn't. https://github.com/ziglang/zig/issues/782 https://github.com/ziglang/zig/issues/782
      • AndyKelley 5y ago
        show me a raii code example in C++ and I'll show you the zig equivalent
        • lenkite 5y ago
          Note that in `good` below, one can have many such lock guards: lk1, lk2, etc without any explicit lock release expression in the body of the function. std::mutex m; void good() { std::lock_guard<std::mutex> lk(m); // RAII class: mutex acquisition is initialization f(); // if f() throws an exception, the mutex is released if(!everything_ok()) return; // early return, the mutex is released } // if good() returns normally, the mutex is released
          • AndyKelley 5y ago
            var m: std.Thread.Mutex = .{}; fn good() !void { m.lock(); defer m.unlock(); try f(); if (!everything_ok()) return; } It's still the RAII pattern. The explicit call to deinitialization does not disqualify it. I can overcomplicate it with a LockGuard class too: const LockGuard = struct { mutex: *std.Thread.Mutex, fn init(mutex: *std.Thread.Mutex) !LockGuard { mutex.lock(); return .{ .mutex = mutex, }; } fn deinit(lg: *LockGuard) void { lg.mutex.unlock(); } }; fn good() !void { var lk = try LockGuard.init(&m); defer lk.deinit(); try f(); if (!everything_ok()) return; } In this case it demonstrates an improvement over C++, which is what happens if an error happens during a constructor. In C++ throwing an exception in a constructor is essentially UB; in zig it's a regular function call just like anything else.
            • lenkite 5y ago
              Thanks for the informative snippet, but explicit expressions involving defer is not what RAII means. In RAII resource is automatically tied to object lifetime. https://en.wikipedia.org/wiki/Resource_acquisition_is_initialization https://en.wikipedia.org/wiki/Resource_acquisition_is_initia... Regarding errors in a C++ constructor: https://isocpp.org/wiki/faq/exceptions#ctors-can-throw https://isocpp.org/wiki/faq/exceptions#ctors-can-throw