Types, Kinds and Type Constructors in Scala | Rock the JVM

[@daniellopes6874]

Next stop: type lambdas and partially applied types, which I personally still find hard to grasp. Some people refer to type constructors as types with holes you need to fill to get a well formed type. As you mentioned lifting functions mentally to the type level can help understand the concepts. What I found interesting about generics and generic functions in particular is that they limit the possible implementations and help alot when it comes to reasoning by only looking at the types.

[@rockthejvm]

Yep - type lambdas coming in the next video tomorrow!

[@ravisubramanian919]

Superb explanation! Thank you!

[@HPA97]

Great explanation!

[@AmitPrasadbangalore]

Thank you Daniel, this is very crisp and clear , however I'm just wondering for
Option[Seq[]] , why my code is not compiling
It is something like
trait CustomContainer[F[C[_]]] {
def filterByQueryParameters[A, B](container: F[A])(f: A => B): F[B]
}
But this is not working for Option[Seq[CaseClass]], could you please spot what I'm missiing here. Thanks

[@joan38]

Really good videos. Super clear, super detailed.

[@rockthejvm]

Glad to hear it!

[@PlatinumDragonProductions999]

Thank you for all of your Scala videos, I am learning a lot from them :-)

[@rockthejvm]

Glad they're useful!

[@hotharvey2]

So, considering an Option[+A] - where I can create an Option[List[Int]], would it be correct that Option[+A] is only a level 1 type because the API of Option never interacts with the inner type?

[@rockthejvm]

It's a "level-1" type in the video, yes - not sure what you mean by "never interacts with the inner type".

[@hotharvey2]

@@rockthejvm Thank you. I mean that no method on Option will need to call any method on the Int, only the List

[@jogatavid]

What an incredible explanation thank you

[@rockthejvm]

Happy it clicked!

[@imranhossainfaruk5445]

Hi Daniel,
Thanks a lot for the nice video.
I am confused about a particular scenario, I have tried to summarize the scenario in dummy code( it does not compile). Could you please help me understand how can the scenario be achieved?
trait GenericFlatten[F[G[T]]]{ // sample concrete type List[Set[Int]] or Seq[List[String]]
def flatten(input: F[G[T]]): F[T]
// F[G[T]] => List[Set[Int]] , F[T] => List[Int]
}

implicit object GenericFlattenListSetInt extends GenericFlatten[List[Set[Int]]]{
override def flatten(input: List[Set[Int]]): List[Int] = input.flatMap(_.toList)
}

def getFlattenCollection[F[G[T]]](input : F[G[T]])(implicit gf : GenericFlatten[F[G[T]]]): F[T] ={
gf.flatten(input)
}
val listOfSet: List[Set[Int]] = List(Set(1,2), Set(2,3))
val flattenList = getFlattenCollection(listOfSet)

// expected output is 1,2,2,3

[@rockthejvm]

Hi Imran, it's certainly possible, only that you can't pass all the type arguments nested like that. You can do this:
trait GenericFlatten[F[_], G[_], T] {
def flatten(input: F[G[T]]): F[T]
}
implicit object GenericFlattenListSetInt extends GenericFlatten[List, Set, Int]{
override def flatten(input: List[Set[Int]]) = input.flatMap(_.toList)
}
def getFlattenCollection[F[_], G[_], T](input : F[G[T]])(implicit gf : GenericFlatten[F, G, T]): F[T] ={
gf.flatten(input)
}

[@imranhossainfaruk5445]

@@rockthejvm Thank you very much, Daniel.

[@dhirendrapandit5530]

I loved this explanation

[@rockthejvm]

Glad you liked it!

[@ThePyroJoke]

Awesome video! Almost a super power of explaining complex abstract stuff in simple words :)
One question to clarify: when you defined functorList as new Functor[List] that became level-1 type or level-0 type?

[@rockthejvm]

If you can attach it to a value, that's a level-0 type in this terminology.

[@daniellopes6874]

I think they call it proper type or value type but I like your level scheme more intuitive. If you need a good reading before going to sleep 😬 scala-lang.org/files/archive/spec/2.13/03-types.html

[@anticipayo]

Can you put out a video that explains the placeholder ? or * for higher kind types as supposed to _? Thanks for the video

[@rockthejvm]

Those placeholders will probably not be needed too much now with proper type lambda syntax in Scala 3 th-cam.com/video/b1C8ybLpzUc/w-d-xo.html

[@pr0master]

Amazing video, thank you very much!!

[@rockthejvm]

Glad you liked it!

[@TheProximator]

Very nice video, waiting next :)

[@aviadshiber6232]

Great explanation! can you explain in other videos on shapeless?

[@rockthejvm]

Noted - will have something on shapeless as well

[@kevalan1042]

What would be awesome is to give code examples where a higher level type can simplify a codebase

[@rockthejvm]

A subject for some 2-hour video! This would require some longer-form tutorial.

[@RobinHillyard]

Good description but you might want to show what you can actually do with something like your functorList.

[@RomanArkharov]

Thank you for the video and light theme in IDE :)

[@WA9NNN]

I find the light theme much easier to read. Thanks.

[@robert33232]

HashMap - why not just call it Dict? 🙂