On Thursday, 20 October 2022 at 15:54:45 UTC, Ali Çehreli wrote:
> On 10/20/22 07:09, jmh530 wrote:
>
> > TIL that this works...I thought it would only work for
> global/static
> > variables.
>
> Similar nested function examples appear at the following point during one of my presentations:
>
>   https://www.youtube.com/watch?v=dRORNQIB2wA&t=2419s
>
> Ali

I suppose I just don't make much use of nested functions. Might consider making more useof them, when needed.

On 10/20/22 18:49, H. S. Teoh wrote:
> On Thu, Oct 20, 2022 at 03:25:36PM +0000, Don Allen via Digitalmars-d wrote:
>> Where I do think D would do well by emulating Rust is in the area of helpful
>> compiler warnings: noting unused variables, constants and imported symbols,
>> pointing out unnecessary parentheses, etc.
> [...]
> 
> It would be good to file these as enhancement requests to bugzilla, so
> that they don't get lost in the dusts of forum history.
> 
> 
> T
> 

Such warnings don't carry over well to D though, because template expansion is untyped. Therefore, by default the compiler will check whether the _generated code_ has any of those issues, which is usually just an annoyance. Lots of false positives. I also don't think people should be encouraged to remove unnecessary parentheses, otherwise they will start to also omit necessary ones.

On 20/10/2022 15:37, Don Allen via Digitalmars-d wrote:
> Rust has closures. Great. So here's an example of an attempt to do something along the lines described above with a single mutable variable:
> 
> ````
> fn main() {
>      let mut foo = 5;
>      let mut bar = || {
>          foo = 17;
>      };
>      let mut baz = || {
>          foo = 42;
>      };
>      bar();
>      println!("{}", &mut foo);
>      baz();
>      println!("{}", &mut foo);
> 
> }
> ````

To be honest, these kind of access patterns are smelly and there almost always exists a more elegant alternative.

Regarding that example code above, the burrow checker will be happy if you reorder it slightly:

```rust
fn main() {
    let mut foo = 5;
    let mut bar = || {
        foo = 17;
    };
    bar();
    println!("{}", &mut foo);
        // just moved this down here
    let mut baz = || {
        foo = 42;
    };
    baz();
    println!("{}", &mut foo);
}
```

On Thursday, 20 October 2022 at 22:41:34 UTC, rassoc wrote:
> On 20/10/2022 15:37, Don Allen via Digitalmars-d wrote:
>> Rust has closures. Great. So here's an example of an attempt to do something along the lines described above with a single mutable variable:
>> 
>> ````
>> fn main() {
>>      let mut foo = 5;
>>      let mut bar = || {
>>          foo = 17;
>>      };
>>      let mut baz = || {
>>          foo = 42;
>>      };
>>      bar();
>>      println!("{}", &mut foo);
>>      baz();
>>      println!("{}", &mut foo);
>> 
>> }
>> ````
>
> To be honest, these kind of access patterns are smelly and there almost always exists a more elegant alternative.

"smelly" and "elegant" are in the nose and eye of the beholder. As I said in my original post, this kind of code is very common in Scheme.

>
> Regarding that example code above, the burrow checker will be happy if you reorder it slightly:
>
> ```rust
> fn main() {
>     let mut foo = 5;
>     let mut bar = || {
>         foo = 17;
>     };
>     bar();
>     println!("{}", &mut foo);
>         // just moved this down here
>     let mut baz = || {
>         foo = 42;
>     };
>     baz();
>     println!("{}", &mut foo);
> }
> ```

Except the re-ordering you suggest is not possible in the actual code from which this example was derived. In the real code, the mutable variables are sqlite statements where multiple closures refer to several of them and the closures are called in multiple places.

You are taking advantage of this simple derived case, where each closure is called in only one place, and also the fact that mutable references are dropped after their last use, to arrange for only one mutable reference to foo active at any time, which is what the borrow checker wants.

In the real code, because the closures refer to multiple mutable variables and there are multiple call sites to each closure, it isn't possible to segregate the closures and their call sites to satisfy the borrow checker, but use of interior mutability does work.

On 21/10/2022 05:36, Don Allen via Digitalmars-d wrote:
> As I said in my original post, this kind of code is very common in Scheme.
>

Right, I walked that path before, even shiny R7RS, and I'm glad I went to speech therapy for my lisp.

> where multiple closures refer to several of them and the closures are called in multiple places
>

National Spaghetti Day is coming up on January 4th. ;)

In all seriousness, though, I'm not here to invalidate your experiences with Rust. While I've been using D for quite a bit now, I get to experience some pretty uncomfortable cognitive dissonance doing so. I still love it, but D often times offers a slightly less performant and reliable way to tackle a certain set of hard problems. Even if I never get to experience Rust professionally, I'm still quite happy that it set a new baseline for safe languages to come and evolve to.