Listen, download or stream New Style now!

kpreid: > > | > 3 | const NEW_STYLE: NonZeroU8 = NonZeroU8::new(10 - 10)?; > | ^^^^^^^^^^^^^^^^^^^^^^^ this expression returned `None` > The error message makes no sense. I can declare `const FOO: Option<NonZero<u32>>`, and returning `None` in its initializer is entirely valid. Why should it be treated as an error on an ad-hoc basis? Also, the error arguably becomes worse. `unwrap()`, like any panic, produces effectively a backtrace, pointing to the specific panic in code. The proposal instead lumps all errors in a single error type (`None` in case of `Option`), making it impossible to distinguish different places and causes of errors. Since traits are const unstable, we can't even use `Display` & friends to make nice-looking error types, like `anyhow` does. kpreid: > When const evaluation of `expr?` results in an `Err` (or other “residual” case) passed from `expr` to `?`, the compiler reports an error. This error should: > > * have the span of the `expr` (not the `expr?`, and especially not the whole constant expression), and > * if the value matches `Result::Err(e)`, then attempt to evaluate `format!("{e}")` (or even an entire `Error::source()` chain) and display that if it succeeds. > Again, `expr ` or `expr?`, the error span is entirely wrong. We need to know the specific place where evaluation failed, and this proposal doesn't even in principle include a mechanism to define it. Also, it seems your proposal is entirely equivalent to simple syntax sugar for `const { try { expr }.expect("error msg") }`, so why bother? kpreid: > This RFC does not extend the `?` operator to constant expression positions which are _not_ marked with the `const` keyword. For example, > > > foo::<{ bar()? }>() > > > should remain an error. That's a major downside. You are proposing to split "const blocks" into "explicit" and "implicit" ones, and the users should keep track. Not impossible, but it certainly increases the inconsistency of the language and adds edge cases. * * * The proposal also doesn't compose with `const fn`. A `const fn` can return `Option<T>/Result<T>`, and thus the bahaviour of `?` inside it should be kept consistent with the usual semantics. We also can't add ad-hoc semantics to `?` inside `const fn`, because it may be evaluated at runtime, where the semantics of `?` are already defined. This means that the RFC can only apply to top-level constant expressions, which severely restricts its usefulness and makes the inconsistency even worse (extracting a subexpression of const expression into a function significantly changes semantics). Nor would the RFC solve in any way the problem of panics in constants: const functions would still need to utilize panics as the only proper way to return a properly scoped error.

ekuber: > I wonder if expanding the `let-else` feature to `const` definitions would be a better alternative. I assume you mean something like: const Some(NEW_STYLE): NonZeroU8 = NonZeroU8::new(10 - 10) else {...}; The problem with that is that doesn’t nest at all: it can't express const FOO: Foo = foo(...)?.with_bar(...)?; unless you also add a `try` block, and it doesn't fit at all in inline `const`s which have no pattern side. It’s much more important to help with inline consts (which have a small syntactic cost already) than with named consts. kornel: > It's less clear about the intent. In non-messy code, `.unwrap()` signals that I know/trust something won't fail, but `?` is associated with possibility of runtime failures. Many readers are not so confident as this that an `unwrap()` _does_ mean that. (And in general, people have wildly different ideas about how and when `unwrap()` _should_ be used.) The purpose of this proposal is to make something which is _purely syntactically_ obviously not a run-time failure. kornel: > Perhaps there should be `NonZeroU8::const_new(2)` with the function declared in a way that makes it const-_only_ I did mention that in the alternatives section. As I see it, this has the problem that it expects library authors to think harder about serving `const` use cases, and to clutter their API with such functions, rather than allowing the use of existing fallible constructors. (To be fair, if a library author doesn’t think about that, it’s likely the type won’t end up practically const constructible at all.) kornel: > Rust needs support for more literals (ideally user-defined). In this particular example it could be something like `2_nzu8`. That does not help with data types which are not numbers. (It is true that I haven’t presented any concrete examples of such.)

I wonder if expanding the `let-else` feature to `const` definitions would be a better alternative. You can already use that today, at some verbosity cost: const NEW_STYLE: NonZeroU8 = { let Some(x) = NonZeroU8::new(10 - 10) else { panic!("`NEW_STYLE` was `0`") }; x };

Okay, i solved it… Script: func _on_Size_button_focus(SizeMenu_button: Button): # override colors var size_button = $Menus/HBoxContainer/VBoxContainer/SizeOptionButtonContainer/SizeOptionButton var new_style = StyleBoxFlat.new() new_style.bg_color = GlobalOptions.menu_canvas_color_focus size_button.add_theme_stylebox_override("normal", new_style) size_button.add_theme_stylebox_override("hover", new_style) Global Variable: `var menu_canvas_color_focus: Color = Color8(1, 46, 64, 255) # #012E40`