CODEWITHSUNDEEP
scalatypesscala-3
Max
Max

Reputation: 1867

Scala 3 type lambdas. Example for "curried type parameters"

Scala 3 has a powerful mechanism of expressing type constructors via type lambdas.

Even simple type lambdas can do powerful things like expressing partial application of a type constructor (see for ex https://stackoverflow.com/a/75428709/336184 ).

Docs mention "Curried Type Parameters" like

type TL = [X] =>> [Y] =>> (X, Y)

this looks like even more abstract thing.

Question:

Can anyone give a working example with an implementation of such a type lambda? Also - what is a practical purpose of such an abstraction? Any parallels in Haskell?

Upvotes: 0

Views: 207

Answers (1)

Dmytro Mitin
Dmytro Mitin

Reputation: 51658

type TL = [X] =>> [Y] =>> ...

is the same as

type TL[X] = [Y] =>> ...

and should be the same as

type TL[X][Y] = ...

if there were multiple type-parameter lists (MTPL).

So [X] =>> [Y] =>> ... should be a way to introduce such type anonymously.

MTPL along with named type parameters could be useful for specifying some type parameters and inferring the rest of them.

Cannot prove equivalence with a path dependent type

Curried type "does not take type parameters"

https://contributors.scala-lang.org/t/multiple-type-parameter-lists-in-dotty-si-4719/2399

https://github.com/scala/bug/issues/4719

https://docs.scala-lang.org/scala3/reference/experimental/named-typeargs.html

For example specifying some type parameters and inferring the rest can be necessary for type-level calculations. Currently for type-level calculations people either make type parameters nested or use type members instead of type parameters.

When are dependent types needed in Shapeless?

In Haskell you can write

foo :: forall (f :: * -> * -> *) . ()
foo = ()

but in Scala without MTPL implemented, currently you can't write

def foo[F[_][_]]: Unit = ()

you can only write

def foo[F[_,_]]: Unit = ()

If there were MTPL then for a definition like def foo[F[_][_]]... it would be convenient having curried type lambdas [X] =>> [Y] =>> ..., you could use them at a call site foo[[X] =>> [Y] =>> ...].

In Haskell all type constructors are curried and there are no type lambdas

Lambda for type expressions in Haskell?

Upvotes: 2

Related Questions