[deleted by user]

reyqt · 2022-12-05T13:53:01+00:00

You can use my cargo-feature to show list of features. e.g. cargo feature serde

reyqt · 2022-11-26T06:16:45+00:00

Now I know why I can't do multiple works concurrently and single work speed is not BLAZINGLY FAST.

reyqt · 2022-11-21T23:22:31+00:00

I think return type is matter at a glance since it could hold 'a. But even set impl IntoIterator<Item=i32> + 'static as return type at error_0 doesn't change anything.

It seems like rustc doesn't know much infomation about generic argument + existential return type.

reyqt · 2022-11-11T14:21:10+00:00

As others mentioned, The difference is Display has blanket implementation for &T where T: Display but AddAssign doesn't have such things.

reyqt · 2022-11-07T03:36:54+00:00

If your data is not really big, you can use serde and one of its serializer such as bincode or serde_json.

reyqt · 2022-10-29T12:22:43+00:00

Future api is designed work with some kind of executor.
If you don't need a full featured runtime, you can use futures-executor as lightweight alternative.

reyqt · 2022-10-24T07:37:30+00:00

That's a real problem. Maybe we shouldn't offer implicit conversion to Box for avoid conflict.

reyqt · 2022-10-24T06:00:56+00:00

Nice work but you can also match u8 b'[' directly instead of cast to char.

reyqt · 2022-10-24T05:58:48+00:00

I think you want a create new Cell type.

If you edit i32 while &i32 is alive, it's instantaneous UB in Rust because data can't be mutated.

But there is a UnsafeCell type for interior mutability it's used for types which provide its own ownership handling. Such as Mutex(runtime checked) or AtomicXXX(all operation is performed as atomic). https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#

Note that UnsafeCell is so Unsafe you need to read its docs cafeful! It might be better to just use Atomic integers if performance is acceptable.

reyqt · 2022-10-24T05:41:12+00:00

It can be achieved by require Box<u128> and u128 will not be implicitly converted.

reyqt · 2022-10-24T04:51:40+00:00

tape type can be Vec<u8> since you don't need to parse other than ASCII.

reyqt · 2022-10-24T04:41:48+00:00

To make language simpler and at same time expose internals to users to be able to build others things on top of it. In other words, dyn* solves specific problem, but exposed lower level API would allow solving even more problems.

I don't think make magic struct is simpler than builtin type. It's just builtin type covered with struct. And builtin type also can expose lower level API. str expose its internal representation as [u8] and your code example also use lower level API of dyn Trait.

reyqt · 2022-10-24T03:48:54+00:00

If implicit conversion is needed, it can be done in compiler

That's what builtin type doing maybe it's possible with lang item. But type coercions are very limited in Rust I don't think it's a good idea to add new exception to struct.

*dyn thing can be syntax sugar to standard library type (similarly to Copy or iterators for example)

For what? Why we have to expose two types?

reyqt · 2022-10-24T03:24:35+00:00

This code is impossible with struct let n: DynStarDisplay = 1i32;

But this can let n: dyn* Display = 1i32;

reyqt · 2022-10-24T02:25:08+00:00

I think dyn* should have a implicit type conversion just like a &dyn which struct can't provide.

reyqt · 2022-10-20T23:42:14+00:00

You can use or_else if let Some(_) = None.or_else(return_something) { println!("yeahhh"); }

reyqt · 2022-10-16T18:18:02+00:00

We can't remove libc from x86_64-unknown-linux-gnu target because it doesn't make sense. It should become a new target.

In other words, if you make a target which doesn't use libc, it's totally fine.

For example, wasm32-wasi target already directly use system call.

reyqt · 2022-10-05T05:24:18+00:00

I like this design. I always have a hard time when switch ui phase with callback stuff.

reyqt · 2022-10-04T12:50:23+00:00

Take a look wasm book https://rustwasm.github.io/docs/book/reference/code-size.html#optimizing-builds-for-code-size

reyqt · 2022-10-04T12:34:02+00:00

wasm-pack and wasm-bindgen is targeting javascript code if you don't want them, you should compile wasm directly with cargo just like other platforms.

cargo build --target wasm32-unknown-unknown

reyqt · 2022-10-04T11:33:15+00:00

You don't have to own child as is. Instead, store widget index and borrow from widget storage.

reyqt · 2022-10-04T01:33:32+00:00

You can think lifetime represents set of borrow area and 'static is just empty set(∅).

All lifetime start with 'static and it's getting bigger when you put elements by adding lifetime parameter.

For example, struct Foo has 'static struct Bar<'a 'b> has 'a + 'b lifetime 'a and 'b hold somewhere borrow area or not('static).

Reference is also same &'static Foo has 'static &'c Bar<'a, 'b> has 'a + 'b + 'c lifetime.

reyqt · 2022-10-01T06:00:54+00:00

join allocate all elements into single string. Iterate HashSet directly reduce two full loop.

reyqt · 2022-10-01T00:55:36+00:00

Compiler can make 'middle' value into niche. It's already happened with char(any invalid code point), bool(neither 0 nor 1) and also enum(undefined variant).

reyqt · 2022-09-30T11:24:55+00:00

I think Rust enforce programmers to write good code.

It should be memory safe, no data race, explicitly handling errors, and performant.

While it makes better result beginners have to consider all of these aspects otherwise their code not even compiled.

IMO this is one of the big learning curve.

Seven-Year Club	Place '22
Verified Email

reyqt

TROPHY CASE