• 2 Posts
  • 28 Comments
Joined 2 years ago
cake
Cake day: June 13th, 2023

help-circle




  • If all you do in the Err(e) => ... match arm is returning the error, then you absolutely should use the ? operator instead.

    If the match arm also converts the error type into another error type, implement the From trait for the conversion, then you can use ? as well.

    If you want to add more information to the error, you can use .map_err(...)?. Or, if you’re using the anyhow crate, .with_context(...)?.



  • Apparently the maintainer trusted the first-time contributor enough to propose tackling another bug.

    There is no trust needed when asking someone to fix a bug. It’s not like the maintainer would lose anything if the contributor failed to fix the bug.

    Besides, I think it is natural to want recognition when you do a lot of work for free. Many other people wouldn’t do this unpaid work at all; recognizing their contribution is the bare minimum of good manners. Even in a company where employees are paid for their work, it is customary to give credit to co-workers who have helped you. Most people don’t like to work in places where they don’t feel appreciated, and that is also true in Open-Source.


  • It’s not possible to instantiate or assign, which is more like a never type than a unit

    Actually, this is because void is not a type, it is just a keyword, a placeholder used instead of the return type when a function doesn’t return anything.

    If it were a bottom type, that would mean that a method returning void must diverge, which is simply not true.

    Also, if it were a bottom type, it would be possible to write an “unreachable” method

    void unreachable(void bottom) {
        return bottom;
    }
    

    Even though it couldn’t be called, it should be possible to define it, if void was a bottom type. But it is not, because void isn’t a bottom type, it’s no type at all.



    • Svelte/Vue/React components need to be compiled
    • JavaScript should be minified if the project has a significant size
    • File names should have a content hash, so they can be cashed in the browser
    • Even with HTTP/2, there’s still a case to be made for bundling hundreds or thousands of JS modules into a single file for better performance
    • Bundlers give you a dev server with live reload and hot module replacement for great developer experience
    • Setting up Vite is really easy and requires minimal configuration (compared to Webpack, for example)

  • Easy interop with legacy code is how kotlin took off, so maybe it will work out?

    Good interop was a requirement for widespread adoption, but not the reason why programmers want to use it. There’s also null safety, a much nicer syntax, custom DSLs, sealed classes, type inference, data classes, named and optional arguments, template strings, multi-line strings, computed properties, arbitrary-arity function types, delegation, custom operators, operator overloading, structural equality, destructuring, extension methods, inline functions and non-local control flow, reified types, …

    Some of these features have since been added to Java.




  • Whenever possible, it’s recommended to work in a common Git repository and use branching strategies to manage your work. However, if you do not have write access for the repository you want to contribute to, you can create a fork.

    A fork is a personal copy of the repository and all its branches, which you create in a namespace of your choice. Make changes in your own fork and submit them through a merge request to the repository you don’t have access to.

    https://docs.gitlab.com/ee/user/project/repository/forking_workflow.html

    How is this different from GitHub?

    Just to make sure there’s no misunderstanding: When I want to contribute to a project I’m not involved in, like inkscape, I’m not allowed to create a branch in their repo, so I have to fork it, which creates a copy of the repo, and sets the original repo as a remote.

    Note that git is a distributed VCS that doesn’t distinguish between servers and clients. Forking and cloning are the same operation from a technical perspective, except when you git clone, the copy ends up on your local machine, and when you press the “fork” button, the copy is on a GitHub/GitLab server.


  • Over the years people have developed an unbelievable number of coding languages. They all do pretty much the same job in pretty much the same way.

    That’s one way to say that you don’t know a lot about programming languages.

    Personally I have coded in Mercury Autocode, COBOL, FORTRAN, PL/1, LISP, Assembler, PERL, basic, C, C++ and JavaScript plus probably some others I have forgotten.

    Sadly, there’s no functional language in this list except LISP.

    JavaScript’s longevity is assured for one reason. Browsers only support JavaScript.

    Incorrect, browsers also support WebAssembly, which allows many languages (including C, C++, Rust, zig, Go, and many more) to run in the browser. And even without WebAssembly, languages can be transpiled to JavaScript, so you don’t need to code in JavaScript to run your code in the browser. Languages that can be transpiled to JavaScript include TypeScript, CoffeeScript, Reason, Elm, PureScript, Dart, Kotlin, Scala, Nim, …

    However JavaScript has a flaw.

    Not just one. Every programming language is flawed. Some languages have no type safety, some have no memory safety, some have no thread safety (or no multithreading to begin with), some are too slow for certain applications, some have an incomprehensible or verbose syntax, most support only one (sometimes two) paradigms (functional / imperative / object-oriented / logical), some have no proper module system, or no control over mutability, or visibility, or memory allocation, or side effects… some lack ergonomic error handling, or cooperative multitasking facilities such as coroutines, or generators, or macros, or reflexion…

    If you don’t appreciate the vast design space that is programming languages, of course you won’t understand why there are so many of them.




  • Even if this was true in 2013, when this article was written, the more accurate answer today would be “it depends”.

    In Rust, there are multi-threaded async executors implementing M:N threading (e.g. tokio), where M asynchronous tasks are mapped to N operating system threads. So when you await, the rest of the function may very well run in a different OS thread.

    Swift also has async/await, and like tokio it uses multiple threads to run concurrent tasks in parallel (therefore using multiple OS threads).

    Scala’s equivalent to asynchronous tasks are Promises, which can also run in parallel, as I understand it.

    Kotlin doesn’t have async/await, but it has a similar concept, coroutines, which are basically a superset of asynchronous tasks. While Kotlin’s coroutines are single-threaded by default, there is a multi-threaded implementation, enabling truly parallel coroutines.

    Go also uses coroutines (which it calls “goroutines”), which can use multiple threads.

    C++ will soon get coroutines as well, which support multithreading to run coroutines in parallel.




  • Discriminant is irrelevant and you’re not supposed to fuck with it

    It matters because the conversion between i32 and the Result is only “free” if they have the same layout (which they do not, because of the discriminant). So a more costly conversion method is required.

    And there is zero reason to use unsafe/transmute for this.

    You are right, because the compiler is able to optimize your code quite well. However, if that optimization were to break at some point (as there is no guarantee that an optimization will continue to work in the future), it would become less efficient.


  • Aloso@programming.devtoRust@programming.devCan I make Result an integer?
    link
    fedilink
    English
    arrow-up
    3
    arrow-down
    1
    ·
    edit-2
    1 year ago

    This is not possible, because Rust still stores a discriminant even when the enum values don’t overlap.

    As far as I can tell, the only situation where Rust doesn’t store a discriminant is when either the Ok or Err variant is zero-sized, and the other variant has a niche. So, Result<(), ErrorEnum> can be represented as an integer, but Result can not.

    You can still use enums, and implement simple conversions like this:

    #[repr(i8)]
    pub enum Error {
        E1 = -1,
        E2 = -2,
        E3 = -3,
        E4 = -4,
    }
    
    #[repr(i8)]
    pub enum Success {
        S0 = 0,
        S1 = 1,
        S2 = 2,
        S3 = 3,
    }
    
    pub type LibResult = Result;
    
    pub fn number_to_result(value: i32) -> Option {
        match value {
            -4 ..= -1 => Some(Err(unsafe { std::mem::transmute(value as i8) })),
            0 ..= 3 => Some(Err(unsafe { std::mem::transmute(value as i8) })),
            _ => return None,
        }
    }
    
    pub fn result_to_number(res: LibResult) -> i32 {
        match res {
            Ok(value) => value as i32,
            Err(error) => error as i32,
        }
    }
    

    P.S. Sorry that the generics aren’t displayed due to Lemmy’s bad santiziation.