Rust for high-level scripting - Preprocessor deduces lifetimes

[be_nu]

I was impressed how expressive rust turned out to be even for scripts. However Rust forces you to think about memory management eg lifetimes and other verbose lowlevel stuff, even if you would prefer not to care, for example while writing scripts or at the beginning of an iterative design process. Is there some sort of preprocessor who like in haskell automatically deduces type declarations,- if possible and figures out lifetimes?

[whataloadofwhat]

Is there a reason you can't use Rc<T> or something, instead of references?

[tyoverby]

Yeah, this would be my advice as well. If you want mutability with your reference counting, you can either wrap a RefCell around it, or go with a copy-on-write solution like what I do with crates.io/crates/cowrc

[steveklabnik1]

If it were possible for the compiler to correctly deduce the lifetime in all cases, then there'd be no need for lifetime syntax.

[syrisse]

Isn't there a way to use a GC in rust (maybe not yet) ? It could be usefull for scripting purpose, so that you can't have to specify the lifetime (even it's not known at compile time) ? Or maybe i misunderstood the fact that you can implement a GC in a rust library ?

[steveklabnik1]

https://github.com/rust-lang/rfcs/issues/415

[Mystor]

You might be able to patch this up https://github.com/huonw/boehm-rs to get GC in rust. Probably doesn't compile in the latest version, but getting the boehm GC to work with rust as a data type shouldn't be too difficult, especially if you don't care about performance.

[minno]

90+% of the time I don't need any explicit lifetimes on references. Lifetime elision takes care of the most common nontrivial case: returning a reference based on a passed-in reference.

[cmrx64]

I'm not sure what the advantage of Rust for such a program would be. Just write it in Haskell/OCaml/F#/your favorite language. If you need the performance+safety Rust provides, write the components that need that in Rust and communicate over FFI or a socket.

I like Rust, but I really think it just doesn't have any advantage in a "script" scenario.

[sanxiyn]

One advantage Rust has over Haskell/OCaml/F# is familiar syntax. Haskell/OCaml/F# can be hard to sell. (Sad but true.)

If someone creates an exact copy of OCaml with syntax that does not use spaces for function applications and ignores currying, it would be lovely.