scaladays.txt

| \rA purely functional approach
| \rto building large applications

| Scala eXchange - 10 December 2015


| Noel Markham - \b@noelmarkham
---
| \rWarning

Sweeping Statements!
---
```
import scalaz._
import Scalaz._

--
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

```
---
```
import com.noelmarkham.scaladays.external.Twitter
```

def getTweets(name: String,
              apiKey: String,
              apiSecret: String): Future[List[Tweet]]

case class UserDetails(screenName: String)
case class Tweet(user: UserDetails, content: String)

--
```
def tweetsFuture =
  Twitter.getTweets("noelmarkham", "key", "secret")
  
Await.result(tweetsFuture, 1.second)
   .take(3)
   .foreach(t => println(s"${t.content}\n"))
```
---
| \bMarkov Chains

--
| "My name is Noel. My name is Christmas in French."
--

| \rContext = 2

[My, name] -> [is]
--
[name, is] -> [Noel, Christmas]
--
...
---
```
import com.noelmarkham.scaladays.external.Markov

```

def generateString(text: String,
                   context: Int): Future[String]

--
```
def tweets = Await.result(tweetsFuture, 1.second)
def randomString = Markov.generateString(
          tweets.map(_.content).mkString(" "), 2)
```

--
```
Await.result(randomString, 1.second)
```
---
| \bWiring the two methods together

--
```
val apiKey = "APIKey"
val apiSecret = "APISecret"
val context = 2

def randString(username: String): Future[String] = for {
  ts <- Twitter.getTweets(username, apiKey, apiSecret)
  tweetsAsText = ts.map(_.content).mkString(" ")
  r <- Markov.generateString(tweetsAsText, context)
} yield r
```
--

```
Await.result(randString("noelmarkham"), 1.second)
```
---
| \bExtracting the configuration
--

```
val strLen: String => Int = _.length
val isEven: Int => Boolean = _ % 2 == 0
```
--

```
val isEvenLengthString = strLen andThen isEven
```
--

\b Functions as functors:

```
val isEvenLengthString = strLen map isEven
```
---
| \bFunctions as functors

```
case class Config(key: String,
                  secret: String,
                  context: Int)
```
--

```
val keyFromConfig: Config => String = _.key
val secretFromConfig: Config => String = _.secret
```
--

```
val keyAndSecret: Config => (String, String) = ???
```
---
| \bval keyAndSecret: Config => (String, String) = ???

```
val keyAndSecret: Config => (String, String) = c => {
  (keyFromConfig(c), secretFromConfig(c))
}
```
--

```
keyAndSecret(Config("k", "s", 3)) === ("k" -> "s")
```
--

| \rShip it!
---
| \bval keyAndSecret: Config => (String, String) = ???
--

| \bFunctions as \rmonads
--

```
val keyAndSecret: Config => (String, String) =
  for {
    k <- keyFromConfig
    s <- secretFromConfig
  } yield (k, s)
```
--

```
keyAndSecret(Config("k", "s", 3)) === ("k" -> "s")
```
---
| \bSeparating the configuration

```
import Twitter.Tweet

def getTweets(username: String):
          Config => Future[List[Tweet]] = c => {

  Twitter.getTweets(username, c.key, c.secret)
}

def generateString(text: String):
          Config => Future[String] = c => {

  Markov.generateString(text, c.context)
}
```
---
| \bFlatMap?
\rReminder:
def getTweets(username: String):
                   Config => Future[List[Tweet]]
def generateString(text: String):
                   Config => Future[String]
--
/
```
def randString(username: String):
                            Config => Future[String]
  for {
    tweets <- getTweets(username)
```
--
    ... ???
--
| \b... lets take a step back
---
| \bReader

```
val keyFromConfig: Config => String = _.key
val secretFromConfig: Config => String = _.secret
```
--
/
```
val keyFromConfig: Reader[Config, String] =
                                       Reader(_.key)

val secretFromConfig: Reader[Config, String] =
                                       Reader(_.secret)
```


```
keyFromConfig.run(Config("key", "secret", 2)) === "key"
```
---
| \bAs before...

```
val keyAndSecret: Reader[Config, (String, String)] =
  for {
    k <- keyFromConfig
    s <- secretFromConfig
  } yield (k, s)
```
--

```
keyAndSecret.run(Config("k", "s", 3)) === ("k" -> "s")
```
---
| \bMonad Transformers

--
| Recap

```
val fo: Future[Option[Int]] = Future(Some(1))
```
--

```
val optionT: OptionT[Future, Int] = OptionT(fo)
```
--

```
val foUpdated = optionT.map(_ + 9)
```
--

```
val newFuture: Future[Option[Int]] = foUpdated.run
```
--

```
Await.result(newFuture, 1.second) === Some(10)
```
---
| \bThe ReaderT monad
--

```
val f: String => Future[Int] = s => Future(s.length)
```
--

```
import Kleisli._

// takes a function, just like the Reader constructor
val reader: ReaderT[Future, String, Int] = kleisli(f)
```
--
```

val mapped = reader.map(_ % 2 == 0)

val futResult: Future[Boolean] = mapped.run("scala days")
```
--

```
Await.result(futResult, 1.second)
```
---
| \bBack to our example
\rWe had:
```
--

def getTweets(username: String):
          Config => Future[List[Tweet]] = c => {

  Twitter.getTweets(username, c.key, c.secret)
}

def generateString(text: String):
          Config => Future[String] = c => {

  Markov.generateString(text, c.context)
}
```
---
| \bBack to our example
\rChanged to:
```
def getTweets(username: String):
      ReaderT[Future, Config, List[Tweet]] = {
  kleisli { c =>
   Twitter.getTweets(username, c.key, c.secret)
  }
}
def generateString(text: String):
      ReaderT[Future, Config, String] = {
  kleisli { c =>
    Markov.generateString(text, c.context)
  }
}
```
---
| \bPlugging the methods together... again!
```
--

def randString(username: String):
                   ReaderT[Future, Config, String] = {
  for {
    tweets <- getTweets(username)
    tweetsAsText = tweets.map(_.content).mkString(" ")
    randomString <- generateString(tweetsAsText)
  } yield randomString
}
```
--

```
def forMe = randString("noelmarkham")
                    .run(Config("apiKey", "secret", 2))
```
--
```
Await.result(forMe, 1.second)
```
---
| \bEasier to test?
--
| \bExtract our two methods:
```
def randString(
   getTweetsF:
     String => ReaderT[Future, Config, List[Tweet]],
   generateTextF:
     String => ReaderT[Future, Config, String]
   )(username: String):
                     ReaderT[Future, Config, String] = {
  for {
    tweets <- getTweetsF(username)
    tweetsAsText = tweets.map(_.content).mkString(" ")
    randomString <- generateTextF(tweetsAsText)
  } yield randomString
}
```
---
| \bTesting

```
import org.scalacheck.Prop.forAll
```
--


\g"org.typelevel" %% "shapeless-scalacheck" % "0.3"

```
import shapeless.contrib.scalacheck._
```
---
```
val prop = forAll { (tweets: List[Tweet]) =>
  def tweetsR(name: String):
               ReaderT[Future, Config, List[Tweet]] = {
    kleisli { _ => Future(tweets) }
  }
  def textR(text: String):
               ReaderT[Future, Config, String] = {
    kleisli { _ => Future(text) }
  }
  val r = randString(tweetsR, textR)("name")
  val receivedText =
     Await.result(r.run(Config("a", "b", 2)), 1.second)

  tweets.all(t => receivedText.contains(t.content))
}
```
---
| \bAbstracting over the ReaderT monad
\rWe had:
```
def randString(
   getTweetsF:
     String => ReaderT[Future, Config, List[Tweet]],
   generateTextF:
     String => ReaderT[Future, Config, String]
   )(username: String):
                     ReaderT[Future, Config, String] = {
  for {
    tweets <- getTweetsF(username)
    tweetsAsText = tweets.map(_.content).mkString(" ")
    randomString <- generateTextF(tweetsAsText)
  } yield randomString
}
```
---
| \bAbstracting over the ReaderT monad

\rWe can change this to:
--
```
def randString[M[_]: Monad](
    getTweetsF: String => M[List[Tweet]],
    generateTextF: String => M[String]
  )(username: String): M[String] = {

  for {
    tweets <- getTweetsF(username)
    tweetsAsText = tweets.map(_.content).mkString(" ")
    randomString <- generateTextF(tweetsAsText)
  } yield randomString
}
```
---
| \bNicer tests!
--

```
val prop = forAll { (tweets: List[Tweet]) =>

  def tweetsF(name: String): Id[List[Tweet]] = tweets
  def textF(text: String): Id[String] = text

  val receivedText = randString(tweetsF, textF)("name")

  tweets.all(t => receivedText.contains(t.content))
}
```
---
| \rNew feature request: logging
--


| def log(text: String): Future[Unit]
---
| \rNew feature request: logging

```
def randString[M[_]: Monad](
    getTweetsF: String => M[List[Tweet]],
    generateTextF: String => M[String],
    logF: String => M[Unit]
  )(username: String): M[String] = {
  for {
    tweets <- getTweetsF(username)
    _ <- logF(s"Received tweets: $tweets")
    tweetsAsText = tweets.map(_.content).mkString(" ")
    randomString <- generateTextF(tweetsAsText)
    _ <- logF(s"Generated $randomString for $username")
  } yield randomString
}
```
---
| \bBack to our test
--
```
type W[X] = Writer[Map[String, Int], X] // brevity here

val prop = forAll { (tweets: List[Tweet]) =>
  def tweetsF(name: String): W[List[Tweet]] =
                         tweets.set(Map("tweets" -> 1))

  def textF(text: String): W[String] =
                         text.set(Map("text" -> 1))

  def logF(text: String): W[Unit] = Map("log" -> 1).tell

  val run = randString(tweetsF, textF, logF)("name").run
  Map("tweets" -> 1, "text" -> 1, "log" -> 1) === run._1
}
```
---
| \bBack to our test
```
type W[X] = Writer[Map[String, Int], X] // brevity here

val prop = forAll { (tweets: List[Tweet]) =>
  def tweetsF(name: String): W[List[Tweet]] =
                         tweets.set(Map("tweets" -> 1))

  def textF(text: String): W[String] =
                         text.set(Map("text" -> 1))

  def logF(text: String): W[Unit] = Map("log" -> 1).tell

  val run = randString(tweetsF, textF, logF)("name").run
  Map("tweets" -> 1, "text" -> 1, "log" -> 2) === run._1
}
```
---
| \bWhat have we achieved?

--
We were given some unhelpful APIs

--
We found a nice way to provide different configurations:
  - Reader and ReaderT monads

--
Made the integration of the APIs easily testable:
 - "Wiring" functions together
 - Abstracting over monads

--
All using some very powerful libraries:
  - Scalaz
  - Scalacheck
  - Shapeless
---
| \rThank you


| Noel Markham - \b@noelmarkham

| ITV are hiring!