fsarradin

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

case class IO[+A](run: () => A)
object IO {
  def pure[A](a: => A): IO[A] = IO(() => a)

  implied IOFunctor for Functor[IO] {

fsarradin

import com.twitter.chill.Externalizer
import org.apache.spark.sql._
import org.apache.spark.sql.expressions.UserDefinedFunction
import org.apache.spark.sql.functions._
import scala.reflect.runtime.universe._

object TestMain {
  def main(args: Array[String]): Unit = {
    val spark: SparkSession =
      SparkSession

fsarradin

import java.lang.management.ManagementFactory
import java.net.{InetAddress, NetworkInterface}

object Main {

  import scala.collection.JavaConverters._

  def main(args: Array[String]): Unit = {
    val localHost = InetAddress.getLocalHost
    println(localHost)

fsarradin

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

fsarradin

import cats.data.State
import cats.free.Free
import cats.free.Free.liftF
import cats.kernel.Monoid
import cats.~>

type Amount = Double

// ADT for bank operations
sealed trait BankOperation[A]

fsarradin

data BBool a b = BTrue a | BFalse b deriving (Show)

true :: a -> BBool a b
true a = BTrue a

trueMap :: (a -> b) -> BBool a c -> BBool b c
trueMap f (BTrue x) = BTrue (f x)
trueMap _ (BFalse x) = BFalse x

fsarradin

object PageRank {

  def main(args: Array[String]): Unit = {
    val graph = Map(
      "A" -> List("B", "C"),
      "B" -> List("C"),
      "C" -> List("A")
    )

    val init = Map(

fsarradin

import akka.actor.ActorSystem
import akka.stream.ActorMaterializer
import akka.stream.scaladsl.{Sink, Source}
import com.softwaremill.react.kafka.{ConsumerProperties, ReactiveKafka}
import org.apache.kafka.common.serialization.StringDeserializer

object MainConsumer {

  def main(args: Array[String]): Unit = {
    implicit val actorSystem = ActorSystem("TestKafka")

fsarradin

package me.conway

import me.conway.cell.{Cells, Location}
import org.scalatest.{Matchers, FunSuiteLike}

import scala.language.implicitConversions

class CellsTest extends FunSuiteLike with Matchers {

  implicit def tuple2Location(t: (Int, Int)): Location = Location(t._1, t._2)

fsarradin

package me.mixin;

import java.util.Map;
import java.util.WeakHashMap;

import static java.util.Collections.synchronizedMap;

public class MixinMain {

    interface WithName {