entry | Qt binding for JavaScript/TypeScript Showcase example

Judging from this issue: CSS import breaks webpack 5 compilation
I believe this is an issue with Semantic-UI-React and Webpack 5 (which is used by Create-React-App).

The final answer in that issue is a suggestion to switch to Fomantic-UI 😅

This should be reported into the upstream repo: https://github.com/Semantic-Org/Semantic-UI. The problem is that it's dead 🙄 Reasonable solution is to switch to https://github.com/fomantic/Fomantic-UI.

https://github.com/Semantic-Org/Semantic-UI-React/issues/4287#issuecomment-935897619

#[main] is an old, unstable attribute that was mostly removed from the language in 1.53.0. However, the removal missed one line, with the result you see: the attribute had no effect, but it could be used on stable Rust without an error, and conflicted with imported attributes named main. This was a bug, not intended behaviour. It has been fixed as of nightly-2022-02-10 and 1.59.0-beta.8. Your example with use tokio::main; and #[main] can now run without error.

Before it was removed, the unstable #[main] was used to specify the entry point of a program. Alex Crichton described the behaviour of it and related attributes in a 2016 comment on GitHub:

Ah yes, we've got three entry points. I.. think this is how they work:

• First, #[start], the receiver of int argc and char **argv. This is literally the symbol main (or what is called by that symbol generated in the compiler).
• Next, there's #[lang = "start"]. If no #[start] exists in the crate graph then the compiler generates a main function that calls this. This functions receives argc/argv along with a third argument that is a function pointer to the #[main] function (defined below). Importantly, #[lang = "start"] can be located in a library. For example it's located in the standard library (libstd).
• Finally, #[main], the main function for an executable. This is passed no arguments and is called by #[lang = "start"] (if it decides to). The standard library uses this to initialize itself and then call the Rust program. This, if not specified, defaults to fn main at the top.

So to answer your question, this isn't the same as #[start]. To answer your other (possibly not yet asked) question, yes we have too many entry points.

If you are using NLog the easiest way to log in you startup.cs is to add private property.

This is currently a known bug in Rakudo. The intended behavior is for has to support list assignment, which would make syntax very much like that shown in the question work.

I am not sure if the supported syntax will be:

Navigation routes are equivalent to urls. Generally you're supposed to pass something like id there.

When you need to pass a url inside another url, you need to encode it:

In short, yes, it's legal.

The concept of an identifier is a syntactic one: when parsing Raku, the parser needs to classify the things it sees, and the identifier rules indicate what sequences of characters should be recognized as an identifier.

By contrast, stashes, method tables, and lexical scopes are ultimately hash-like data structures: they map string keys into stored values. Just as there's no limit on what keys one can put into a hash, there's not one here either. Given meta-objects can be user-defined, it's unclear one could reliably enforce limits, even if it was considered desirable.

The ::(...) indirect name syntax in declarative contexts comes only with the restriction that what you put there must be a compile-time constant. So far as parsing goes, what comes inside of the parentheses is an expression. The compiler wants to get a string that it can use to install a symbol somewhere; with identifiers it comes directly from the program source text, and with indirect name syntax by evaluating the constant that is found there. In either case, it's used to make an entry in a symbol table, and those don't care, and thus between the two, you have a way to get symbol table entries that don't have identifier syntax.

Does it make sense to iterate through layers like this and keep adding files (to some target, does not matter for now) and deleting the added files in case they are found with a .wh prefix? Or am I totally off and is there a much better way?

There is a much better way, you do not want to reimplement (with worse performances) what Docker already does. The main reason is that Docker uses a mount filesystem called overlay2 by default that allows the creation of images and containers leveraging the concepts of a Union Filesystem: lowerdir, upperdir, workdir and mergeddir.

What you might not expect is that you can reproduce an image or container building process using the mount command available in almost any Unix-like machine.

I found a very interesting article that explains how the overlay storage system works and how Docker internally uses it, I highly recommend the reading.

Actually, if you have read the article, the solution is there: you can mount the image data you have by docker inspecting its LowerDir, UpperDir, WorkDir and by setting the merged dir to a custom path. To make the process simpler, you can run a script like:

This is what I think, You are passing Messages in ChatSection and that means that when Messages get updated ChatSection will rerender and all its children will rerender too.

So here is my idea remove Messages from ChatSection and only add it in Chat.

You already using useChatService in Chat so adding Messages there should be better.

Try this and gets back too us if it working.

If still not as you like it to be there is also other way we could fix it.

But you have to create a working example for us so we could have a look and make small changes.

Contrary to common belief Haskell is quite friendly with respect to problems like that. The real issue is that the array library that comes with GHC is total garbage. Another big problem is that everyone is taught in Haskell to use lists where arrays should be used instead, which is usually one of the major sources of slow code and memory bloated programs. So, it is not surprising that GC takes a long time, it is because there is way too much stuff being allocation. Here is a run on the supplied input for the solution provided below: