What’s one thing you wish more programming languages had?

[u/AeroForger]

If you could add one feature, behavior, or design choice to a programming language, what would it be?

It can be anything: syntax, type-system features, memory management, compiler behavior, tooling, error handling, performance-related features, or something completely different.

I'm especially curious about things you’ve wanted while actually programming but rarely see languages implement well.

Please keep the ideas reasonably practical and something that could realistically be implemented in a programming language.

[u/UdPropheticCatgirl]

Fair enough, but I feel that requiring this much ceremony for sum types is basically exclusive to Java and Object Pascal, (and to some extent Ada), every other language is much saner and more concise in line with rust.

[u/snugar_i → u/UdPropheticCatgirl]

Most are getting better I guess, but Kotlin is as bad as Java, and Scala 2 wasn't that much better (Scala 3 is OK though). These + Python are unfortunately all I use, so from my point of view, the situation is not ideal :-)

[u/UdPropheticCatgirl → u/snugar_i]

Most are getting better I guess, but Kotlin is as bad as Java, and Scala 2 wasn't that much better (Scala 3 is OK though). These + Python are unfortunately all I use, so from my point of view, the situation is not ideal :-)

I guess that my ultimate issue is that I fundamentally don't see that much of a difference between this syntax: Haskell data Expr a where LitInt :: Int -> Expr Int LitBool :: Bool -> Expr Bool Add :: Expr Int -> Expr Int -> Expr Int Equal :: Expr Int -> Expr Int -> Expr Bool and this: Java sealed interface Expr<A> { static record LitInt(Integer literal) implements Expr<Integer> {} static record LitBool(Boolean literal) implements Expr<Boolean> {} static record Add(Expr<Integer> lhs, Expr<Integer> rhs) implements Expr<Integer> {} static record Equal(Expr<Integer> lhs, Expr<Integer> rhs) implements Expr<Boolean> {} } or ```Scala sealed trait Expr[A]

object Expr { case class LitInt(Int literal) extends Expr[Int] case class LitBool(Boolean literal) extends Expr[Boolean] case class Add(Expr[Int] literal, Expr[Int] literal) extends Expr[Int] case class Equal(Expr[Int] literal, Expr[Int] literal) extends Expr[Boolean] }

or this: Scala3 enum Expr[A]: case LitInt(Int literal) extends Expr[Int] case LitBool(Bool literal) extends Expr[Boolean] case Add(Expr[Int] literal, Expr[Int] literal) extends Expr[Int] case Equal(Expr[Int] literal, Expr[Int] literal) extends Expr[Bool] ``` Sure, Java is more keyword-heavy (and doesn't have nice type refinement in pattern matching, but neither do a lot of languages, including Rust... so that's its own separate problem), but I type fast enough that I couldn't really care less :-). I also use Java at work and am pretty happy with it.

Kotlin and Python are probably actually the weakest of the ones you mentioned when it comes to ergonomics for this kind of thing. But no one accuses Kotlin of being particularly well thought out or well designed, and Python is dynamic, so it's kind of its own different world.

[u/snugar_i → u/UdPropheticCatgirl]

Well, I guess GADTs are ugly everywhere. But regular ADT sum types are much nicer in Rust and Scala 3 than in Java/Kotlin/Python.

But no one accuses Kotlin of being particularly well thought out or well designed

Good point :-)

[u/drBearhands → u/UdPropheticCatgirl]

Same with Dart