wincompose
rust
Our great sponsors
wincompose | rust | |
---|---|---|
134 | 2674 | |
2,478 | 91,922 | |
- | 2.8% | |
6.1 | 10.0 | |
13 days ago | 3 days ago | |
C# | Rust | |
GNU General Public License v3.0 or later | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
wincompose
-
"ç" majuscule
Touche compose. Natif sous linux, et sous windows : https://github.com/samhocevar/wincompose
-
Victor Mono Typeface
Julia has made symbol input manageable and lets you define infix operators for many of the Unicode symbols that make sense for that. [1] And JuliaMono was designed to support the symbols that Julia does. [2]
I generally do quite fine with my Compose Key configuration, though (even on Windows, where I use WinCompose). [3]
[1]: https://docs.julialang.org/en/v1/manual/unicode-input/
-
Hyphens, minus, and dashes in Debian man pages
On Windows, I use http://wincompose.info/ for all my special-character needs (and use the system compose key on Linux).
-
bach - a tool for searching compose sequences
Credit to wincompose's GUI for inspiration, which provides similar functionality on Windows.
-
Writing Prettier Haskell with Unicode Syntax and Vim
Iâve previously used a nice little tool called WinCompose for exactly that. Looks like itâs still going:
-
My setup for conlanging. Vim, XeLaTex and Zathura. What do you guys use?
An essentially equivalent program for Windows is the WinCompose tool, which I used before making the switch to Linux.
- Scusate lâignoranza, ma non ci sono ancora arrivato da soloâŠ
-
GitHub Is Sued, and We May Learn Something About Creative Commons Licensing
They are available in most fonts with reasonable-or-better Unicode coverage (https://en.wikipedia.org/wiki/Unicode_subscripts_and_supersc...). 1, 2 and 3 are available in ISO-8859-1 so can sometimes be used in 8-bit-only text, but I'd use them with care in that context.
To type them easily you'll usually need composition (sometimes called chording) support. Some Linux (and other Unix) distributions still have this built in by default, though last time I used Linux for much desktop use it seemed to be fading from common availability, otherwise you'll have to hunt for another method. On Windows I use http://wincompose.info/ (here [atlgr][^][1] produces âÂčâ, for instance, in the default settings) which is useful for a number of other things (I first started using it for accented characters like ĂĄ on a UK keyboard). If you have a keyboard with programmable function keys then you could use its customisation tool to map some of them to produce the super-script (or sub-script) characters you commonly want.
-
Does anyone here speak ÂŒĂČĂĂ„ĂÄĂĂ?
Anyone on Windows needing to type accented/special characters, I recommend WinCompose.
Not a text extractor, but I use WinCompose (a Compose key implementation for Windows users). With that you can press something like Compose + 1 + 4 for ÂŒ, or Compose + O + " for Ă (Right Alt serves as Compose). (Posting this in case someone may like it as well)
rust
-
What Are Const Generics and How Are They Used in Rust?
The above Assert<{N % 2 == 1}> requires #![feature(generic_const_exprs)] and the nightly toolchain. See https://github.com/rust-lang/rust/issues/76560 for more info.
-
Algorithms for Modern Hardware
Thereâs also other reasons. For example, take binary search:
* prefetch + cmov. These should be part of the STL but languages and compilers struggle to emit the cmov properly (Rustâs been broken for 6 years: https://github.com/rust-lang/rust/issues/53823). Prefetch is an interesting one because while you do optimize the binary search in a micro benchmark, youâre potentially putting extra pressure on the cache with âgarbageâ data which means itâs a greedy optimization that might hurt surrounding code. Probably should have separate implementations as binary search isnât necessarily always in the hot path.
* Eytzinger layout has additional limitations that are often not discussed when pointing out âhey this is fasterâ. Adding elements is non-trivial since you first have to add + sort (as you would for binary search) and then rebuild a new parallel eytzinger layout from scratch (i.e. youâd have it be an index of pointers rather than the values themselves which adds memory overhead + indirection for the comparisons). You canât find the âinsertionâ position for non-existent elements which means it canât be used for std::lower_bound (i.e. if the element doesnât exist, you just get None back instead of Err(position where it can be slotted in to maintain order).
Basically, optimizations can sometimes rely on changing the problem domain so that you can trade off features of the algorithm against the runtime. These kinds of algorithms can be a bad fit for a standard library which aims to be a toolbox of âgood enoughâ algorithms and data structures for problems that appear very very frequently. Or they could be part of the standard library toolkit just under a different name but you also have to balance that against maintenance concerns.
- Rust: Actix-web and Daily Logging
-
Groovy đ· Cheat Sheet - 01 Say "Hello" from Groovy
But that said, - and again I might be a bit biased - Groovy is too slow for me! I compared it to Rust in this LinkedIn post and it was waaaaay slow. Keep in mind that subjectively comparing programming languages might be a tricky business. But at the end, it will be up to your use case/project to prefer a language over the other.
-
Top Paying Programming Technologies 2024
13. Rust - $87,012
-
Dada, an Experiement by the Creators of Rust
Yes, actually.
https://github.com/rust-lang/rust/blob/d0ea1d767925d53b2230e...
Limited to the rust codebase itself, but I'm sure the developers would force it on everyone else if they thought they could get away with it.
-
7 Programming Languages Every Cloud Engineer Should Know in 2024!
Rust is gaining momentum in the cloud computing domain due to its emphasis on safety, speed, and concurrency without a garbage collector. These features make Rust an appealing choice for cloud engineers looking to develop high-performance, secure, and reliable cloud services and infrastructure. Rust's memory safety guarantees and efficient compilation to machine code position it as an ideal language for system-level and embedded applications in cloud environments, where performance and security are paramount.
-
Borrow Checking Without Lifetimes
> I'm not sure what's neutered about Rust's current plans for generators
They're neutered because they can't suspend and transfer control to a function other than the one that called them ("Note also that "coroutines" here are really "semicoroutines" since they can only yield back to their caller." https://lang-team.rust-lang.org/design_notes/general_corouti...) and you can't pass values into resume and get them out from the yield statement in the coroutine (https://github.com/rust-lang/rust/issues/43122#issuecomment-...).
> and they aren't separate from async, they're the foundation that async desugars to.
Yeah I just looked it up again and I don't know why I had it in my head that they were separate, you're correct, they are the same thing under the hood, so honestly that eliminates my biggest problem with them.
> 'm also not sure what your objection is to Polonius, which, so far, is still just a strictly more permissive version of the borrow checker, with nothing new to learn on the user end.
The entire model is different under the hood, though, since it switches from lifetimes+borrows to loans, and so in order to fully understand its behavior the user really would have to change their mental model, and as I said above I'm a huge fan of the lifetimes model and less so of the loan model. I just feel like it's much more natural to treat the ownership of a memory object and therefore amount of time in your code that object lives as the fixed point, and borrows as wrong for outliving what they refer to, then to treat borrows as the fixed point, and objects as wrong for going out of scope and being dropped before the borrow ends, because the fundamental memory management model of Rust is single ownership of objects, moves, and scope based RAII via Drop, so the lifetime of an object kind of is the more basic building block of the memory model, with borrows sort of conceptually orbiting around that and naturally being adjusted to fit that, with the checker being a way to force you to adhere to that. The loan based way of thinking would make more sense for an ARC-based language where references actually are more basic because objects really do only live for as long as there are references to them.
> you can't pass values into resume and get them out from the yield statement in the coroutine
I think that the linked comment is out of date, and that this is supported now (hard to tell because it hasn't been close enough to stabilization to be properly documented): https://github.com/rust-lang/rust/pull/68524
As for Polonius changing the underlying mental model, I think this is a natural progression. Rust 1.0 tried to present a simple lexical model of borrowing, and then enough people complained that it has long since replaced the simple model with non-lexical lifetimes in order to trade simplicity for "do what I mean". And since it's not allowed to break any old code, if you want to continue treating borrowing like it has the previous model then that shouldn't present any difficulties.
-
Why do we need for an Undefined Behavior Annex to C++
I don't see where those methods are getting called from a Unix signal handler but the code is complex enough that it's easy to miss, especially perusing through github instead of vscode.
AFAICT those methods are called from `guard::current`. In turn, `guard::current` is used to initialize TLS data when a thread is spawned before a signal is generated (& right after the signal handler is installed): https://github.com/rust-lang/rust/blob/26907374b9478d84d766a...
It doesn't look like there's any UB behavior being relied upon but I could very easily be misreading. If I missed it, please give me some more pointers cause this should be a github issue if it's the case - calling non async-safe methods from a signal handler typically can result in a deadlock which is no bueno.
What are some alternatives?
carbon-lang - Carbon Language's main repository: documents, design, implementation, and related tools. (NOTE: Carbon Language is experimental; see README)
zig - General-purpose programming language and toolchain for maintaining robust, optimal, and reusable software.
Nim - Nim is a statically typed compiled systems programming language. It combines successful concepts from mature languages like Python, Ada and Modula. Its design focuses on efficiency, expressiveness, and elegance (in that order of priority).
Odin - Odin Programming Language
Elixir - Elixir is a dynamic, functional language for building scalable and maintainable applications
Rustup - The Rust toolchain installer
rust-analyzer - A Rust compiler front-end for IDEs [Moved to: https://github.com/rust-lang/rust-analyzer]
go - The Go programming language
mimalloc - mimalloc is a compact general purpose allocator with excellent performance.
scala - Scala 2 compiler and standard library. Bugs at https://github.com/scala/bug; Scala 3 at https://github.com/scala/scala3
spaCy - đ« Industrial-strength Natural Language Processing (NLP) in Python
widevine-l3-guesser