Ammonite-Ops VS Shapeless

The indent based syntax is only available in Scala 3, you have to download a matching ammonite version from https://github.com/com-lihaoyi/Ammonite/releases

That's funny, because this is what I really like about Scala; how quick and easy it is to get a project started.

> sbt new scala/scala3.g8

will just create an empty project. If you don't even want to bother with a project, use use scala-cli or ammonite (http://ammonite.io/) to just start banging out code.

Even the upgrading of a project from Scala2 to Scala3 is a breeze, thanks to very good backwards compatibility of new library releases.

Ammonite is a very good REPL for Scala. You can invoke it with amm and type expressions into it, or load a Scala “script file” whose name ends with .sc into it, or many other things. It’s documented at https://ammonite.io. 2. sbt is the dominant build tool for Scala projects. As others have commented, when you open a folder in Visual Studio Code and try to make Metals “aware of it,” it expects to find a “Scala project” in the folder. A “Scala project” isn’t just Scala source code. See https://www.scala-sbt.org for details. 3. Also be aware that Metals supports worksheets, so you can easily experiment with code in your project interactively, too.

Scripting API is quite limited, so the third option. - reuse the ammonite scripts https://github.com/com-lihaoyi/Ammonite or look how this is implemented (using internal compiler API),

Your exposure to Functional Programming with Haskell and Clojure suggest you will certainly pick up Scala quickly. With ZIO and cats, you can write robust software quickly. Consider the excellent Coursera Scala course. Get "the Red Book" https://www.manning.com/books/functional-programming-in-scala, and most important, play. Experiment to see how things work. Get https://ammonite.io/

Here's an example of a smaller project that added telemetry without suffering a fork:

https://github.com/com-lihaoyi/Ammonite/issues/607

Or ammonite - I've ran Gatling performance test from a simple script based on this gist it fetches all the dependencies, compiles and runs the test, producing nice html report..

Scala with the Typelevel ecosystem. Stay on the jVM, but have a much more pleasant and robust experience, including a great REPL.

Scala 2-only: * Shapeless (there is Shapeless for Scala 3 but less often needed as basic things are in Scala 3)

This is the FromMap typeclass in Shapeless. Note that there’s a companion syntax package for it providing .toRecord for any Map and an appropriately-structured Record (and a Record is the LabelledGeneric representation of a case class).

If that's what you want, you can use Shapeless' records and HList. You can probably replicate this in plain Scala 3 with tuples and literal types as you said. It won't play nice with your others libs though but maybe there are integrations.

See the Shapeless Sized example.

Shapeless has Sized: https://github.com/milessabin/shapeless/blob/v2.3.9/core/src/main/scala/shapeless/sized.scala

I know that libraries like Scodec and shapeless were rewritten practically from scratch for Scala 3, taking advantage of the next syntax and internals, as well as protoquill - a Scala 3 implementation of Quill.

please show me something like this: https://akka.io/ or this: https://zio.dev/ or this: https://github.com/milessabin/shapeless

That largely depends on the type system. Languages like Haskell and Scala which have much more powerful type systems than C/Java/Go/etc absolutely do allow you to do those sorts of things. It is a bit harder to wrap your head around to be sure and there are some rough edges, but once you get the hang of it you can get the benefits of static typing with the flexibility of dynamic typing. See https://github.com/milessabin/shapeless or a project that I've been working on a lot lately https://github.com/zio/zio-schema.

Just use cats and use the apply syntax .mapN for this. Seriously. There isn't a way to do it without generating source code that I can see in the api. Scala 3's HList Tuples aren't like Shapeless 2's HLists and I can't figure out a way in the api to reduce the tuple members down from (A, B, C, D) into an E, generically, yet with Scala 3 poly functions, unlike what you could do in Shapeless 2 with HList

Scala has sparked a huge ecosystem of very high quality libraries (Cats, Scalaz, shapeless, to name but a few). I think a major reason for this is that Scala attracts developers who value the advantages of the JVM, but are fed up with the limitations of the Java programming language and understand the benefits of an expressive type system and functional programming.