• sudo@programming.dev
    link
    fedilink
    arrow-up
    2
    ·
    7 months ago

    He explicitly states that its not that bad in Rust because all functions must have type annotations. Its only a problem if your functions are huge (they shouldn’t). I think thats the correct way to go. Local variables can be inferred but anything else should be annotated.

    Modern code review tools like Github even support LSP-like features to solve this problem; and if your language isn’t supported… just pull the feature branch to review it.

    But now your requiring more tools and effort on the reviewer over, just reading the code.

    • tatterdemalion@programming.dev
      link
      fedilink
      arrow-up
      2
      ·
      7 months ago

      But now your requiring more tools and effort on the reviewer over, just reading the code.

      This should be completely negligible if you are writing code in the same code base.

      • sudo@programming.dev
        link
        fedilink
        arrow-up
        2
        arrow-down
        1
        ·
        7 months ago

        I was already assuming I was working on the same codebase. I am not going to stash my work, checkout the branch and wait for the LSP to start up (if it’s working) just to confirm that your types aren’t doing anything weird. I’d rather just have them annotated correctly in the first place and just read the PR and trust the CI.

        • tatterdemalion@programming.dev
          link
          fedilink
          arrow-up
          4
          ·
          edit-2
          7 months ago

          You don’t need to restart your LSP to switch to a new branch. You also don’t need an LSP to find the types.

          Even with all of these issues aside, I can’t think of the last time I was reviewing a PR where it wasn’t clear from context what the types were, or they were irrelevant.

          • sudo@programming.dev
            link
            fedilink
            arrow-up
            1
            ·
            7 months ago

            wth is your position then? If I can know the types from just looking at the code then it must have adequate type annotations and none of this matters. If I can’t tell the types and I have to pull the code locally to figure it out then I’m not starting the review on a good foot.

            I think people here are thinking about type inference in a very local scope and not at a public function level which I understood the author to be complaining about.

            • tatterdemalion@programming.dev
              link
              fedilink
              arrow-up
              1
              ·
              7 months ago

              If I can know the types from just looking at the code then it must have adequate type annotations and none of this matters

              That’s not really true. It depends on the language. In Rust, it’s common to read a function without any explicit types except for the arguments and return type. So you may not know what types are used in the body without referring to the signatures of functions called.

              If I can’t tell the types and I have to pull the code locally to figure it out then I’m not starting the review on a good foot.

              It’s rare that knowing the types is critical to actually reviewing the code. Types are mostly for the compiler to help you. When reading the code, it’s more important that you see idioms, descriptive names, and test cases. There are rare occasions where it’s necessary to determine a type to resolve some ambiguity in how the code works, and in those cases, there are tools to help you do this (usually the same tools you use while writing code, e.g. LSP editor plugins and grep).

              I think people here are thinking about type inference in a very local scope and not at a public function level which I understood the author to be complaining about.

              In my very first comment, I said I can’t comment on OCaml. I am only really speaking on Rust here, where you have local inference and mandatory function type signatures.