English, rewritten in Rust: grammar as trait bounds, pronouns as borrows, and englishc, a compiler with rustc-style diagnostics for prose - Aaryan-Kapoor/english-rs

Antoyo's Personal Blog

pub fn fold(slice: &[i32], init: i32, f: fn(i32, i32) -> i32)-> i32 { match slice { [] => init, [first, rest @ ..] => fold(rest, f(init, *first), f), } }

The Borrow Checker Requires Predictable Lifetimes The borrow checker is a static analysis tool. It must be able to look at your code at compile time and definitively prove exactly when a reference starts, when it ends, and that no two threads overlap. When you spin up multiple independent OS threads, the compiler cannot predict when they will execute. Thread A might run for 5 milliseconds, get interrupted by the operating system, and then Thread B might run. Because the execution order is determined at runtime by the OS scheduler, the compiler cannot statically guarantee that two threads won’t try to access the same memory address at the same fraction of a second.

Okay. I’m moderately (at best) familiar with rustc and wildly unfamiliar with LLVM. But from what I can tell, LLVM allows type aliasing so long as the relevant parts of the layout are compatible. So: * Rust’s AM guarantees padding is not clobbered unless the entire struct is assigned. * LLVM allows aliasing the same memory between a layout with explicit padding (like a byte array field) and a layout with implicit padding if they are equal in other regards. * Explicit padding is never overwritten no matter what. I’m _not_ suggesting a design right now, I just want to figure out whether this is technically possible: * Similar to the proposed attribute, some `zero_padding` function attribute is introduced. GCC has `-fzero-init-padding-bits`, for example. * With the attribute, all padding initializes to 0 alike GCC (may also require something like `-ftrivial-auto-var-init`, unsure). * Rust never changes the padding of a partial struct update, so zero-inits are preserved. If the struct is fully updated, the value it’s updated to was originally initialized with 0 padding and also was never clobbered by partial writes. * Within annotated functions, all writes are performed with explicit-padding LLVM layouts so that LLVM cannot apply optimizations that would clobber 0-padding. Reads may or may not need explicit padding, I’m not sure what kind of optimizations are enabled for reading undef padding. * Unannotated functions work as usual; all secrets must have been zeroized before returning to or calling them. I’m not sure this is bullet-proof, but sounds doable in principle? I’m also aware it’s unrealistic to annotate all callees all the time, but I think this can be mitigated by good practice (keeping secret-processing code minimal, zeroizing asap, etc.).

No, because you said the end product should be rustc level error, I corrected it that the end product should be compiler magic You seems to not read the discussion well, because that things are already solved with the latest details of specification that I already wrote earlier. That, ASAP drop has no effect in safe Rust code correctness due to it works out of the box with reference, and fallback safe to scope drop for T that is converted to pointer (standart library can use ASAP manual annotation to bypass the fallback, otherwise any T that is converted to raw pointer be it standart library or user code that is not manually ASAP annotated is untouched, still uses scope drop), dedicated ASAP lock types (practically making existing scope lock untouched, so any argument mentioning legacy scope block lock user code issue is not correct, because it is untouched). So you haven't shown legacy code that will not handled with that newest specifications, just instantly assert people will audit their code. Maybe can you write the new list? If the end product is compiler magic, not a compiler error or warning, it is ok to do the experiment in Clippy lint. Tho there is potential downside that I need to state, but ok to choose either way. Experimenting in linting way won't give insight about how to implement it in compiler magic, so it can double the work. If the experimentation is done in a fork of Rust compiler, so people gets hand touch experience directly to the real thing that will be implemented to the main branch later. But it is ok too to do via lint for the initial test, just the final result is compiler magic that I explained before, not compiler error or warning

No, because you said the end product should be rustc level error, I corrected it that the end product should be compiler magic You seems to not read the discussion well, because that things are already solved with the latest details of specification that I already wrote earlier. That, ASAP drop has no effect in safe Rust code correctness due to it works out of the box with reference, and fallback safe to scope drop for T that is converted to pointer (standart library can use ASAP manual annotation to bypass the fallback, otherwise any T that is converted to raw pointer be it standart library or user code that is not manually ASAP annotated is untouched, still uses scope drop), dedicated ASAP lock types (practically making existing scope lock untouched, so any argument mentioning legacy scope block lock user code issue is not correct, because it is untouched). So you haven't shown legacy code that will not handled with that newest specifications, just instantly assert people will audit their code. Maybe can you write the new list? If the end product is compiler magic, not a compiler error or warning, it is ok to do the experiment in Clippy lint. Tho there is potential downside that I need to state, but ok to choose either way. Experimenting in linting way won't give insight about how to implement it in compiler magic, so it can double the work. If the experimentation is done in a fork of Rust compiler, so people gets hand touch experience directly to the real thing that will be implemented to the main branch later. But it is ok too to do via lint for the initial test, just the final result is compiler magic that I explained before, not compiler error or warning

Making Clippy lint deny by default in rustc level does not solve the problems of a lint that I stated earlier. So I recommend you reread it To put it simple, lint/error is not compiler magic. Lint/error just tells you the info, you have to do the grunge work to fix it yourself manually, which result in bad user experience because people get something in ther way that could actually be moved to compiler magic. Compiler magic is the compiler handles it all automatically user just receive the clean result, user does not see warning or error message, user does not need to do the fix manually (writing manual drop), compiler already insert the drop code automatically when later compiling the code, it does not edit your code but its own internal state when compiling and the cache in target folder. So rustc level deny will still has these problems fuji-184: > * you write many code, you don't know where to place it, you run clippy, it tells you to place the manual drop here and here and here, you reedit the code, then you write many new code again, you don't know where to place it, you run clippy again, it prints message to place drop here and here and here and here, you scroll and edit the code again to any code and any file. Then the code is filled with memory management ceremony not business logic > * you can not get ASAP drop if it is code written by other people, eg 3rd party libraries. Because Clippy needs to insert `drop` manually physically by hand, not compiler magic, and you don't have access to the code >

Making Clippy lint deny by default in rustc level does not solve the problems of a lint that I stated earlier. So I recommend you reread it To put it simple, lint/error is not compiler magic. Lint/error just tells you the info, you have to do the grunge work to fix it yourself manually, which result in bad user experience because people get something in ther way that could actually be moved to compiler magic. Compiler magic is the compiler handles it all automatically user just receive the clean result, user does not see warning or error message, user does not need to do the fix manually (writing manual drop), compiler already insert the drop code automatically when later compiling the code, it does not edit your code but its own internal state when compiling and the cache in target folder. So rustc level deny will still has these problems fuji-184: > * you write many code, you don't know where to place it, you run clippy, it tells you to place the manual drop here and here and here, you reedit the code, then you write many new code again, you don't know where to place it, you run clippy again, it prints message to place drop here and here and here and here, you scroll and edit the code again to any code and any file. Then the code is filled with memory management ceremony not business logic > * you can not get ASAP drop if it is code written by other people, eg 3rd party libraries. Because Clippy needs to insert `drop` manually physically by hand, not compiler magic, and you don't have access to the code >

However, starting as a Clippy lint is a good way to prove that something is generally useful - a lint can go from "nursery" to "suspicious" to being a deny-by-default `rustc` lint to changing the way the language works in line with the lint. At core, changing the language is a big deal - it means forcing people to audit all existing code and documentation to confirm that it's still correct even in the presence of a change. Adding a lint is a very good way to gather data to show that the language change makes sense - first get the lint stable as an allow-by-default Clippy lint, then persuade people to make it warn-by-default (e.g., then you'll get examples of cases where people think this change is bad because it's warning on code they think is perfectly reasonable). Remember that, fundamentally, evolving _existing_ parts of a language has to be conservative - every time you change something that people are depending on, you force people to do "busy work" that they don't want to do, and if you do that enough times, they abandon the language and move on. Adding new things that have no impact on existing code is where you don't have to be conservative.

No, because you said the end product should be rustc level error, I corrected it that the end product should be compiler magic You seems to not read the discussion well, because that things are already solved with the latest details of specification that I already wrote earlier. That, ASAP drop has no effect in safe Rust code correctness due to it works out of the box with reference, and fallback safe to scope drop for T that is converted to pointer (standart library can use ASAP manual annotation to bypass the fallback, otherwise any T that is converted to raw pointer be it standart library or user code that is not manually ASAP annotated is untouched, still uses scope drop), dedicated ASAP lock types (practically making existing scope lock untouched, so any argument mentioning legacy scope block lock user code issue is not correct, because it is untouched). So you haven't shown legacy code that will not handled with that newest specifications, just instantly assert people will audit their code. Maybe can you write the new list? If the end product is compiler magic, not a compiler error or warning, it is ok to do the experiment in Clippy lint. Tho there is potential downside that I need to state, but ok to choose either way. Experimenting in linting way won't give insight about how to implement it in compiler magic, so it can double the work. If the experimentation is done in a fork of Rust compiler, so people gets hand touch experience directly to the real thing that will be implemented to the main branch later. But it is ok too to do via lint for the initial test, just the final result is compiler magic that I explained before, not compiler error or warning

Making Clippy lint deny by default in rustc level does not solve the problems of a lint that I stated earlier. So I recommend you reread it To put it simple, lint/error is not compiler magic. Lint/error just tells you the info, you have to do the grunge work to fix it yourself manually, which result in bad user experience because people get something in ther way that could actually be moved to compiler magic. Compiler magic is the compiler handles it all automatically user just receive the clean result, user does not see warning or error message, user does not need to do the fix manually (writing manual drop), compiler already insert the drop code automatically when later compiling the code, it does not edit your code but its own internal state when compiling and the cache in target folder. So rustc level deny will still has these problems fuji-184: > * you write many code, you don't know where to place it, you run clippy, it tells you to place the manual drop here and here and here, you reedit the code, then you write many new code again, you don't know where to place it, you run clippy again, it prints message to place drop here and here and here and here, you scroll and edit the code again to any code and any file. Then the code is filled with memory management ceremony not business logic > * you can not get ASAP drop if it is code written by other people, eg 3rd party libraries. Because Clippy needs to insert `drop` manually physically by hand, not compiler magic, and you don't have access to the code >

Making Clippy lint deny by default in rustc level does not solve the problems of a lint that I stated earlier. So I recommend you reread it To put it simple, lint/error is not compiler magic. Lint/error just tells you the info, you have to do the grunge work to fix it yourself manually, which result in bad user experience because people get something in ther way that could actually be moved to compiler magic. Compiler magic is the compiler handles it all automatically user just receive the clean result, user does not see warning or error message, user does not need to do the fix manually (writing manual drop), compiler already insert the drop code automatically when later compiling the code, it does not edit your code but its own internal state when compiling and the cache in target folder. So rustc level deny will still has these problems fuji-184: > * you write many code, you don't know where to place it, you run clippy, it tells you to place the manual drop here and here and here, you reedit the code, then you write many new code again, you don't know where to place it, you run clippy again, it prints message to place drop here and here and here and here, you scroll and edit the code again to any code and any file. Then the code is filled with memory management ceremony not business logic > * you can not get ASAP drop if it is code written by other people, eg 3rd party libraries. Because Clippy needs to insert `drop` manually physically by hand, not compiler magic, and you don't have access to the code >

However, starting as a Clippy lint is a good way to prove that something is generally useful - a lint can go from "nursery" to "suspicious" to being a deny-by-default `rustc` lint to changing the way the language works in line with the lint. At core, changing the language is a big deal - it means forcing people to audit all existing code and documentation to confirm that it's still correct even in the presence of a change. Adding a lint is a very good way to gather data to show that the language change makes sense - first get the lint stable as an allow-by-default Clippy lint, then persuade people to make it warn-by-default (e.g., then you'll get examples of cases where people think this change is bad because it's warning on code they think is perfectly reasonable). Remember that, fundamentally, evolving _existing_ parts of a language has to be conservative - every time you change something that people are depending on, you force people to do "busy work" that they don't want to do, and if you do that enough times, they abandon the language and move on. Adding new things that have no impact on existing code is where you don't have to be conservative.

Ada と Rust はどちらも安全性を重視する言語ですが、誤りを止める場所が違います。値の範囲、整数オーバーフロー、メモリ、データ競合、検査を外す仕組み、形式検証の6点を、GNAT・GNATprove・rustc で実際に動かして比べます。