oh, just noticed

the Gleam language doesn't have macros nor annotations

which means that things like the cool routing in Rocket.rs or Actix Web or Spring Boot just aren't feasible at all

riiiiiiiiiiiiiiiiiiiiiiight

this might be the thing that breaks the language for me

pattern matching is fine and all, but we should be making code as densely packed and declarative as possible imho

I also really really REALLY think that a language without a proper piping operator isn't really worth considering

so uh, rip JavaScript and TypeScript

I would like to use PureScript but I'm increasingly concerned that the language is just... ded https://github.com/purescript/purescript

ngl tho, looking through PureScript gives me the impression that it'll also lack macros or annotations

you gotta give me one of the following:

- annotations (or attributes or whatever) with arguments
- refinement types/type tailoring
- dependent typing
- macros that let me put one of these features onto your language

it just makes life so much easier

I might actually end up coming back to Rhombus

"wait but you can't do web development on Rhombus" shhhhhhhhhhhhhhhhhhhhhh

CoffeeScript is also discarded https://github.com/jashkenas/coffeescript/issues/5316

there's a way to do pipelining on Scala

. . .

....I'm paying attention

@xerz do you think I’d like gleam

Haxe also has annotations, which makes sense because it's a JVM language.

They call them... metadata.

Huh.

Haxe also allows defining a pipe operator... it's, weird tho

https://code.haxe.org/category/abstract-types/pipe.html

oh and I forgot annotations can also be called "decorators"

so that's 4 names for the same obvious concept

remember when I said this

https://owo.cafe/@xerz/116069109462525884

welp

this is actually unfairly cool https://rescript-lang.org/docs/manual/jsx#generic-jsx-transform-jsx-beyond-react-experimental

wAIT

HOLDUP

IS THIS WHAT I THINK IT IS

https://rescript-lang.org/docs/manual/module-functions

IS THIS THE EQUIVALENT, OF LIKE, OVERRIDES IN NIX

oh, no, it's a functor, it's for mapping stuffs

still neatneat

> We adhere to the llms.txt convention to make documentation accessible to large language models and their applications.

cringe

it's unfair how cool this language looks, because now I'm worried it's becoming slopghetti https://rescript-lang.org/blog/reactive-analysis/

so yeah, I guess I'm considering Scala and ReScript

weh

@xerz what kind of project do you want to do? Or are you just searching for the perfect language? :3c

@Sugui for web frameworking stuffs, my idea is to make it as easy as possible to create a website using Web Components on the client and the easiest routing and (de)serializing possible on the server side

@MeDueleLaTeta yeah, and that's alright... no annotation-decorator thingies tho........

...so uh, I guess my current options are:

- JS/TS + whatever lets me use a pipe operator (probably Babel)
- ScalaJS
- ReScript

and ngl I'm leaning towards good old JS here

making a macro in shrubbery is so easy

*type check fails*

making a macro in shrubbery is so hard

okay I think making a pipeline operator for Shplait isn't as easy as I thought (here's the Rhombus implementation) https://github.com/racket/rhombus/blob/30a3212e3b6616b75ececdc96656d2529a20dfda/rhombus-lib/rhombus/private/amalgam/pipeline.rhm

all of these fail:

```shplait
macro '$lhs |> $rhs': '$rhs($lhs)'
macro '$lhs |> $rhs ...': '$rhs ...($lhs)'
macro '$lhs |> $(rhs :: Identifier)': '$rhs($lhs)'
macro '$lhs |> $(rhs :: Identifier) ...': '$rhs ...($lhs)'
```

the problem is that I can't just, create a macro that takes everything to its left and evaluates it first

it sees it all as individual terms, separated from each other

it gets better tho: when something does get evaluated by the macro, it is not within parents, so like `(3 |> add1) |> print` becomes `print(3 |> add1)`

it does not know how to evaluate what's within afterwards

overall, it's a world worth keeping up with, but I can't be fully happy with the semityped, class-first Rhombus nor the ML typed, pretty incomplete Shplait

.......speaking of keeping up with: https://github.com/drym-org/qi/wiki/Qi-Meeting-Jan-9-2026

(P.S.: "lhs" means "left hand side" https://en.wikipedia.org/wiki/Sides_of_an_equation)

oh and in case anyone wonders why Rhombus become Racket 2 instead of Shplait

also: https://racket.discourse.group/t/any-plan-for-static-type-checker/3669/4

yeah okay, Babel supports both JS and TS *with JSX* so that settles it

no, not doing SWC

it doesn't support annotations/decorators nor pipeline operators

weh https://github.com/tc39/proposal-pipeline-operator/issues/221#issuecomment-922168037

I hope Babel does souece mapping so if I debug TypeScript code with unsupported, Babel-compiled features (*ahem* pipeline operator *ahem*) it shows the original source code instead of the Babel-parsed one

@xerz why tho

I don't feel that the absence of that feature makes language so useless that it's not worth using

@nyx_lyb3ra I strictly want something where the control flow is as obvious as possible. This is a deal breaker to me.

just noticed that ReasonML has PPX ("preprocessor extensions"), which means you can do macros for whatever you need at compile-time

so yay I guess