Python-like decorator annotation?

[Lumintorious]

With the compile-time inline functions we have nowadays, a decorator system could be implemented.

inline def nonNegative(inline fn: Int => Int): Int => Int = (i: Int) => Math.abs(fn(i))

@nonNegative
def pow3(i: Int): Int = i * i * i
// transformed to
val pow3 = nonNegative { (i: Int) => i * i * i }

pow3(-2) // +8

inline def quotedOutput[T <: Product](inline fn: T => String): T => String = (t: T) => "\"" + fn(t) + "\""

case class User(name: String, birthYear: Int)

@quotedOutput
def userSignature(user: User): String = s"${user.name} @ ${user.birthYear}"

userSignature(User("Mike", 1990)) // "Mike @ 1990" (with actual `"` chars in the string)

This would make def declarations more readable and more reusable, without having to transform it into a function val.
I don't know how the this could be passed, maybe as a given in the decorator. Context functions and Polymorphic functions would make this quite elegant.

type GenericDecorator = [Self, In, Out] => (Self ?=> In => Out) => (Self ?=> Int => Out)

[smarter]

If you replace a def with a val you:

• break overriding
• break overloading
• cause extra allocations

Not to mention you cannot do it for defs with default parameters or repeated arguments. So I don't think having code that uses "def" but actually behaves as if it was a val is a good idea, it's already hard enough for people to understand the difference between these two concepts without complicating things further. But the basic idea of having macros that transform code existed in Scala 2 as macro annotations and that might be brought back in a more controlled form in Scala 3.

[Lumintorious]

Alright, the idea was that defs would be altered and still compiled to defs before runtime, so no vals, more like a macro annotation that is controlled, and if that is coming in such a way, i suppose code transformation like this would be possible without a special case.