JoolsF

import cats.data.Writer
import cats.instances.vector._ // for Monoid
import cats.syntax.applicative._ // for pure
import cats.syntax.writer._
import scala.concurrent._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

type Logged[A] = Writer[Vector[String], A]

JoolsF

import FutureEither.FutureEither
import cats.data.EitherT

import scala.concurrent.{ExecutionContext, Future}

//ServiceError
sealed trait ServiceError {
  val msg: String
}

JoolsF

import akka.Done
import akka.actor._
import akka.stream._
import akka.stream.scaladsl.Source

import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success}


object TestStreamApp extends App {

JoolsF

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

JoolsF

import scala.util.Try
import scala.io.StdIn.readLine

//https://www.youtube.com/watch?v=sxudIMiOo68

object App0 {
  def main: Unit = {
    println("What is your name?")

    val name = readLine()

JoolsF

case class IO[A](unsafeRun: () => A) { self =>
  def map[B](f: A => B): IO[B] = IO(() => f(self.unsafeRun()))

  def flatMap[B](f: A => IO[B]): IO[B] = IO(() => f(self.unsafeRun()).unsafeRun())
}

def funcA(input: String): IO[Unit] = {
  IO(() => println(input))
}

JoolsF

 def squareString(s: String, p: Int => Boolean): Either[String, Int] = {
    Either.fromTry( // Either from Try
      Try {
        val i = s.toInt
        i * i
      }
    ).leftMap { case _: NumberFormatException => "Boom - number format exception!" } // Left map
  }.ensure("result must not equal 9")(p) // Predicate to check with result satisfies a predicate

  val p: Int => Boolean = _ != 9

JoolsF

case class Error(e: String)

/**
  * These “smart constructors” have advantages over Left.apply and Right.apply
  * because they return results of type Either instead of Left and Right.
  * This helps avoid type inference bugs caused by over-narrowing
  */
def sumPositive(l: List[Int]): Either[Error, Int] = {
  l.foldLeft(0.asRight[Error]) { (acc: Either[Error, Int], i: Int) =>
    if (i > 0) {

JoolsF

#!/usr/bin/env bash


DB_USER="???"
DB_PASS="???"
DB_HOST="???"

if [ ! "$DB_USER" ] || [ ! "$DB_PASS" ] || [ ! "$DB_HOST" ]; then
 echo "You need to set DB_USER, DB_PASS and DB_HOST environmental variables."
 exit 1

JoolsF

 private def accumulateErrors[A,B](list: List[A], f: A => B): Either[List[Throwable], List[B]] = {
    val res = list.foldLeft(List[Error](), List[B]()) { case ((accError, accRes), item) =>
      Try(f(item)).toEither match {
        case Right(i) => (accError, accRes :+ i)
        case Left(e) => (accError :+ new Error(e), accRes)
      }
    }
    if(res._1.isEmpty) Right(res._2) else Left(res._1)
  }