refined VS Shapeless

Scala has quite good support for refined types across multiple libraries. A solution using the refined library might look something like

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

I'm trying to create a poor man version of refined types implementation with a simple validation of string content and check the return type via Implicit evidence on another function. It seems that the type got erased after it got returned from the check

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.

I think the way you model problems in Ada is superficially similar to refined types you find in some functional languages (e.g. Scala).

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.

Perhaps refined would help you? It lets you set constraints (i.e. "rules") for values / types. You get compile-time enforcement for constants and fallible methods for runtime values (i.e. Either[Error, RefinedValue]).

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.

> Combined with the extremely powerful compile-time reflection capabilities of D it's the closest thing I've seen to Lisp metaprogramming outside of that family of languages ...

Scala gets pretty close to LISP-level of metaprogramming support between its intrinsic support for macros[0] (not to be confused with the C/C++ preprocessor of the same name) the Scalameta project[1], and libraries such as Shapeless[2].

Not comparing Scala to D, just identifying a language with similar functionality.

0 - https://docs.scala-lang.org/scala3/reference/metaprogramming...

1 - https://scalameta.org/

2 - https://github.com/milessabin/shapeless

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