refined VS Ammonite-Ops

Does the Refined library for Scala (at https://github.com/fthomas/refined; "eu.timepit" %% "refined") work in Scala 3? Does it work differently?

Scala likes to do design-by-contract on the type level. You encode your pre- and post- conditions into types. Libraries like iron (scala 3) https://github.com/Iltotore/iron and refined (scala 2) https://github.com/fthomas/refined allow you to do all that without throwing any exceptions and they can even enforce some simple predicates at compile time.

Annotation is not the only way (and probably not the best IMHO) to do refined types. You might be interested in Iron in Scala 3 or Refined in Scala 2/3.

In one respect, nothing. You’re right. Even given refinement types as in Haskell or Scala, there is indeed a necessarily-partial function (refineV in Scala) to refine a value to its refinement type.

This is more or less how derivation works when you want to use something like Refined types (it exposes Validate[Type, Refinement] typeclass if I remember correctly). Enumeratum exposes Enum[A], and newtypes expose Coercible[From, To].

You will probably be interested into Iron or Refined.

You want either a refined type, a newtype, or if you are in Scala 3 an opaque type.

This example uses probably the most popular JSON library for Scala, Circe. There is another Scala library that lets us "be more specific with," or "refine," our types, called Refined. http4s doesn't provide any particular support for Refined, but Circe has a module integrating Refined, meaning that all of Circe's parsing, encoding, and decoding support is integrated with Refined. Putting together http4s' Circe support, Circe's generic codec derivation, and Circe's Refined integration, here's what I came up with:

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.

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),

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.

If you are installing, and you are learning, I would also recommend ammonite as an easier REPL.

I've been using amm on and off https://ammonite.io/#Ammonite-Shell

pretty nice if you know scala, still have to use regular shell(s) so I do not forget them

I've never tested Ammonite, only read the https://ammonite.io/#Ammonite-Shell, so I'm only guessing here.

From what I understand, Ammonite was designed as a "readline shell" as I wrote in the article. It perpetuates this approach that everything is a command.

The thesis of my article suggests we do the opposite: I'm suggesting to rethink shells by starting from the interface (here the SLY REPL) and then implement the shell features.

In particular, it seems that Ammonite does not support back-references and I'm not sure it has an interactive inspector.

While Ammonite seems to be a definite improvement over the _syntax_ of Bash, etc., I'm not sure it brings much novelty in terms of user interface. But again, I know very little about it so I may have missed some features :)

I wonder what people think about Ammonite (https://ammonite.io/)?

It's not Lisp but Scala so may not be the authors language of choice however it can be used as a Shell: https://ammonite.io/#Ammonite-Shell

I am personally using it and compared to a classical shell like Bash it's really nice for more structured data related tasks (exploring some API, checking some data, creating a bunch of PRs at once, ...).

It also makes use of Scala's adjustable syntax and functional concepts so you basically get shell piping but in a strongly typed fashion (e.g.