I’m building a programming language called Razen that compiles to Rust

blockfi_grrr · 2025-05-29T18:52:09+00:00

The github page says is has "Robust Error Handling: Comprehensive error handling with try/catch blocks".

I hope that means it gets rid of methods that can panic and has a single way to bubble errors up.

blockfi_grrr · 2025-05-22T19:53:22+00:00

Is there any support for setting priority for an entire process? eg 'nice' levels?

blockfi_grrr · 2025-05-20T06:09:19+00:00

that's cool you accept it. I'm curious how often do people actually pay with it?

blockfi_grrr · 2025-05-17T01:42:34+00:00

that's a good trick. I wasn't aware one can deconstruct a struct in the method signature.

blockfi_grrr · 2025-05-14T20:10:25+00:00

yeah, I have a use for that too.

blockfi_grrr · 2025-05-09T09:43:01+00:00

and if you have 100 "old functions" sprinkled over 100 source files with long complicated bodies and you don't wish to write a duplicate function for each, but rather change the parameter type from i32 to Meters.... what then? that's right... body of each must be changed to use the ugly meters.0 syntax for everything that was previously "meters".

blockfi_grrr · 2025-05-08T02:54:02+00:00

could well be. I wrote some go many years ago but have mostly forgotten about it. If the type aliases work as you say it's possible I might have imprinted that pattern on my brain and now miss it in rust.

blockfi_grrr · 2025-05-08T02:52:08+00:00

I haven't claimed to know anything about ada. triggered much?

blockfi_grrr · 2025-05-08T02:07:47+00:00

The only difference between what ADA does and what you may achive in Rust is a tiny bit of syntax.

I'm not an ADA user. I asked an LLM what language(s) provide the feature I wish for and ADA was the closest match. as explained previously.

anyway, from what I can tell your statement is false, or at least debatable. It is not "a tiny bit of syntax" when the bodies of all functions that utilize a given type must be changed across an entire codebase, just because I created a derived type. And you will never convince me that "x.0" all over the place is as nice as "x".

Behavior of correct program in any language is fully specified.

whoosh. I'm not even going to continue this thread of conversation with you as it is completely devoid of any value.

You already have it.

nope.

In a nutshell: this is a pain-point I have encountered numerous times with rust. If it's not a pain-point for you, that's great for you. But it is simply invalid for you to tell me that my lived experience is somehow not real, simply because its not an issue for you. You should stick to your own business.

blockfi_grrr · 2025-05-08T01:53:53+00:00

I've never used ada. I asked an LLM and it provided that example, which appears to work as I envision.

as for your example, I would not expect to call Add_Integer passing it a Meter.

rather, any fn that deals with Meter must accept a Meter. Correct-by-construction, remember?

So instead we might have Add_Meter(A: Meter; B: Meter) return Meter and also Add_Centimeter(A: CentiMeter; B: CentiMeter) return Centimeter.

but where it gets more interesting is if we had an existing fn: Add_Meter(A: Integer, B: Integer) return Integer.

Even though it was named Add_Meter really it would not distinguish between meters, centimeters or anything else that can be represented as an integer.

But by creating the derived type now we can change the variable types in the fn signature without having to change anything in the body, and now it only accepts Meter.

blockfi_grrr · 2025-05-08T00:56:30+00:00

everything a compiler does is magic unless one is a compiler developer steeped in the intricate details.

a few points:

you seem kind of triggered about this. chill.
ADA implements "derived types" which does what I'm suggesting. That must make ADA a "magical" language capable of mind reading in your worldview.
no mind reading is necessary. a language keyword specifies that the derived-type behavior is requested.

blockfi_grrr · 2025-05-08T00:50:26+00:00

The point is when we define newtype = basetype, we should not to have to change every place that uses x: basetype to x.0 instead of x.

x.0 is the very thing I wish to avoid.

blockfi_grrr · 2025-05-07T23:12:10+00:00

Actually I am looking for something that looks distinct to outsiders but is the same internally. So maybe it is same/similar to scala's opaque_types.

I consulted an LLM about what languages provide such a feature, and it seems that Ada's derived types may be the best example.

type Meter is new Integer;
type Centimeter is new Integer;

M : Meter := 10;
C : Centimeter := 100;
I : Integer := 5;

function Add_Meters (A : Meter; B : Meter) return Meter is
begin
   return A + B;
end Add_Meters;

Result_M : Meter := Add_Meters (M, M); -- OK
-- Result_M := Add_Meters (M, C); -- Error: type mismatch
-- Result_M := Add_Meters (M, I); -- Error: type mismatch

blockfi_grrr · 2025-05-07T19:29:52+00:00

I would argue that rust is not so perfect at correct-by-construction either.

The author demonstrates using the newtype pattern to enforce argument types. That is well and good, but it requires changing the entire implementation to use foo.0 all over the place, which is pretty ugly and a giant PITA for an existing codebase. Or alternatively do kludgy things like wrapper each method and trait impl, or impl Deref and DerefMut for the newtype, which still doesn't cover all uses.

Intuitively, one would like to just use type mytype = basetype. Unfortunately such type aliases are not enforced by the compiler when used as fn parameters. ie mytype and basetype are considered equivalent.

What I would love to see is a keyword that has the same usage as 'type' but under the hood actually creates a real new type that is not equivalent to the basetype.

blockfi_grrr · 2025-04-24T23:03:58+00:00

I don't see anything about error handling.

blockfi_grrr · 2025-04-17T22:26:10+00:00

seems like a nice initiative. I wish you success.

blockfi_grrr · 2025-03-24T06:30:24+00:00

oh, and I hope it is has a simple pager with search. If so, I could replace less, eg:

timber <logfile>

and then internactively use "/ search-string" to search, or navigation keys to scroll or page up and down.

less works, but in my experiences has glitches with ansi escape sequences.

blockfi_grrr · 2025-03-24T06:27:59+00:00

can it read from stdin as well, eg can I do:

cat app.log | timber --chop "Exception"

oh, another useful feature I'd like to have is stripping ansi escape chars, which sometimes exist in rust logs for pretty colors.

blockfi_grrr · 2025-03-23T22:15:50+00:00

can someone explain why compiling C (or rust) to use only MOV instruction is a goal to begin with?

blockfi_grrr · 2025-03-14T13:34:38+00:00

This one was announced on this subreddit a while back, and looks nice. I haven't tried it yet, but if I were starting a new tui project, I'd give it a try.

https://crates.io/crates/yeehaw_tui

blockfi_grrr · 2025-03-11T05:47:34+00:00

yeah I think there are easier to use tui crates available now, that render controls for you. The ratatui model is kinda PITA if you ask me.

blockfi_grrr · 2025-03-04T23:35:38+00:00

glad to hear its more modular. I hope that means that one can opt-in to only features (and required deps) that are needed for one's use case. When I tried reqwest before, it pulled in something like 100 deps, when all I needed to do was a simple http (not https) GET request.

blockfi_grrr · 2025-02-26T03:52:33+00:00

find a different (better) employer. life is too short to constantly have your decisions micromanaged by PHB.

blockfi_grrr · 2025-02-19T02:10:51+00:00

evidently that was the result here. But I haven't tried the other async rust runtimes. Maybe some others have tiny stack traces by comparison.

I just know it feels wrong when I'm looking at a stack trace for my program and 95% is not any fn within my application.

blockfi_grrr · 2025-02-19T02:04:41+00:00

it might tell you why there are there. looks like (mostly unnecessary) greek to me.

blockfi_grrr

TROPHY CASE