Type Lambdas & Higher Kinds

//> using scala 3.10.0

trait Container[F[_]]:
  def empty[A]: F[A]
  def add[A](fa: F[A], a: A): F[A]

object ListContainer extends Container[List]:
  def empty[A] = Nil
  def add[A](fa: List[A], a: A) = a :: fa

object OptionContainer extends Container[Option]:
  def empty[A] = None
  def add[A](fa: Option[A], a: A) = Some(a)

def fill[F[_]](c: Container[F], xs: Seq[Int]): F[Int] =
  xs.foldLeft(c.empty[Int])(c.add)

@main def run(): Unit =
  println(fill(ListContainer, Seq(1, 2, 3)))
  println(fill(OptionContainer, Seq(1, 2, 3)))

List(3, 2, 1)
Some(3)

//> using scala 3.10.0

trait Container[F[_]]

class Box[A]
class Two[A, B]

val ok: Container[Box] = new Container[Box] {}
val bad: Container[Two] = new Container[Two] {}
val bad2: Container[Int] = new Container[Int] {}

-- Error: b_err.scala:9:19
9 |val bad: Container[Two] = new Container[Two] {}
  |                   ^^^
  |          Type argument Two does not have the same kind as its bound [_$1]
-- Error: b_err.scala:10:20
10 |val bad2: Container[Int] = new Container[Int] {}
   |                    ^^^
   |        Type argument Int does not have the same kind as its bound [_$1]

//> using scala 3.10.0

type Pair = [X] =>> (X, X)
type Named = [X] =>> Map[String, X]
type Const = [A, B] =>> A

trait Functor[F[_]]:
  extension [A](fa: F[A]) def map[B](f: A => B): F[B]

given Functor[List] with
  extension [A](fa: List[A]) def map[B](f: A => B): List[B] = fa.map(f)

given Functor[Pair] with
  extension [A](fa: (A, A)) def map[B](f: A => B): (B, B) = (f(fa._1), f(fa._2))

given [K]: Functor[[V] =>> Map[K, V]] with
  extension [A](fa: Map[K, A]) def map[B](f: A => B): Map[K, B] = fa.map((k, v) => (k, f(v)))

def double[F[_]: Functor](fa: F[Int]): F[Int] = fa.map(_ * 2)

@main def run(): Unit =
  val p: Pair[Int] = (1, 2)
  println(double(List(1, 2, 3)))
  println(double(p))
  println(double(Map("a" -> 10, "b" -> 20)))
  val n: Named[Int] = Map("x" -> 1)
  println(n)
  val c: Const[String, Int] = "const"
  println(c)

List(2, 4, 6)
(2,4)
Map(a -> 20, b -> 40)
Map(x -> 1)
const

//> using scala 3.10.0

type Id = [X] =>> X
type Compose = [F[_], G[_]] =>> [X] =>> F[G[X]]
type ListOfOption = Compose[List, Option]
type Bounded = [X <: AnyVal] =>> List[X]

@main def run(): Unit =
  val a: Id[Int] = 3
  val b: ListOfOption[Int] = List(Some(1), None)
  val c: Bounded[Int] = List(1)
  println((a, b, c))

(3,List(Some(1), None),List(1))

//> using scala 3.10.0

type Bounded = [X <: AnyVal] =>> List[X]
val bad: Bounded[String] = List("a")

-- [E057] Type Mismatch Error: d_err.scala:4:17
4 |val bad: Bounded[String] = List("a")
  |                 ^
  |               Type argument String does not conform to upper bound AnyVal

//> using scala 3.10.0

def head[F[_], A](fa: F[A]): String = fa.toString

@main def run(): Unit =
  println(head(Right(1): Either[String, Int]))
  println(head(Map("a" -> 1)))
  println(head((1, 2)))

Right(1)
Map(a -> 1)
(1,2)

//> using scala 3.10.0

trait Kinded[T <: AnyKind]:
  def name: String

given Kinded[Int] with
  def name = "Int (kind *)"
given Kinded[List] with
  def name = "List (kind * -> *)"
given Kinded[Either] with
  def name = "Either (kind * -> * -> *)"
given Kinded[[F[_]] =>> F[Int]] with
  def name = "[F[_]] =>> F[Int] (kind (* -> *) -> *)"

def describe[T <: AnyKind](using k: Kinded[T]): String = k.name

@main def run(): Unit =
  println(describe[Int])
  println(describe[List])
  println(describe[Either])
  println(describe[[F[_]] =>> F[Int]])

Int (kind *)
List (kind * -> *)
Either (kind * -> * -> *)
[F[_]] =>> F[Int] (kind (* -> *) -> *)

//> using scala 3.10.0

def broken[T <: AnyKind]: Unit =
  val x: T = ???
  ()

def alsoBroken[T <: AnyKind](t: T): Unit = ()

-- [E056] Syntax Error: f.scala:4:9
4 |  val x: T = ???
  |         ^
  |         T cannot be used as a value type
  |
  |         where:    T is a type in method broken with bounds <: AnyKind
-- [E056] Syntax Error: f.scala:7:32
7 |def alsoBroken[T <: AnyKind](t: T): Unit = ()
  |                                ^
  |                                T cannot be used as a value type

//> using scala 3.10.0

trait Functor[F[_]]

val x: Functor[Either[String, *]] = ???

-- [E006] Not Found Error: g_err.scala:5:30
5 |val x: Functor[Either[String, *]] = ???
  |                              ^
  |                              Not found: type *

//> using scala 3.10.0
//> using option -Xkind-projector

trait Functor[F[_]]:
  def map[A, B](fa: F[A])(f: A => B): F[B]

given eitherFunctor: [E] => Functor[Either[E, *]]:
  def map[A, B](fa: Either[E, A])(f: A => B) = fa.map(f)

given Functor[Map[String, *]] with
  def map[A, B](fa: Map[String, A])(f: A => B) = fa.view.mapValues(f).toMap

@main def run(): Unit =
  println(summon[Functor[Either[String, *]]].map(Right(2): Either[String, Int])(_ + 1))
  println(summon[Functor[Map[String, *]]].map(Map("a" -> 1))(_ + 1))
  val x: Functor[λ[x => Either[Int, x]]] = eitherFunctor[Int]
  println(x.map(Left(1): Either[Int, Int])(_ + 1))

Right(3)
Map(a -> 2)
Left(1)