Functional Structures in Scala

• 📆 2019-04-19
• this spans many weeks / investment times
• 📹 Screencast: Functional Structures
• 👨‍💻📝️ an experienced OOP programmer learning FP and Scala
  • and maybe category theory? 🤔

On Kindedness

• Cool REPL command: :k TYPE which reveals the Kind of TYPE 😎
  • e.g.,
    • :k Int => A
    • :k List => F[+A]

Type Constructors

• A Higher Kinded Type

  • can not be the value of an expression.
  • A List (alone) can not be the value of an expression. But, a List[Thinger] can be.
    • List is the Higher Kinded Type
    • Thinger is the Proper Type
  • A Higher Kinded Type can be thought of as a function that takes a Proper Type and returns a new Proper Type
    • i.e., the F[A], or List[Thinger]
    • This is also called a Type Constructor

• When defining a function/method where one argument is the result of applying a Proper Type to a Type Constructor, the TC must also be expressed as a type parameter

  • For type parameters: [F[_], A], the F[_] is a Type Constructor
    • specifically, a Type Constructor with one argument
    • the arg could be List(1) or Some(1) or Right(1)
      • but it can not be an Int / A
  • contrived example:
    • def bar[F[_], A](x: F[A], y: F[A]) = null
    • can be called as: bar(Some(1), Some(2))
    • or: bar(List(1,2,3), List(1)
      • 🤔 📝 : if this is true, then whatabout F[_] "having only one argument?"
    • it can not be called as: bar(Some(1), List(2)) as that uses two different Proper Types (Option and List), and we only define one type parameter (A)

Functors

• Functor - a type class that abstracts over Type Constructors that can define a Map operation
  • 👀 7:30
    • code is more clear there ;)
  • Simply put, its abstraction to define a pattern for how to map from one Higher Kinded Type to another
  • expressed as: trait Functor[F[_]] {}
    • will have a method like: def map[A, B](fa: F[A])(f: A => B): F[B]
    • basically, defining map is half of the definintion of a Functor
    • the other half is the set of rules map must comply with

Functor Laws

• Functor Laws 👩‍⚖️👮
  • the set of rules that define how the Functor maps
  • e.g., an identity law that states that for every function fa: F[A], the result of .map(fa)(a => a) must === fa
    • i.e., def identity[F[_], A](fa: F[A]) = Functor[F].map(fa)(a => a) === fa
      • 📝️ === is not real 🧙
    • 👀 10:32
      • above code is actually a trait outside of the contrived Functor
      • and since the above code lacks the actual ability to perform said mapping, an implicit can be added to do the work:
      • def identity[...](fa...)(implicit F: Functor[F]) = F.map(fa)(a => a) == fa
  • e.g., composition law states that for F and G, we can compose them together as a single function, or, they can be composed piecewise through many functions
    • 👀 13:21 for mention of andThen
    • i.e., 🙃

def composition[F[_], A, B, C](fa: F[A], f: A => B, g: B => C)(implicit F: Functor[F]) =
  F.map(F.map(fa)(f))(g) == F.map(fa)(f andThen g)

• 👀️ 14:05 for examples on Functor instances, via a companion object

  • Functor[List] is a valid functor, as our trait was: Functor[F[_]]
    • this implementation is simple, since List already has a map() method
    • as do most std lib collections (Option, etc)
  • Functor[X => ?] -> a function1Functor
  • 📝️ it does not make sense to define a Functor for a Proper Type 🙃️
  • 📝️ not to be confused with Funktion-One 🎶️
  • 👷‍♀️️ [X => ?] is a Type Constructor such that when a Proper Type, X, is applied to it, you get back a function X => A or X => B etc.
  • 📝️ val can not have a type param, only methods (def)
    • and fyi, a type parameter is required to define the X in [X => ?]
  • function1Functor.map() can begin implementation as:
    • def map[A, B](fa: X => A)(f: A => B): X => B = ...
      oh 💩️, B has no map 🤔️ ⁉
    • we need to return a new function X => B -> the answer is composition
      • andThen 😉️
    • def map[A, B](fa: X => A)(f: A => B): X => B = fa andThen f

• lawfulness is determined by testing the given laws, e.g., identity or
  composition.

  • testing any arbitrary values for the above examples would prove lawfulness
  • 🤔️ so how does one define a chaotic functor? inquiring minds want to know!
    • 😅️ author describes this at 👀️ 23:55
    • def lift[A, B](f: A => B): F[A] => F[B]
      • it is no longer pure as values are wrapped into that context
    • implemented as: def lift[A, B](f: A => B): F[A] => F[B] = fa => map(fa)(f)
      • 🤔️ so where did fa come from?
    • def as[A, B](fa: F[A], b: => B): F[B] = map(fa)(_ => b)
    • def void[A](fa: F[A]): F[Unit] = as(fa, ())

• Break for refreshment @ 27:52

---

• 📆 2019-07-12
• its been maybe 4-5 weeks since I watched this! 😅️

Type Classes

• simulacrum - typeclass library

• provides @typeclass annotation

• @typeclass is an annotation that provides enrichments or extension methods for an F[A]

  • 🧙 magic with super ("scary") complicated types happen ~33:32
    • 📝️ note that searching for Lambda in Scala will probably be painful and not provide any actual information, but also provide tons of information not-about Lambda but perhaps "lambdas" as a concept! Welcome to relying on web searches to learn about Scala!
  • more mysterious things happen with .compose
    • apparently its very powerful! it can do more than the standard library!
      • im not at all clear on what that is, but yah, sure!
        • programmers frickin' love things that are "powerful" 💪️
  • actually, there is a grok'able example @ 37:00
    • Im a believer, but this is still just a matter of faith!
  • apparently, nothing in this section is going "very deep with Functor"
    • but apparently it offers lots of things not in the standard Collections library!
      • which is what all language libraries do, so Im still not sold, at all, on why any of this is important
    • software libraries: they add more power (cool story!)
      • and I guess adding near-infinite increasing complexity somehow lets one get even more power? where is it? what is it? 🤔️
  • author seemed like he was just right about to explain Lambda and then does the typical Scala cultural thing where he talks a lot "about" it and "around" it but doesnt at all explain what it is.
    • are Scalaists really just Daoists? ☯️
      • the type that can be spoken is not the type!
    • holy 💩️ my brain hurts! 🧠️😢️

Structural Type

• a thing that looks like: Functor[({type l[a] = Function1[Int, a] })#l]
  • the {} imply Structural Type.
  • the #l is a Type Projection, which represents the type member l of the structural type (defined in the {})
  • this is a Type Lambda

King Projector

• convience for anonymous Structural Types

  • see cats kind projector
    • this is where Lambda comes from!
      • ok, srsly, how useful is any of this if this much complexity is required?
        • again, WHY is any of this important at all?
        • why not juse use a tool (language) thats much simpler to explain?
  • adds support for F[X => ?] syntax

• The Lambda keyword defines type functions

• 🆒🆒🆒!

  • 🔚

---