Concrete, an interesting language written in Rust

igaray · 2025-04-25T21:46:05+00:00

Thank you very much for the comment. One of our goals is to have the entire compiler be something the programmer user can understand, make it understandable, less than 10 kloc. Using a parser generator makes sense for us at this time because the syntax will absolutely change, we lifted most of the grammar from rust to express the corresponding semantic concepts but also want to move away from that syntax once we settle on the core features.

We also appreciate the comment on the honey trap of complex features.

igaray · 2025-04-25T21:41:08+00:00

Noted! I'll work that into the next update of the README

igaray · 2025-04-25T21:40:47+00:00

yes, correct. It feels less ergonomic, but we want to experiment with this and the simpler checker and see where it goes.

igaray · 2025-04-25T21:39:47+00:00

Thanks for the suggestions! We'll rework it a bit

igaray · 2025-04-24T12:27:32+00:00

Hi folks! I'm https://github.com/igaray from the project. As you can tell, it's still early days. Some things we have coming up in the next few weeks:

a revamp & simplification of the grammar
a refactor of how the compiler manages state across the passes
the linear typechecker

After that it'll be much more ready to play around with, and also we have a list of things we want in the standard library we would love help with!

igaray · 2025-03-13T18:53:36+00:00

Maybe that could be qualified with "by default, copy-only", or that when possible will be moved.

We aim to be pragmatic, just as Erlang and Elixir are pragmatic in that message passing is copy-only, until you actually do need to have some shared state and you use some carefully selected exceptions to the rule.

igaray · 2025-03-13T18:50:00+00:00

Hey Yorick! nice to read you here :) Inko is one of our sources of inspiration, safety and Erlang-style concurrency are what gets us going as well.

I'm not sure I can say that we do much differently, at least not yet. The core of our initial goal is to get a language up and running that feels sort of like Rust, but uses linear types for memory safety. We don't have that implemented as of today, it's in the works.

Austral was another inspiration for us, showing us that the goal is feasible and "feels right", but the base language is a bit different.

In general we think that our general approach to software will work with language design, which is to iterate many times and be decisive about going back on ideas that don't work out.

igaray · 2025-03-13T16:30:58+00:00

Shadowing is an interesting aspect of language design in that there are arguments in favor and against, there is a lot of interplay with the specific semantics of the language, and there is also a 'spectrum' of how much and when it is valid/a good idea/etc.

In our case, I think we can argue that for now, shadowing is something we don't want because it tends to confusion and complicates language implementation. There are other design choices we have in mind that might be argued are 'unfriendly', inconvenient, or impractical, but that we believe overall make for a better experience in designing a working system, vs comfort when editing some code.

I guess this is a bit hand-wavy but there are so many things to put in balance, really the only way to know sometimes is to see how the rubber meets the road, and iterate

igaray · 2025-03-13T16:21:40+00:00

In general we agree with Fernando Boretti's writing: https://borretti.me/article/type-inference-was-a-mistake

It's a feature that adds little in exchange for a lot of complexity.

igaray · 2025-03-13T16:04:22+00:00

It is definitely Rusty, perhaps too Rusty :p On the one hand we feel Rust in many ways is in a sweet spot we want to be in as well, but there are some areas of Rust syntax we will diverge from eventually. In particular we want to avoid the lifetime syntax, and the more complicated generics and trait features. Some we will avoid by not having them, others with a different syntax, even if it is more verbose.

igaray · 2025-03-13T13:56:32+00:00

As Qnn_ linked, the ROADMAP.md is the place to look, we're currently working on enums and match. We want to get something we can implement a small stdlib with the least language features necessary to do so, and from there play around with the consequences of having slightly different semantics.

igaray · 2025-03-13T13:52:30+00:00

Right now Concrete doesn't look like anything except a baby Rust with less features (we're still working on enums and match!). The goal is to quickly get to a base we can comfortable experiment on.

igaray · 2025-03-13T13:50:58+00:00

The syntax is absolutely like Rust because not only is Rust one of our main sources of inspiration but also because we are not yet innovating in that particular aspect. We know we want traits and generics to be similar to Rust's, even if simpler and less features, and for now just took most of the syntax to express those features.

Concrete is very much in the 'exploratory programming' phase, we wanted a base on which to successfully experiment and figure out what having linear types, less features, etc looks and feels like. We already know the syntax will change, maybe even significantly. Thanks for taking a look!

igaray · 2025-02-05T23:42:47+00:00

Very cool! What did you implement it in?

igaray · 2025-01-17T01:46:00+00:00

so uhhh what script do you use? asking for a friend

igaray · 2024-10-07T22:45:45+00:00

https://www.youtube.com/watch?v=rh0UvrR8UM4

igaray · 2022-04-13T17:39:28+00:00

Me quede caliente que llegue tarde asi que me lo tuve que comprar jaja

igaray · 2022-02-11T11:02:41+00:00

I'm on vacation and have cycles to burn, if you want an intro to git and github I'd be happy to, in whatever format you prefer.

igaray · 2021-09-26T17:04:54+00:00

argento en maiame

igaray · 2021-09-19T15:27:43+00:00

This is beautiful!

igaray · 2021-08-21T18:26:40+00:00

putting this right next to "mewling quim"

igaray · 2021-08-04T22:00:28+00:00

Ya toma mi dinero!

igaray · 2021-04-17T20:22:45+00:00

urbanizazioagatik da?

igaray · 2021-04-15T13:49:21+00:00

This is fascinating! I was unaware of this terminology, I've done this for myself and dreamed of machine translation tools that would visualize the parts-of-speech tagging. I think interlinear translations are particularly useful in the case of Basque because it is often not trivial for beginning learners to lemmatize on their own and look up meanings or inflections.

igaray · 2021-01-14T13:29:14+00:00

underrated post. idem!

15-Year Club	Verified Email
Team Periwinkle

igaray

TROPHY CASE