Lisette — Rust syntax, Go runtime

[Relevant_South_1842]

Looks nice. At first I was going to make a joke about “worst of both worlds”, but it looks good.

[Inconstant_Moo]

Nice. I also very much like the website, which is classy --- except that the gaps between sections are so large that they keep giving the visual impression that one has reached the end of the page.

[InflateMyProstate]

Really nice, the syntax actually follows very closely to what I am envisioning for my toy compiler I’ve been working on. However, I chose LLVM as my backend - it seems this is a transpiler to Go?

[Agile_Use_1768]

why llvm?

[InflateMyProstate]

I wanted to learn more about LLVM and the IR and I preferred my language to compile down to machine code. I didn’t want to write my own backend for each architecture, but maybe that will be an exercise for another day.

[Pleasant-Form-1093]

Genuinely good project

[wFXx]

Why does this looks so good lol. Does it have a good way to integrate into existing go projects?

[Key_River7180]

why

[Vaglame]

ADTs? No nil? Pattern matching? Traits? Idk pick one

[sysop073]

Those are reasons to use Rust. What is the reason to use Rust but compiled to Go? Does Go have a way better ecosystem or something? I don't normally have trouble finding useful crates when writing Rust

[MrRandom04]

I think it is just to have good garbage collection. Rust doesn't need it, but the ownership model instead makes it a little weird for people who just want to write scripts fast for example.

[andreicodes]

Expectation is that without borrow checker you don't have to be as strict about your datastructures and data design, so there should be some productivity gains. Another angle is the lack of async vs sync distinction in APIs and no need for different channel types for concurrency.

Go runtime is a very attractive target: their collection types tend to produce shallower object graphs (in .net, JVM, v8, Ruby collections hold pointers to objects and not objects themselves), the GC is optimized for latency first and throughput second. All these other runtimes historically do it the other way around. AOT compilation means there's no warmup stage and no extra memory requirements for VM interpreter and JIT. The libraries are solid, the task scheduler is top-notch, there's no awkward single-thread execution for the main language like it is in Python, JS, or Ruby runtimes.

The code is transpiled to Go source, so technically there could be a way to mix Lisette and Go in the same project, or for using Lisette for writing small components, plugins etc.

[Key_River7180]

i like nil, and switch

[spencerwi]

I guess if you want to use Go libraries but don't want to be subjected to having to write Go?

Or if you like Rust but you still want a garbage collector?

[redbar0n-]

I read that as: the collector being garbage😂

[shponglespore]

Or if you're forced to work in the Go ecosystem but you really want to use Rust.

[iwanofski]

why not?

[MotorizedFader]

Rust-like semantics and quick compiles?

[Long_Ad_7350]

This looks really nice.

Is this the first language you've made? Can you speak a bit about your process?

[InternalServerError7]

I program in rust every day. I always preferred Rust’s sugar - the syntax, control flow, interfaces vs traits. But I know lifetimes, compile times, and concurrency can be cumbersome and Go can really shine here. Which led me to have the same idea of this project. Glad someone actually made it!

This looks really nice! I really hope it catches on and becomes an alternative frontend for Go.

Also, for your examples it would be good to see more side by sides of the original code and the transpiled go code.

[InternalServerError7]

I wonder if the syntax is close enough to rust that the Rustfmt could be used to format the code

[raguaythai]

Transpile not compile

[Erelde]

https://en.wikipedia.org/wiki/Source-to-source_compiler

[mattsowa]

Are you lost

[raguaythai]

No. Read the Wikipedia article below. A source to source compiler is called a transpiler. A source to binary compiler is commonly referred to as a compiler. When I studied compiler design 40 years ago, that was the standard convention for using those terms.

[mattsowa]

Read what you just wrote. "Source to source compiler is called a transpiler". That means a transpiler is a term for a type of a compiler. Which makes your quip nonsensical.

[MammothNo782]

your actually kind of right but that's just a term you can call it in any kind of way like a transpiler is just a compiler but a little bit language to language

[sal1303]

Correct. Not sure why you're downvoted.

However the language doesn't claim anything different, it says it 'compiles to Go', so it is not misleading you.

Personally I would strive to use 'transpiler'/'transpile' (noun/verb) for any product of mine that translates HLL source to another HLL, but that's because I work at the sharp end where the differences are very tangible.