Rust is holocaust deniers.
Aside from the awful community that Rust has, it is actually a comfortable programming language to write. I find myself wishing for it when having to go back to writing Java and Python. Match Statements are very good idea; languages like Scala agree. One of my favourite features is that Match and If Statements can be used as expressions:
Code:
let result = if (x.is_empty()) {
"empty"
} else {
some_function_that_returns_a_&'static_str()
};
If you like using interfaces, then Rust would be a good choice, otherwise the retard danger-hairs that you'll meet at conventions and other places are worth skipping it in my opinion. Java, C++, and Rust all have generics. Rust and Java have explicate interfaces and bounds for generics, but Java does not allow for interface members to be constructors or static. In Rust you can guarantee that you can create an object of any type implementing an specified interface by creating trait that returns a "
Self where Self: Sized;", like this:
Code:
pub trait UniformConsturtor {
fn new(url:String) -> Self where Self:Sized;
}
In C++ you don't have explicate trait (interface) bounds because methods are supposed to serve as the interface. When creating a statically compiled interface using function you must use a template. There is no explicate way to designate methods being used in the function as part of a specific interface with templates. If you're thinking, "Wait, I'll just use a parent class with virtual member functions, too try to keep thinks organized." Ah, but then it's happening at runtime and done with type cast-ed pointers; no longer optimized during compilation. Rust does not have this problem, you can have trait bounds that will accept any implementing type at complication that will then be allowed to be optimized. Plus, Rust has explicitly named interfaces, so no more "methods that match the type signature are allowed in the template" non-sense. But you say, "Rust doesn't have pointers then?" Wrong again. Rust does have pointers and if you want a pointer to an object implementing an interface (a very common use for interfaces) then you can have a trait object to that interface, which is done by specifying
dyn Trait in the return type.
Code:
pub trait UniformConsturtor {
fn new(url:String) -> Result<Self,Box<dyn Error>> where Self:Sized;
}
Here we are creating a Self object or returning any object that implement the std::error::Error trait, as a trait object. You can also do this for your own traits, not just the built-in ones, like Error.
How do you stay Super Strait?
Simple, I really don't interact with the Rust Community at all. I find it disgusting how political they are. Though I don't think C and C++ are much better; they're just more your Eco-terroists types instead of Gender-terroists. I stay away from actually having conversations with these retards and instead just read the source and documentation in rustdoc (which will show you to a copy of the source outside of git) and git. Sometimes I'll read the mdBook sites that Rust Foundation and private developers put out. Maybe I read a blog post about a Rust project or coding style, but I don't reach out to socialize with the author. The funny thing is that as soon as Rust went hard on the tranny stuff, it probably killed the language there. No one wants to inherit the issues of gender freaks when they just want to write some source code. Rust is not a prefect language and some things like static singletons are not simple; you'll even get told not to bother from retards on StackOverflow. Competent people are getting alienated away from working on Rust because of their holocaust denial and
transphilia.
This brings me to my next point. I had an opportunity to use Rust for a project recently and decided against it. The project was to replace some old C software with new one including upgrades and improvements. I chose to go with C++ instead of Rust for a number of reasons. Mind you, this was a complete rewrite, so it wasn't a priority to try to reuse old code from the existing package this project was replacing. I when with C++ after considering the following.
- No ability to use the new project and the old project together. In case it's better to use old implementation for some reason, if Rust then that'd have to be FFI call.
- No ABI. C++ doesn't have one either, but that's easier to get around using dlopen. Rust does not have a standard ABI and Rust's std does not support dlopen sort-of interface. I read some suggestions of using WASM to get around this, but a ridiculous over complication for the protect.
- Forward usability would be a problem. Most other project that might want to use this a library would be C or C++ and not subject to being rewritten, so it would make this project an island if done in Rust.
A lot of projects that claim "written in Rust" are not implemented in rust, but are rust FFI wrappers to C and C++ packages. So you are not actually getting the advantage of using Rust, because the C and C++ stuff is complied by their respective compilers and not rustc. It seems silly to go out of your way to use Rust with FFI in the face of no advantages in complication and a difficult community to avoid if you have a problem in the future, you may end up having to maintain a dead project to keep your own dependent projects going after the trannies have chased everyone else off and kill the project.
Most Rust projects are command line utilities that don't do anything graphical (system gui libraries, if you want opengl or vulkan they do have that). All the work is either done through FFI wrapper or
std::process::Command (system command call). This actually make sense, given that Rust's strong suit is handling the logic of programming, with the statements and expressions and other niceties inspired by functional programming. But for more serious projects, it's not worth it to use Rust. A while back, I was evaluating using OpenCV from Rust and concluded that the Rust API exposed was so idiosyncratic the programmer would have to be looking at the rustdoc and cross referencing it with the C++ docs just to be able to do anything with it. So, you'd be better off just using C++ and forgetting about Rust at that point.
A lot of these criticisms may seem surprising given that Rust and Actix Framework have been given such positive reception due to it's performance as web server. Web Servers use a very well standardized (IETF) API provided by the operating system, and in Rust the Standard Library. At the end of the day it really doesn't matter how you pull data from a database, format it, write bytes to the client calling from the web server. You can use a thread pool, individual threads per request, or just load a static file per formatted into memory and copy it over the interface. It doesn't matter to the client. It only matters when there is a problem and the client can't get what it requested, so pick one way that's reliable and you're done. Not all programs are Web Servers and also don't have as well defined APIs and standards. So you end up in a situation where there is different lei-ways and constraints. For example, take having to create a GUI program that has a battery of image analysis tools: that's one library for the GUI, any number for the tools even if you make them your self you'll probably split them up that away, and maybe a base library for working with images as a concept. Could it be done in Rust, yes it's not impossible. But is it cost effective? Well, Rust can compile to most platforms, so the JVM argument goes out the window. How are you going to do the cross platform GUI; yourself implement the rust-platform FFI or get it from a tranny controlled project? That'll bite you in the future. What about the image interface, your self or another questionable library ran by the mentally ill? Other languages may require to do the same parts yourself as Rust, but are not advertising themselves as the catch-all for paedophiles and axe murderers. Even if all development costs were equal with Rust, you'd still have to account for the fact you are attaching your future to one controlled by Psychotics and type-2 psychopaths.
You may be tempted to write off these concerns about the Rust Community as just
Transphobia. But Phobias can be healthy. For example, Fear of Heights. That's a healthy phobia because it keep you from falling to your death.
Transphobia is also healthy because it keeps you away for dangerous psychotics who have been know to become violent. Trannies like to make up stories about how they were born in the wrong body and that they are symbolically -- spiritually really a women. If you don't know what sex you are and make up a story to try to explain otherwise that's evidence of a psychosis. There is also a disorder where a patient will go to a doctor complaining that they are the reincarnation of a solider who lost their limb (like a leg or an arm) in war and will insist that the limb be amputated. It's called
Body Integrity Dysphoria and it goes away if you give the patient anti-pschotic medication. There is no differences in the two disorders: Body Integrity Dysphoria and Gender Dysphoria, I would even argue that they are exact same because both include the request for organs to be amputated. Only in the case of Gender Dysphoria it is sex organs. Under the guise of being accepting of psychotic people, Mozilla has allow for a new phenomenon of elected self identification to spring up. This is absolutely offensive as it is a nice sounding way to make people ware a target. Just think, if it were a
Star of David and not pronouns on people's chests, would you be so accepting.
Pronoun badges are the new age's Stars of David and they are just as great an atrocity as the Stars of David were in Nazi German.
