Hacker News Reader

Hacker News

Comment by flohofwoe | Hacker News Reader

Parent Full thread

flohofwoe

Worth looking at the hello-triangle examples for the C- and Rust-APIs:

C99 Hello Triangle:

https://github.com/gfx-rs/wgpu/blob/master/examples/hello_tr...

Rust Hello Triangle:

https://github.com/gfx-rs/wgpu/blob/master/examples/hello_tr...

Both look very neat and tidy IMHO.

The C99 version could also use nested designated initialization right in the function call, this would make it look very similar to the Rust version, e.g.:

    WGPUBlendStateId blend_state_0 = wgpu_device_create_blend_state(
        device,
        &(WGPUBlendDescriptor) {
            .blend_enabled = false,
            .write_mask = WGPUColorWriteFlags_ALL,
            .color = {
                .src_factor = WGPUBlendFactor_One,
                .dst_factor = WGPUBlendFactor_Zero,
                .operation = WGPUBlendOperation_Add,
            },
            .alpha = {
                .src_factor = WGPUBlendFactor_One,
                .dst_factor = WGPUBlendFactor_Zero,
                .operation = WGPUBlendOperation_Add,
            }
        });

But of course that's a matter of taste :)

View on HN

I was about to say "yeah, you should look at flohofwoe's Sokol stuff for an example of nested init", then saw the username :)

For me, the C version looks actually cleaner than the Rust one.

Is this because you’re not as familiar with Rust as you are with C?

Rust has more syntactic elements than the C, in this code that’s clear, but cleanliness can mean different things.

Rust has a module system, so no global namespace issues, but does require all of the :: separators.

Rust has cleaner ways of dealing with cross platform compile time switches, thus we don’t see the CPP macros for different platform targets.

To me, those are cleaner, but I’m familiar with Rust and C, which is why I asked.

I think the Rust style that uses ”constructorless” struct initialization really makes the code too verbose in this case. It’s nice and explicit in a way but having to say e.g

    entrypoint: ”main”

as the argument for a shader program seems like it could be turned into a default.

Convention over configuration isn’t always the answer, but some times at least it can help reduce clutter.

In the future the api will perhaps have builders as an option.

I'm not sure if the builder pattern is better than designated initialization... AFAIK in Rust you can get something similar (fill up missing members with their default values) with ..Default::default(), like:

    &BlaDesc {
        bla: 1,
        blub: 2,
        ..Default::default()
    }

One annoyance of this is that you can't require fields to be explicitly provided anymore.

With the builder pattern, you can do so: require them in the builder constructor.

I'm genuinely interested in why you find it cleaner, please elaborate?

Three thoughts:

- The types help, seeing "WGPUSwapChainId" tells me exactly what sort of object is returned (a reference to some object held elsewhere), we don't get this in Rust because of type inference.

- Rust doesn't help in this example because it's just a bunch of API calls... so it's a more complex language for nothing. Obviously this doesn't generalize.

- The event handling is much simpler in the C code, this also doesn't generalize.

> we don't get this in Rust because of type inference

Might be worth mentioning that (AFAIK) type inference is entirely optional in Rust. If you prefer to write explicit types on your decls that's fine. (I suspect there are pathological cases where the type is impractical to write, but you'd have been screwed then anyway.)

This won't help you when reading other people's code, obviously.

> seeing "WGPUSwapChainId" tells me exactly what sort of object is returned (a reference to some object held elsewhere)

Check out RLS (the rust language server) to get intellisense like this working in your favorite editor.

I think that in reviewing code this is definitely something where languages with type inference lose clarity; Rust is even worse because of the Deref/Into idioms.

I think the solution is for diff viewers incl. those on the web to support something like intellisense, but obviously we are a very long way away from that.

You could have the compiler produce a fully explicit version (I'm not sure if Rust can do that out of the box at the moment)

~~It can't.~~ See below, it can!

I tend to find, personally, that this kind of thing doesn't interfere strongly with reviewing. I think this is because I have an extensive background in dynamically typed languages and ones with strong inference like Rust, so I'm more used to it, whereas people who don't come from said backgrounds prefer more explicitness. YMMV of course!

It can.

-Z unstable-options -Zunpretty=hir,typed

    // source
    pub fn square(num: i32) -> i32 {
        num * num
    }

    // expanded
    use ::std::prelude::v1::*;
    extern crate std;
    pub fn square(num: i32)
     -> i32 ({ ((num as i32) * (num as i32) as i32) } as i32)

You can try on https://rust.godbolt.org/

Oh dang! That's very cool, thank you!

I don’t think it’s just “strong” inference that’s the problem; I find I have an easier time reading ML because the inference somehow feels more obvious. After thinking about it some more, I think it really is deref coercion that is the gotcha, especially with function chaining.

By "strong" I really mean "type inference" over "type deduction", to be clear. But yeah, I could see that.

>> very neat and tidy

I couldn't disagree more.

It's definitely cleaner and less code compared to a Vulkan "hello triangle".

Compared to D3D11 or Metal? Arguable.

Compared to GL? For a simple triangle also arguable, but GL gets messier much quicker for complex cases.

Reply on news.ycombinator.com