lemastero

/**
  * Edward Kmett Discrimination is Wrong: Improving Productivity
  * http://yowconference.com.au/slides/yowlambdajam2015/Kmett-DiscriminationIsWrong.pdf
  */
object MonoidalCategoriesForCategoryOfScalaTypes {
  import scala.language.higherKinds

  trait Bifunctor[P[_,_]] {
    def bimap[A, B, C, D](f: A => B, g: C => D): P[A, C] => P[B, D]
  }

lemastero

import scala.language.higherKinds

/*
 Mainline Profunctor Heirarchy for Optics: https://r6research.livejournal.com/27476.html
 Profunctor Optics: The Categorical Approach - Bartosz Milewski: https://www.youtube.com/watch?v=l1FCXUi6Vlw
*/
object ProfunctorOpticsSimpleImpl {

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

lemastero

sealed trait Interact[A]

case class Ask(prompt: String)
  extends Interact[String]

case class Tell(msg: String)
  extends Interact[Unit]

trait Monad[M[_]] {
  def pure[A](a: A): M[A]

lemastero

trait λ {
  type α
}

trait Functor extends λ {
  type α <: λ

  def map[A,B](x: α { type α = A })(f: A => B): α { type α = B }
}

lemastero

import scalaz._, Scalaz._

// Adjunction between `F` and `G` means there is an
// isomorphism between `A => G[B]` and `F[A] => B`.
trait Adjunction[F[_],G[_]] {
  def leftAdjunct[A, B](a: A)(f: F[A] => B): G[B]
  def rightAdjunct[A, B](a: F[A])(f: A => G[B]): B
}

// Adjunction between free and forgetful functor.

lemastero

/** Showing with Kind-Polymorphism the evidence that Monad is a monoid in the category of endofunctors */
object Test extends App {

  /** Monoid (https://en.wikipedia.org/wiki/Monoid_(category_theory))
    * In category theory, a monoid (or monoid object) (M, μ, η) in a monoidal category (C, ⊗, I)
    * is an object M together with two morphisms
    *
    * μ: M ⊗ M → M called multiplication,
    * η: I → M called unit
    *

lemastero

swap (a, b) = (b, a)

class Profunctor p where
  dimap :: (aa -> a) -> (b -> bb) -> p a b -> p aa bb

  lmap ::  (aa -> a) ->              p a b -> p aa b
  lmap f = dimap f id

  rmap ::               (b -> bb) -> p a b -> p a  bb
  rmap = dimap id

lemastero

{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}   
                                                           
import Control.Applicative
import Data.Char
import Data.List (intersperse)
import Data.Monoid hiding (All, Any)
import Data.Foldable hiding (all, any)
import Prelude hiding (all, any)

lemastero

{-# OPTIONS_GHC -Wall #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE StandaloneDeriving #-}

lemastero

import scalaz.{Comonad, Monad}
import scalaz.{Arrow, Contravariant, Profunctor}
import scalaz.{Lan, Ran}

object AnyAndNothingInstances {

  // Monad
  // https://twitter.com/runarorama/status/1085383309969014784
  type FYea[A] = Any