: D](ancestor: A, descendant: D)
12 |
13 | val grandParentToChild =
14 | new HeirloomTransition(new Grandparent, new Child)
15 |
16 | // Task (4a) -- not an answer, given
17 | // val childToGrandparent =
18 | // new HeirloomTransition(new Child, new Grandparent)
19 |
20 |
21 | }
22 |
23 |
--------------------------------------------------------------------------------
/sbtTutorial/multi/build.sbt:
--------------------------------------------------------------------------------
1 |
2 |
3 | lazy val commonSettings = Seq(
4 | scalaVersion := "2.11.8"
5 | )
6 |
7 | // Set sub-project on SBT start: http://stackoverflow.com/a/22240142/1007926
8 | lazy val root = (project in file(".")).
9 | settings(
10 | onLoad in Global := { Command.process("project backend", _: State) } compose (onLoad in Global).value
11 | ).settings(commonSettings: _*)
12 |
13 |
14 | lazy val backend = (project in file("backend")).
15 | settings(
16 | name := "backend",
17 | version := "1.0"
18 | ).settings(commonSettings:_*)
19 |
20 | lazy val frontend = (project in file("frontend")).
21 | settings(
22 | name := "frontend",
23 | version := "1.0"
24 | ).settings(commonSettings:_*).dependsOn(backend)
25 |
26 |
27 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture5/LookandSaySpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 | import org.scalatest._
4 | import org.scalatest.{FunSuite, Matchers}
5 |
6 | class LookandSaySpec extends FunSuite with Matchers {
7 |
8 | import LookAndSay._
9 |
10 | // val lookAndSaySequence =
11 | // List(1, 1, 1, 3, 1, 2, 2, 1, 1, 3, 3, 1, 1, 2, 1, 3, 2, 1, 1, 3, 2, 1, 2, 2, 2, 1)
12 |
13 | val lookAndSay10 = "13211311123113112211"
14 |
15 | // test(s"10th string in Look and Say sequence is correct: "+lookAndSay10) {
16 | // val result = lookAndSay.
17 | // take(10).
18 | // toListFinite(10)
19 |
20 | // val tenth = result(9)
21 |
22 | // tenth should be (lookAndSay10)
23 |
24 | // }
25 |
26 | }
27 |
28 |
29 |
--------------------------------------------------------------------------------
/sbtTutorial/usingBreezeRefactored/project/Common.scala:
--------------------------------------------------------------------------------
1 | // taken from https://github.com/TrueCar/mleap/blob/master/project/Common.scala
2 |
3 | import sbt._
4 | import Keys._
5 |
6 | object Common {
7 |
8 | // emulate this: https://github.com/TrueCar/mleap/blob/master/project/Common.scala
9 |
10 | // Task 5b
11 | // use Scala 2.11.8
12 | val scalaVer: String = ???
13 |
14 | /*
15 | http://www.scala-sbt.org/0.13/docs/Resolvers.html
16 |
17 | Add resolvers
18 | "bintray/non" at "http://dl.bintray.com/non/maven",
19 | and
20 | "Sonatype Releases" at "https://oss.sonatype.org/content/repositories/releases/"
21 | */
22 |
23 | // Task 5c
24 | lazy val otherResolvers: Seq[Resolver] = ???
25 |
26 | // Task 5a and Task 5g
27 | lazy val commonSettings: Seq[Def.Setting[_]] = ???
28 |
29 | }
30 |
31 |
--------------------------------------------------------------------------------
/tutorialCommon/src/main/scala/com/datascience/education/tutorialCommon/lecture4/EmployeesTypeclass.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorialCommon.lecture4
2 |
3 | import java.util.UUID
4 |
5 | /*
6 | With duplicate definitions of Email, Employee,
7 | and the object that contains the exercises - Employees,
8 | all three of these must be abstractly referenced in these test definitions.
9 | Employee and Employees both necessitate their own typeclass.
10 |
11 | */
12 |
13 | trait EmployeeTypeclass[Email] {
14 | val id: UUID
15 | val email: Email
16 | }
17 |
18 | abstract class EmployeesTypeclass[Employee, Email](
19 | implicit et: Employee => EmployeeTypeclass[Email]) {
20 |
21 | val prianna: Employee
22 | val peter: Employee
23 | val chrisId: UUID
24 |
25 | def employeeEmail(id: UUID): Option[Email]
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/XorList.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import cats.data.Xor
4 | import cats.data.Xor.Left
5 | import cats.data.Xor.Right
6 |
7 | import cats.data.NonEmptyList
8 |
9 | object XorList {
10 | import TraverseXor._
11 | // type XorListException[B] = Xor[NonEmptyList[Exception], B]
12 |
13 | def map2[A, B, C](xorA: XorException[A], xorB: XorException[B])(f: (A, B) => C): XorListException[C] = (xorA, xorB) match {
14 | case (Left(e1), Left(e2)) =>
15 | Left(NonEmptyList(e1, e2)): XorListException[C]
16 | case (Left(e1), Right(b)) =>
17 | Left(NonEmptyList(e1)): XorListException[C]
18 | case (Right(a), Left(e2)) =>
19 | Left(NonEmptyList(e2)): XorListException[C]
20 | case (Right(a), Right(b)) =>
21 | Right(f(a, b))
22 | }
23 |
24 | }
25 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture5/ScanAverage.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 | import com.twitter.algebird.AveragedValue
4 | import com.twitter.algebird.AveragedGroup
5 |
6 | import com.datascience.education.common.lecture5.Stream
7 |
8 |
9 |
10 | object ScanRightExample extends App {
11 |
12 | // 2a
13 | val sum10 = Stream.from(0).take(6).scanRight(0)(_+_)
14 |
15 | sum10.print(10)
16 |
17 |
18 | }
19 |
20 | object Average {
21 |
22 | val incrementingNumbers: Stream[Int] = Stream.from(0)
23 |
24 | // Task 2b
25 |
26 | val average: Stream[AveragedValue] = ???
27 | // incrementingNumbers.take(32).???
28 |
29 | }
30 |
31 | object AverageExample extends App {
32 |
33 | import Average._
34 |
35 | println("average of incrementing numbers")
36 |
37 | average.print(32)
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/XorHelpers.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import cats.data.Xor
4 | import cats.data.Xor.Left
5 | import cats.data.Xor.Right
6 | import cats.data.NonEmptyList
7 |
8 |
9 | object XorHelpers {
10 |
11 | def concatIntoNonEmptyList[A](nel: NonEmptyList[A], l: List[A]): NonEmptyList[A] =
12 | NonEmptyList(nel.head, nel.tail:::l)
13 |
14 | def concatIntoList[A](nel: NonEmptyList[A], l: List[A]): List[A] =
15 | nel.head::nel.tail:::l
16 |
17 | def concat[A](nel1: NonEmptyList[A], nel2: NonEmptyList[A]): NonEmptyList[A] =
18 | NonEmptyList(nel1.head, nel2.head::nel1.tail:::nel2.tail)
19 |
20 |
21 | def toString[A](nel: NonEmptyList[A]): String = {
22 | val h = nel.head
23 | val t = nel.tail
24 | h.toString + " " + t.foldRight("")(_+" "+_)
25 | }
26 |
27 | }
28 |
--------------------------------------------------------------------------------
/project/plugins.sbt:
--------------------------------------------------------------------------------
1 | resolvers ++= Seq(
2 | "bintray-sbt-plugins" at "http://dl.bintray.com/sbt/sbt-plugin-releases",
3 | "Sonatype Releases" at "https://oss.sonatype.org/content/repositories/releases/",
4 | "Artima Maven Repository" at "http://repo.artima.com/releases",
5 | "clojars" at "https://clojars.org/repo",
6 | "conjars" at "http://conjars.org/repo",
7 | "plugins" at "http://repo.spring.io/plugins-release",
8 | "sonatype" at "http://oss.sonatype.org/content/groups/public/"
9 | )
10 |
11 | // addSbtPlugin("org.spark-packages" % "sbt-spark-package" % "0.2.4")
12 |
13 | addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "0.14.3")
14 |
15 | addSbtPlugin("com.artima.supersafe" % "sbtplugin" % "1.1.0")
16 |
17 | addSbtPlugin("org.scoverage" % "sbt-scoverage" % "1.3.5")
18 |
19 | addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.3.3")
20 |
21 | addSbtPlugin("com.thoughtworks.sbt-api-mappings" % "sbt-api-mappings" % "0.2.3")
22 |
23 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture1/ImplicitConversions.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture1
2 |
3 |
4 | // Task (5a): decide where the implicit conversion should go; implement it
5 |
6 | object ImplicitConversions {
7 |
8 | type ComplexNumber = (Double, Double)
9 |
10 | trait ComplexVector {
11 | def complexVector: List[ComplexNumber]
12 | override def toString = s"Vector contains $complexVector"
13 | }
14 |
15 |
16 | object ComplexVectors {
17 | def dense(firstValue: ComplexNumber, otherValues: ComplexNumber*): ComplexVector =
18 | new ComplexVector {
19 | val complexVector = firstValue :: otherValues.toList
20 | }
21 | }
22 |
23 |
24 | // val denseInts = ComplexVectors.dense(4, 2, 6, 9)
25 |
26 |
27 | }
28 |
29 | object ImplicitConversionsExample extends App {
30 | import ImplicitConversions._
31 |
32 | // println("Dense Ints")
33 | // println(denseInts)
34 |
35 | }
36 |
37 |
38 |
39 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture4/FlawedOptionSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import org.scalatest.{FunSuite, Matchers}
4 |
5 | class FlawedOptionSpec extends FunSuite with Matchers {
6 |
7 | test("Methods in FlawedOption should not compile when the type parameter of `FlawedOption` is invariant") {
8 | """
9 | sealed trait FlawedOption[A] {
10 | import FlawedOption._
11 |
12 | def map[B](f: A => B): FlawedOption[B] = this match {
13 | case FlawedSome(a) => FlawedSome(f(a))
14 | case FlawedNone => FlawedNone
15 | }
16 |
17 | def getOrElse(default: => A): A = this match {
18 | case FlawedSome(a) => a
19 | case FlawedNone => default
20 | }
21 | }
22 |
23 | object FlawedOption {
24 | case class FlawedSome[A](get: A) extends FlawedOption[A]
25 | case object FlawedNone extends FlawedOption[Nothing]
26 | }
27 | """ shouldNot compile
28 | }
29 |
30 | }
31 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/WebFormVerifier.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | trait WebFormVerifier[+P[_,_] <: Product] {
4 |
5 | private case class VerifiedWebFormImpl(
6 | firstName: String, lastName: String,
7 | phoneNumber: Long, email: String) extends VerifiedWebForm
8 |
9 | protected def constructVerifiedWebForm(
10 | firstName: String, lastName: String,
11 | phoneNumber: Long, email: String): VerifiedWebForm =
12 | VerifiedWebFormImpl(firstName, lastName, phoneNumber, email)
13 |
14 | def isAlpha(string: String): P[String, String]
15 |
16 | def minimumLength(minLength: Int)(string: String): P[String, String]
17 |
18 | def verifyName(name: String): P[String,String]
19 |
20 | def numDigits(num: Long, length: Int): P[String, Long]
21 |
22 | def verifyPhoneNumber(phoneNumber: Long): P[String, Long]
23 |
24 | def verifyEmailAddress(emailAddress: String): P[String, String]
25 |
26 |
27 | def verify(unverifiedWebForm: UnverifiedWebForm): P[String, VerifiedWebForm]
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture4/EmptySetSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import com.datascience.education.tutorialCommon.lecture4.EmptySetTypeclass
4 | import com.datascience.education.tutorialCommon.lecture4.CommonEmptySetSpec
5 |
6 | object EmptySetSpec {
7 |
8 | implicit val emptySetTypeclass = new EmptySetTypeclass {
9 |
10 | def sumList(l: List[Int]): Int = EmptySet.sumList(l)
11 | def prodList(ds: List[Double]): Double = EmptySet.prodList(ds)
12 |
13 | def sumList2(l: List[Int]): Int = EmptySet.sumList2(l)
14 | def prodList2(l: List[Double]): Double = EmptySet.prodList2(l)
15 |
16 | def sum(l: List[Int]): Option[Int] = EmptySet.sum(l)
17 |
18 | def product(l: List[Double]): Option[Double] = EmptySet.product(l)
19 |
20 | def sum2(l: List[Int]): Option[Int] = EmptySet.sum2(l)
21 |
22 | def product2(l: List[Double]): Option[Double] = EmptySet.product2(l)
23 |
24 |
25 | }
26 |
27 | }
28 |
29 | import EmptySetSpec._
30 |
31 | // class EmptySetSpec
32 | // extends CommonEmptySetSpec()(emptySetTypeclass)
33 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture5/QuickSortSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 | import org.scalatest._
4 | import prop._
5 | import org.scalacheck.Gen
6 | import org.scalacheck.Prop
7 | import org.scalacheck.Prop._
8 | import org.scalatest.prop.Checkers.check
9 |
10 |
11 | class QuickSortSpec extends PropSpec
12 | with GeneratorDrivenPropertyChecks with Matchers {
13 | import QuickSort._
14 |
15 | // property("QuickSort on List sorts 16 integers") {
16 | // forAll(
17 | // Gen.listOfN(16, Gen.chooseNum(Integer.MIN_VALUE, Integer.MAX_VALUE))
18 | // ) { unsorted =>
19 | // val correctSorted = unsorted.sorted
20 | // val sorted = quickSort(unsorted).toListFinite(20)
21 | // // http://www.scalatest.org/user_guide/using_matchers#logicalExpressions
22 | // // (
23 | // // correctSorted should be (unsorted)
24 | // // and sorted should be (unsorted)
25 | // // ) or (
26 | // // sorted should be (correctSorted)
27 | // // and sorted should not be (unsorted)
28 | // // )
29 |
30 | // sorted should be (correctSorted)
31 | // }
32 |
33 | // }
34 |
35 | }
36 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture5/Interpolation.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 | import com.datascience.education.common.lecture5.Stream
4 | import com.datascience.education.common.lecture5.Empty
5 | import com.datascience.education.common.lecture5.Cons
6 | import com.datascience.education.common.lecture5.Stream._
7 |
8 |
9 | object Sine {
10 |
11 | def sinePositive: Stream[Double] =
12 | Stream.cons(0,
13 | Stream.cons(1.0/2,
14 | Stream.cons(math.sqrt(3)/2,
15 | Stream.cons(1.0,
16 | Stream.cons(math.sqrt(3)/2,
17 | Stream.cons(1.0/2, sineNegative)
18 | )
19 | )
20 | )
21 | )
22 | )
23 |
24 | def sineNegative: Stream[Double] =
25 | sinePositive.map { d => -1*d }
26 |
27 |
28 | val sine = sinePositive
29 |
30 |
31 | }
32 |
33 |
34 |
35 |
36 | object Stepper {
37 | import Sine._
38 |
39 | val stepperSine = sine.flatMap { d =>
40 | Stream.cons(d, Stream.cons(d, Stream.empty))
41 | }
42 |
43 |
44 | }
45 |
46 |
47 |
48 | object Interpolation {
49 |
50 | import Sine._
51 |
52 | // Task 1a
53 | val linearInterpolated: Stream[Double] = ???
54 |
55 |
56 |
57 | }
58 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture1/Hierarchy.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture1
2 |
3 | import scala.language.implicitConversions
4 |
5 | object Hierarchy extends App {
6 |
7 | import org.json4s._
8 | import org.json4s.native.JsonMethods._
9 |
10 |
11 | val json1 = """
12 | {
13 | "firstName": "John",
14 | "lastName": "Smith",
15 | "isAlive": true,
16 | "age": 25,
17 | "address": {
18 | "streetAddress": "21 2nd Street",
19 | "city": "New York",
20 | "state": "NY",
21 | "postalCode": "10021-3100"
22 | },
23 | "phoneNumbers": [
24 | {
25 | "type": "home",
26 | "number": "212 555-1234"
27 | },
28 | {
29 | "type": "office",
30 | "number": "646 555-4567"
31 | }
32 | ],
33 | "children": [],
34 | "spouse": null
35 | }
36 | """
37 |
38 |
39 | val json2 = """
40 | {
41 | "name" : "Bert",
42 | "children" : [
43 | {
44 | "name" : "Alice",
45 | "children" : []
46 | },
47 | {
48 | "name": "Bob",
49 | "children" : [
50 | {
51 | "name" : "Bill",
52 | "children" : []
53 | },
54 | {
55 | "name" : "Zoot",
56 | "children" : []
57 | }
58 | ]
59 | }
60 | ]
61 | }
62 | """
63 |
64 | // Task (1a)
65 |
66 | }
67 |
68 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture4/EmployeesSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import java.util.UUID
4 |
5 | import scala.language.implicitConversions
6 |
7 | import com.datascience.education.tutorialCommon.lecture4.CommonEmployeesSpec
8 |
9 | import Employees._
10 |
11 | import com.datascience.education.tutorialCommon.lecture4.EmployeeTypeclass
12 | import com.datascience.education.tutorialCommon.lecture4.EmployeesTypeclass
13 |
14 | object EmployeesSpec {
15 | implicit def employeeTypeclass(e: Employee): EmployeeTypeclass[Email] =
16 | new EmployeeTypeclass[Email] {
17 | val id = e.id
18 | val email = e.email
19 | }
20 |
21 | implicit def employeesTypeclass:
22 | EmployeesTypeclass[Employee, Email] =
23 | new EmployeesTypeclass[Employee, Email] {
24 | val prianna: Employee = Employees.prianna
25 | val peter: Employee = Employees.peter
26 | val chrisId: UUID = Employees.chrisId
27 | def employeeEmail(id: UUID): Option[Email] =
28 | Employees.employeeEmail(id)
29 | }
30 | }
31 |
32 | import EmployeesSpec._
33 |
34 | // uncomment when ready to test
35 | // class EmployeesSpec
36 | // extends CommonEmployeesSpec()(employeeTypeclass _, employeesTypeclass)
37 |
38 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/ResponseList.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import scala.util.Random
4 |
5 | import cats.data.Xor
6 | import cats.data.Xor.Left
7 | import cats.data.Xor.Right
8 |
9 | object ResponseList {
10 |
11 | import RequestResponse._
12 | import TraverseXor._
13 |
14 | val rand = new Random
15 |
16 | val listRequests = (1 to 10).map((i: Int) => Request(i.toString)).toList
17 | val listCorrupt = Request("foo") :: listRequests ::: List(Request("bar"), Request("5"))
18 |
19 | // Task 4a
20 | def parsePayload(payload: Payload): Xor[NumberFormatException, Int] =
21 | ???
22 |
23 | // Task 4b
24 | def pipeline(request: Request): Xor[Exception, Int] =
25 | ???
26 |
27 | // Task 4c
28 | def sum(lr: List[Request]): XorException[Int] =
29 | ???
30 | }
31 |
32 | object ResponseListExample extends App {
33 | import ResponseList._
34 |
35 | println("List of valid Requests:")
36 | println(listRequests)
37 |
38 |
39 | val sumValid = sum(listRequests)
40 |
41 | println(sumValid)
42 |
43 | println("----------------------")
44 | println("List of possibly corrupt Payloads:")
45 | println(listCorrupt)
46 |
47 | val sumCorrupt = sum(listCorrupt)
48 |
49 | println(sumCorrupt)
50 |
51 | }
52 |
--------------------------------------------------------------------------------
/tutorialCommon/src/test/scala/com/datascience/education/tutorialCommon/lecture4/CommonEmptySetSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorialCommon.lecture4
2 |
3 | import org.scalatest.{FunSuite, Matchers}
4 |
5 | class CommonEmptySetSpec[EmptySet](implicit EmptySet: EmptySetTypeclass) extends FunSuite with Matchers {
6 |
7 | import EmptySet._
8 | test("Sum of 1 through 10 inclusive should be 55; method sum") {
9 | sum((1 to 10).toList) should be (Some(55))
10 | }
11 |
12 | val dec = (1 to 10).map(_.toDouble).toList
13 | val prod = 3628800.0
14 |
15 | test(s"Product of $dec should be $prod ; prodList") {
16 | prodList(dec) should be (prod)
17 | }
18 | test(s"Product of $dec should be $prod ; prodList2") {
19 | prodList2(dec) should be (prod)
20 | }
21 |
22 | test(s"Sum of empty List should be None ; sum2") {
23 | sum2(List[Int]()) should be (None)
24 | }
25 |
26 | val oneTen = (1 to 10).toList
27 | val sm = oneTen.sum
28 |
29 | test(s"Sum of $oneTen should be Some($sm) ; sum2") {
30 | sum2(oneTen) should be (Some(sm))
31 | }
32 |
33 |
34 | test(s"Product of empty List should be None ; product2") {
35 | product2(List[Double]()) should be (None)
36 | }
37 |
38 | test(s"Product of $dec should be Some($prod) ; product2") {
39 | product2(dec) should be (Some(prod))
40 | }
41 |
42 |
43 |
44 |
45 | }
46 |
47 |
48 |
--------------------------------------------------------------------------------
/sbtTutorial/usingBreezeRefactored/project/Dependencies.scala:
--------------------------------------------------------------------------------
1 | // taken from https://github.com/TrueCar/mleap/blob/master/project/Dependencies.scala
2 |
3 | import sbt._
4 |
5 | object Dependencies {
6 |
7 | import Common.scalaVer
8 |
9 | // emulate this: https://github.com/TrueCar/mleap/blob/master/project/Dependencies.scala
10 |
11 | // Task 5f
12 |
13 | // http://www.scala-sbt.org/1.0/docs/Compiler-Plugins.html
14 |
15 | // https://github.com/non/kind-projector
16 | // http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22kind-projector_2.11%22
17 | val kindProjector = compilerPlugin("org.spire-math" % "kind-projector" % "0.9.0" cross CrossVersion.binary)
18 |
19 | // https://github.com/milessabin/si2712fix-plugin
20 | // http://search.maven.org/#search%7Cga%7C1%7Ca%3A%22si2712fix-plugin_2.11.8%22
21 | val si2712 = compilerPlugin("com.milessabin" % "si2712fix-plugin" % "1.2.0" cross CrossVersion.full)
22 |
23 | // formatting of dependencies
24 | // http://www.scala-sbt.org/0.13/docs/Library-Dependencies.html#The++key
25 |
26 | // Task 5e
27 | val breezeVersion: String = ???
28 |
29 | // Task 5d
30 | lazy val commonDependencies: Seq[ModuleID] = ???
31 |
32 | // Separate "common dependencies" from "plotting dependencies"
33 | // Do not write the same Maven artifact twice
34 |
35 | // Task 5d
36 | lazy val plottingDependencies: Seq[ModuleID] = ???
37 |
38 | }
39 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture3/DatabaseSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture3
2 |
3 | import org.scalatest._
4 | import prop._
5 |
6 | import org.scalacheck.Gen
7 | import org.scalacheck.Prop
8 | import org.scalacheck.Prop.forAllNoShrink
9 |
10 | import org.scalatest.prop.Checkers.check
11 |
12 | import cats.data.Reader
13 | import cats.syntax.applicative._
14 |
15 | class DatabaseSpec extends PropSpec with
16 | GeneratorDrivenPropertyChecks with Matchers {
17 |
18 |
19 | import DatabaseQueriesAndUpdates._
20 |
21 | // Task 3a
22 | // property("User does not exist in database") {
23 | //
24 | // val testDB = TestDatabase()
25 | //
26 | // forAll(Gen.alphaStr) {
27 | // case (username: String) =>
28 | // userExists(username).run(testDB) should be (false)
29 | // }
30 | //
31 | // }
32 |
33 |
34 | // val nonEmptyString = Gen.nonEmptyContainerOf(Gen.alphaStr)
35 |
36 | // val nonEmptyString = Gen.chooseNum(8, 32).flatMap { length =>
37 | // Gen.listOfN(length, Gen.alphaChar).map(_.mkString)
38 | // }
39 |
40 |
41 | // Task 3b
42 | // property("create user") {
43 | // ???
44 | // }
45 |
46 |
47 | // Task 3c
48 | // property("User exists in database") {
49 | //
50 | // ???
51 | // }
52 |
53 | // Task 3d
54 | // property("Password works") {
55 | // ???
56 | //
57 | // }
58 |
59 |
60 | // Task 3e
61 | // property("Bad password fails") {
62 | //
63 | // ???
64 | // }
65 |
66 | }
67 |
68 |
69 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4/Employees.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import scala.collection.Map
4 |
5 | import java.util.UUID
6 |
7 | object Employees {
8 |
9 |
10 | type Email = String
11 |
12 | case class Employee(id: UUID, firstName: String, email: Email, ssnLast4: Short)
13 |
14 | val prianna = Employee(UUID.randomUUID(), "Prianna", "prianna@datascience.com", 8765)
15 | val peter = Employee(UUID.randomUUID(), "Peter", "peter@datascience.com", 9876)
16 |
17 | val chrisId = UUID.randomUUID()
18 |
19 | type Employees = Map[UUID, Employee]
20 | val employees: Employees = Map[UUID, Employee](prianna.id -> prianna, peter.id -> peter)
21 |
22 | /*
23 | Alternative problem description
24 |
25 | Implement the function "employeeEmail(id: UUID): Option[Email]",
26 | which returns an e-mail address if an employee exists who has the provided ID.
27 |
28 | Use the "get" method on Map.
29 | http://www.scala-lang.org/api/current/index.html#scala.collection.Map@get(key:A):Option[B]
30 |
31 | */
32 |
33 | // Task (3a)
34 | def employeeEmail(id: UUID): Option[Email] =
35 | ???
36 |
37 | }
38 |
39 | object EmployeesExample extends App {
40 | import Employees._
41 |
42 | val priannaEmail = employeeEmail(prianna.id)
43 | println(s"Prianna's email: $priannaEmail")
44 | val peterEmail = employeeEmail(peter.id)
45 | println(s"Peter's email: $peterEmail")
46 | val chrisEmail = employeeEmail(chrisId)
47 | println(s"Chris' email: $chrisEmail")
48 |
49 | }
50 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture5/LookandSay.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 |
4 | import scala.math.BigInt
5 |
6 | import com.datascience.education.common.lecture5.Stream
7 | import com.datascience.education.common.lecture5.Empty
8 | import com.datascience.education.common.lecture5.Cons
9 | import com.datascience.education.common.lecture5.Stream._
10 |
11 | /*
12 |
13 | https://en.wikipedia.org/wiki/Look-and-say_sequence
14 |
15 | To generate a member of the sequence from the previous member, read off the digits of the previous member, counting the number of digits in groups of the same digit. For example:
16 |
17 | 1 is read off as "one 1" or 11.
18 | 11 is read off as "two 1s" or 21.
19 | 21 is read off as "one 2, then one 1" or 1211.
20 | 1211 is read off as "one 1, then one 2, then two 1s" or 111221.
21 | 111221 is read off as "three 1s, then two 2s, then one 1" or 312211.
22 |
23 |
24 | */
25 |
26 | object LookAndSay {
27 |
28 | /*
29 | https://www.rosettacode.org/wiki/Look-and-say_sequence#Scala
30 |
31 | Embed the function `next` into a Stream with `unfold`
32 |
33 | So if a single call to `next` provides the next integer in the Look And Say sequence,
34 | `unfold` will produce the next value in the Stream with `next`
35 |
36 | */
37 |
38 | // Task 3a
39 |
40 | val lookAndSay: Stream[String] = ???
41 | // Stream.unfold???
42 |
43 | }
44 |
45 | object LookAndSayExample extends App {
46 | import LookAndSay._
47 |
48 |
49 | lookAndSay.print(10)
50 |
51 | }
52 |
53 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture1/TypeClassProblem.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture1
2 |
3 | import scala.language.higherKinds
4 |
5 | object ModelProblem {
6 |
7 | // Task (6a)
8 | trait Plottable[Domain, Range, T[Domain, Range]] {
9 | // The `= ???` is necessary to prevent compiler error; but this should be abstract!
10 | // Remove `= ???` upon implementation of the signature of `points`
11 | def points/*???*/ = ???
12 |
13 |
14 | def plot(name: String, t: T[Domain, Range], input: List[Domain]): Unit = {
15 | //val y = points(t, input)
16 | val y = ???
17 | println(s"$name: $y")
18 | }
19 |
20 | }
21 |
22 | class Model[Domain, Range](val pdf: Domain => Range)
23 |
24 | // Task (6b)
25 | implicit object PlotDoubleDoubleModel extends Plottable[Double, Double, Model] {
26 |
27 | ???
28 | }
29 |
30 | // Task (6c)
31 | implicit object PlotDoubleDoubleFunction extends Plottable[Double, Double, Function1] {
32 |
33 | ???
34 | }
35 |
36 | // Task (6d)
37 | def plotter[D,R,T[D,R]](t: T[D,R], ld: List[D], name: String)
38 | (implicit plottable: Plottable[D,R,T]): Unit = ???
39 |
40 |
41 | def gaussianPDF(u: Double, t: Double)(d: Double): Double =
42 | (1/(math.sqrt(2*t*t*math.Pi)))*math.pow(math.E, -1*math.pow(d - u, 2)/(2*t*t))
43 |
44 | val gaussianModel = new Model(gaussianPDF(1.0,2.0))
45 |
46 | }
47 |
48 | object PlotExample extends App {
49 |
50 | import ModelProblem._
51 |
52 |
53 | val x = (-16 to 16).toList.map(_.toDouble).map(_/10.0)
54 | plotter(gaussianModel, x, "gaussianpdf.png")
55 |
56 |
57 | }
58 |
59 |
--------------------------------------------------------------------------------
/project/Common.scala:
--------------------------------------------------------------------------------
1 | // taken from https://github.com/TrueCar/mleap/blob/master/project/Common.scala
2 |
3 | import sbt._
4 | import Keys._
5 | import sbtunidoc.Plugin.UnidocKeys._
6 | import sbtunidoc.Plugin.ScalaUnidoc
7 |
8 |
9 | object Common {
10 |
11 | val scalaVer = "2.11.8"
12 |
13 |
14 | lazy val otherResolvers = Seq(
15 | "bintray/non" at "http://dl.bintray.com/non/maven",
16 | "Sonatype Releases" at "https://oss.sonatype.org/content/repositories/releases/",
17 | "sonatype" at "http://oss.sonatype.org/content/groups/public/",
18 | "twitter-repo" at "https://maven.twttr.com",
19 | "Clojars Repository" at "http://clojars.org/repo",
20 | "conjars" at "http://conjars.org/repo",
21 | "Artima Maven Repository" at "http://repo.artima.com/releases",
22 | //"Spark Packages Repo Bintray" at "http://dl.bintray.com/spark-packages/maven",
23 | Opts.resolver.sonatypeSnapshots
24 | )
25 |
26 |
27 | lazy val settings: Seq[Def.Setting[_]] = Seq(
28 | version := "0.1",
29 | scalaVersion := scalaVer,
30 | organization := "com.datascience.education",
31 | scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature"),
32 | resolvers ++= otherResolvers,
33 | resolvers += Resolver.url(
34 | "bintray-sbt-plugins",
35 | url("http://dl.bintray.com/sbt/sbt-plugins"))(
36 | Resolver.ivyStylePatterns),
37 | libraryDependencies ++= Dependencies.dependencies
38 | )
39 |
40 | lazy val additionalUnidocSettings: Seq[Def.Setting[_]] = Seq(
41 | target in unidoc in ScalaUnidoc := baseDirectory.value / "doc" / "scaladoc",
42 | autoAPIMappings := true
43 | )
44 |
45 |
46 |
47 |
48 | }
49 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture3/AsynchronousFactorials.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture3
2 |
3 | import scala.concurrent._
4 |
5 | import scala.concurrent.ExecutionContext.Implicits.global
6 |
7 | object AsynchronousFactorial {
8 |
9 | def factorial(n: Int): Int = {
10 | val fact = if(n == 0) 1 else n*factorial(n-1)
11 |
12 | Thread.sleep(500)
13 | println(s"factorial($n) = $fact")
14 |
15 | fact
16 | }
17 |
18 | def factorialAsync(n: Int): Future[Int] = Future(factorial(n))
19 |
20 | def printFactorial(n: Int): Future[Int] = {
21 | val fut: Future[Int] = factorialAsync(n)
22 |
23 | fut.onSuccess {
24 | case f => println(s"factorial $n is $f")
25 | }
26 |
27 | fut
28 | }
29 |
30 | }
31 |
32 | object AsynchronousFactorialsExample extends App {
33 |
34 | import AsynchronousFactorial._
35 |
36 | val fut10 = printFactorial(10)
37 | val fut20 = printFactorial(20)
38 |
39 | (1 to 30).foreach(i => {Thread.sleep(500); println(s"unrelated: $i")})
40 |
41 | }
42 |
43 | import cats.syntax.applicative._
44 | import cats.syntax.writer._
45 | import cats.data.Writer
46 |
47 | object FactorialWriter {
48 |
49 | // Task (1a)
50 |
51 | // type Logged[A] = ???
52 |
53 | // Task (1b)
54 | // def factorial(n: Int): ??? = ???
55 |
56 |
57 | // Task 1c
58 | // def factorialAsync(n: Int): ??? = ???
59 |
60 |
61 | }
62 |
63 | object FactorialWriterExample extends App {
64 | import FactorialWriter._
65 |
66 | // Task 1b
67 |
68 | }
69 |
70 | object FactorialWriterAsyncExample extends App {
71 | import FactorialWriter._
72 |
73 |
74 | // Task 1d
75 |
76 |
77 | }
78 |
79 |
--------------------------------------------------------------------------------
/slides/theme/css/print.css:
--------------------------------------------------------------------------------
1 | * {
2 | margin: 0;
3 | padding: 0;
4 | }
5 |
6 | @page {
7 | size: landscape;
8 | }
9 |
10 | body {
11 | font: 100% "Lucida Grande", "Trebuchet MS", Verdana, sans-serif;
12 | padding: 0;
13 | margin: 0;
14 | }
15 |
16 | div.slide {
17 | min-width: 800px;
18 | min-height: 600px;
19 | padding: 1em;
20 | overflow: hidden;
21 | page-break-after: always;
22 | border: 1px solid black;
23 | border-radius: 20px;
24 | }
25 |
26 | div.slide div.inner {
27 | width: 800px;
28 | height: 600px;
29 | margin: auto;
30 | display: table-cell;
31 | }
32 |
33 | h1 {
34 | font-size: 2.4em;
35 | }
36 |
37 | h2 {
38 | font-size: 1.4em;
39 | }
40 |
41 | h3 {
42 | margin: 1em 0;
43 | }
44 |
45 | ul {
46 | margin: 0;
47 | padding: 0;
48 | }
49 |
50 | p, li, pre {
51 | margin: 1em 0;
52 | }
53 |
54 | li {
55 | margin-left: 2em;
56 | }
57 |
58 | a {
59 | color: #000000;
60 | }
61 |
62 | pre, code {
63 | max-width: 800px;
64 | background: #eee;
65 | font-family: Monaco, monospace;
66 | font-size: 90%;
67 | }
68 |
69 | pre {
70 | padding: .2em .5em;
71 | overflow: hidden;
72 | border-radius: .8em;
73 | }
74 |
75 | code {
76 | padding: 0 .2em;
77 | }
78 |
79 | .slide header:only-child h1 {
80 | line-height: 180%;
81 | text-align: center;
82 | display: table-cell;
83 | vertical-align: middle;
84 | height: 600px;
85 | width: 800px;
86 | font-size: 48px;
87 | margin-top:100px;
88 | margin-bottom:100px;
89 | }
90 |
91 | #toc, #help, .slide aside, .slide footer, .slide .notes,
92 | .presenter_notes, #current_presenter_notes, #presenter_note {
93 | display: none;
94 | }
95 |
--------------------------------------------------------------------------------
/params.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "Scala",
3 | "tagline": "Lecture slides, labs, and tutorials from our 8-week Scala course.",
4 | "body": "#Lecture Slides\r\n\r\n\r\n\r\nLectures 4-13a are numbered according to their corresponding chapter in _Functional Programming in Scala_.",
5 | "note": "Don't delete this file! It's used internally to help with page regeneration."
6 | }
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture5/InterpolationExamples.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 |
4 | object SineExample extends App {
5 | import Sine._
6 | import breeze.linalg._
7 | import breeze.plot._
8 |
9 | sine.print(32)
10 |
11 | val f = Figure()
12 | val p = f.subplot(0)
13 | val x = linspace(0.0,2.5*math.Pi, 16)
14 |
15 | val out: List[Double] = sine.toListFinite(16)
16 |
17 | p+= plot(x, out)
18 | p+= plot(x, out, '.')
19 |
20 | p.xlabel = "theta radians"
21 | p.ylabel = "sin(theta)"
22 |
23 | f.saveas("sine_wave.png")
24 |
25 | println("done plotting")
26 |
27 |
28 |
29 | }
30 |
31 |
32 | object StepperExample extends App {
33 | import Stepper._
34 |
35 | import breeze.linalg._
36 | import breeze.plot._
37 |
38 |
39 | val stepperOut = stepperSine.toListFinite(32)
40 |
41 | val f = Figure()
42 | val p2 = f.subplot(0)
43 | val x2 = linspace(0.0,2.5*math.Pi, 32)
44 |
45 | p2 += plot(x2, stepperOut)
46 | p2 += plot(x2, stepperOut, '.')
47 |
48 | p2.xlabel = "theta radians"
49 | p2.ylabel = "sin(theta)"
50 |
51 | f.saveas("sine_wave_stepper.png")
52 |
53 | println("done plotting")
54 |
55 | }
56 |
57 | object InterpolationExample extends App {
58 |
59 | import Interpolation._
60 |
61 | import breeze.linalg._
62 | import breeze.plot._
63 |
64 | val linearInterpolatedOut = linearInterpolated.toListFinite(32)
65 |
66 | println(linearInterpolatedOut)
67 |
68 | val f = Figure()
69 | val p3 = f.subplot(0)
70 | val x3 = linspace(0.0,2.5*math.Pi, 32)
71 |
72 | p3 += plot(x3, linearInterpolatedOut)
73 | p3 += plot(x3, linearInterpolatedOut, '.')
74 |
75 | p3.xlabel = "theta radians"
76 | p3.ylabel = "sin(theta)"
77 |
78 | f.saveas("sine_wave_linear_interpolation.png")
79 |
80 | println("done plotting")
81 |
82 |
83 | }
84 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Functional Scala for Data Engineers
2 |
3 | A fast-paced introduction to Scala's FP ecosystem for data engineers.
4 |
5 | These slides loosely follow Chiusano and Bjarnason's [Functional Programming in Scala](https://www.manning.com/books/functional-programming-in-scala) with an emphasis on introducing Cats and various other FP libraries. Please read chapters 1-3 before beginning.
6 |
7 | Welsh and Gurnell's [Advanced Scala with Cats](http://underscore.io/books/advanced-scala/) is an optional supplementary text, and their [Essential Scala](http://underscore.io/books/essential-scala/) is a minimal prerequisite for the course. The first two courses in Coursera's [Functional Programming in Scala Specialization](https://www.coursera.org/specializations/scala) are also highly recommended.
8 |
9 | Slides are viewable [here](http://DS12.github.io/scala-class).
10 |
11 | [](https://gitter.im/ds12/lobby)
12 |
13 | A link to ScalaDoc will be available in the slide table of contents, above.
14 |
15 | Functional Scala for Data Engineers is licensed under a Creative Commons CC0 1.0 Universal License .
16 |
17 |
18 | `DS12/scala-class` build status
19 |
20 | [](https://travis-ci.org/DS12/scala-class)
21 |
22 | `DS12/scala-class-private` build status
23 |
24 | [](https://travis-ci.com/DS12/scala-class-private)
25 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture4/SafeDivisionSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import org.scalatest.{FunSuite, Matchers}
4 |
5 | import SafeDivision._
6 |
7 | class SafeDivisionSpec extends FunSuite with Matchers {
8 |
9 | // // https://docs.oracle.com/javase/7/docs/api/java/lang/Double.html
10 | // test("safeDiv catches Double.POSITIVE_INFINITY") {
11 | // safeDiv(5, 0) should be (None)
12 | // }
13 | // test("safeDiv catches Double.NEGATIVE_INFINITY") {
14 | // safeDiv(-5, 0) should be (None)
15 | // }
16 | // test("safeDiv catches Double.NaN") {
17 | // safeDiv(0, 0) should be (None)
18 | // }
19 | //
20 | // val l1 = (6 to 11).toList
21 | // val l2 = (2 to 7).toList
22 | // val fracsSuccessful: List[(Int, Int)] = l1.zip(l2)
23 | //
24 | // // http://www.scalatest.org/user_guide/using_matchers#checkingAnObjectsClass
25 | // test(s"All of these fractions {$fracsSuccessful} are real numbers, so the traversal should succeed") {
26 | // val out: Option[List[Double]] = traverseFractions(fracsSuccessful)
27 | // out shouldBe a [Some[_]]
28 | // }
29 | //
30 | // val l3 = (6 to 11).toList
31 | // val l4 = (-3 to 2).toList
32 | // val fracsFailing: List[(Int, Int)] = l3.zip(l4)
33 | //
34 | // test(s"One of these fractions {$fracsFailing} is not a real number, so the traversal should fail") {
35 | // val out: Option[List[Double]] = traverseFractions(fracsFailing)
36 | // out shouldBe None
37 | // }
38 | //
39 | // test(s"All of these fractions {$fracsSuccessful} are real numbers, so the traversal and square root should succeed") {
40 | // val out: Option[List[Double]] = traverseSqrtFractions(fracsSuccessful)
41 | // out shouldBe a [Some[_]]
42 | // }
43 | //
44 | // test(s"One of these fractions {$fracsFailing} is not a real number, so the traversal and square root should fail") {
45 | // val out: Option[List[Double]] = traverseSqrtFractions(fracsFailing)
46 | // out shouldBe None
47 | // }
48 |
49 | }
--------------------------------------------------------------------------------
/tutorialCommon/src/test/scala/com/datascience/education/tutorialCommon/lecture4/CommonEmployeesSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorialCommon.lecture4
2 |
3 | import org.scalatest.{FunSuite, Matchers}
4 |
5 | /*
6 | The typeclass pattern may be useful to unify test implementations
7 | between exercise and answer SBT sub-projects.
8 |
9 | The test is defined on a typeclass, which both
10 | exercise and answer code implement -- see
11 | com.datascience.education.tutorialAnswer.lecture4.EmptySetSpec and
12 | com.datascience.education.tutorial.lecture4.EmptySetSpec
13 | in the test folder for a simpler example than `Employees`.
14 |
15 | `EmptySet` is too simple to demonstrate the complication of this attempt
16 | at test unification.
17 | `Employees` features a couple of custom types:
18 | the `Email` type, and the `Employee` case class.
19 | These are duplicately defined in the exercise and answer code,
20 | to make them immediately visible to the student. We should not
21 | hide these simple types away in this `tutorialCommon` sub-project.
22 | While testing boilerplate may expand, I attempt to keep the exercises
23 | in `main` as compact as possible.
24 | `test` code is generally my responsibility and a "given" for the student.
25 |
26 | Both this attempt and the monomorphism attempt at test unification
27 | (see com.datascience.education.tutorialCommon.lecture4.FPOption)
28 | will be shelved for now. Test implementations will simply be duplicated
29 | between the `tutorial` and `tutorialAnswer` sub-projects.
30 |
31 | */
32 |
33 | class CommonEmployeesSpec[Employee, Employees, Email](
34 | implicit
35 | et: Employee => EmployeeTypeclass[Email], Employees: EmployeesTypeclass[Employee, Email]
36 | ) extends FunSuite with Matchers {
37 |
38 | import Employees._
39 |
40 | // http://www.scalatest.org/user_guide/using_matchers
41 | test("Peter's email should be wrapped in a Some") {
42 | employeeEmail(peter.id) should be (Some(peter.email))
43 | }
44 |
45 | test("Chris's email should be a None") {
46 | employeeEmail(chrisId) should be (None)
47 | }
48 |
49 | }
50 |
51 |
52 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture5/QuickSort.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture5
2 |
3 | import com.datascience.education.common.lecture5.Stream
4 | import com.datascience.education.common.lecture5.Empty
5 | import com.datascience.education.common.lecture5.Cons
6 | import com.datascience.education.common.lecture5.Stream._
7 |
8 |
9 | object QuickSort {
10 |
11 | // Task 4c
12 | // Answer 4c
13 | def quickSort(si: Stream[Int]): Stream[Int] = {
14 | println("call")
15 | ???
16 | }
17 |
18 | def quickSort(li: List[Int]): Stream[Int] =
19 | quickSort(listToStream(li))
20 |
21 | }
22 |
23 |
24 |
25 | object QuickSortExample extends App {
26 |
27 | import QuickSort._
28 |
29 | import scala.util.Random
30 | val rand = new Random()
31 |
32 | val unsorted = (for (_ <- 1 to 16) yield rand.nextInt(64)).toList
33 |
34 | println("unsorted")
35 |
36 | println(unsorted)
37 |
38 | println("---------")
39 |
40 |
41 | val sortedLazy = quickSort(unsorted)
42 | println("sort 4 digits")
43 | sortedLazy.print(4)
44 |
45 | println()
46 |
47 | println("-----------------------")
48 |
49 |
50 | val sortedLazy2 = quickSort(unsorted)
51 | println("sort 8 digits")
52 | sortedLazy2.print(8)
53 |
54 | println()
55 |
56 | println("-----------------------")
57 |
58 | val sortedLazy3 = quickSort(unsorted)
59 | println("least element / head")
60 | println(sortedLazy3.headOption)
61 |
62 |
63 | println("---------------------------")
64 |
65 | println("re-use of `sortedLazy`; demonstration of memoization")
66 |
67 | println("sort 4 digits")
68 | sortedLazy.print(4)
69 |
70 | println("sort 6 digits")
71 | sortedLazy.print(6)
72 |
73 |
74 |
75 | }
76 |
77 | object QuickSortUnevaluated extends App {
78 | import QuickSort._
79 |
80 | import scala.util.Random
81 | val rand = new Random()
82 |
83 | val unsorted = (for (_ <- 1 to 16) yield rand.nextInt(64)).toList
84 |
85 | println("---------")
86 |
87 |
88 | val sortedLazy = quickSort(unsorted)
89 | println("sort 4 digits")
90 | sortedLazy.print(4)
91 |
92 | }
93 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4/EmptySet.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 |
4 | object EmptySet {
5 | def sumList(l: List[Int]): Int = l match {
6 | case Nil => 0
7 | case x :: xs => x + sumList(xs)
8 | }
9 | def prodList(ds: List[Double]): Double = ds match {
10 | case Nil => 1.0
11 | case x :: xs => x * prodList(xs)
12 | }
13 |
14 | def sumList2(l: List[Int]) = l.foldRight(0)(_ + _)
15 | def prodList2(l: List[Double]) = l.foldRight(1.0)(_ * _)
16 |
17 |
18 |
19 | // Task (1a)
20 | def sum(l: List[Int]): Option[Int] = ???
21 |
22 | // Task (1b)
23 | def product(l: List[Double]): Option[Double] = ???
24 |
25 |
26 | // Task (1c)
27 | def sum2(l: List[Int]): Option[Int] = ???
28 |
29 | // Task (1d)
30 |
31 | def product2(l: List[Double]): Option[Double] = ???
32 |
33 |
34 | }
35 |
36 |
37 | object EmptySetExamples extends App {
38 |
39 | import EmptySet._
40 |
41 | val nums = (1 to 10).toList
42 | val dec = nums.map(_.toDouble/10.0)
43 |
44 | val s10 = sum(nums)
45 |
46 | println(s"sum of $nums")
47 | println(s10)
48 |
49 | val emptyInt = List[Int]()
50 |
51 | val sEmpty = sum(emptyInt)
52 |
53 | println(s"sum of $emptyInt")
54 | println(sEmpty)
55 |
56 |
57 | println("--------------------")
58 |
59 |
60 | val p10 = product(dec)
61 |
62 | println(s"product of $dec")
63 | println(p10)
64 |
65 | val emptyDouble = List[Double]()
66 |
67 | val dEmpty = product(emptyDouble)
68 |
69 | println(s"product of $emptyDouble")
70 | println(dEmpty)
71 |
72 |
73 | println("--------------------")
74 |
75 | val sFolded10 = sum2(nums)
76 | println(s"sum of $nums")
77 | println(sFolded10)
78 |
79 | val sFoldedEmpty = sum2(emptyInt)
80 | println(s"sum of $emptyInt")
81 | println(sFoldedEmpty)
82 |
83 | println("--------------------")
84 |
85 |
86 | val pFolded10 = product2(dec)
87 |
88 | println(s"product of $dec")
89 | println(pFolded10)
90 |
91 | val dFoldedEmpty = product2(emptyDouble)
92 |
93 | println(s"product of $emptyDouble")
94 | println(dFoldedEmpty)
95 |
96 |
97 |
98 | }
99 |
--------------------------------------------------------------------------------
/tutorial/src/test/scala/com/datascience/education/tutorial/lecture4/FPOptionSpec.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 | import org.scalatest.{FunSuite, Matchers}
4 |
5 | class FPOptionSpec extends FunSuite with Matchers {
6 | import FPOption._
7 |
8 | // val optionHello: FPOption[String] = FPSome("hello")
9 | // val option65: FPOption[Int] = FPSome(65)
10 | // val noInt: FPOption[Int] = FPNone
11 | // val option64: FPOption[Int] = unit(64) // alternative construction
12 |
13 | // def capitalLetter(i: Int): FPOption[Char] =
14 | // if (i >= 65 && i <= 90) FPSome(i.toChar) // use unit here
15 | // else FPNone
16 |
17 |
18 | // test(s"The inner type of $option65 .getOrElse($optionHello) is raised to common ancestor `Any`") {
19 | // "option65.orElse(optionHello): FPOption[Any]" should compile
20 | // }
21 |
22 | // // http://www.scalatest.org/user_guide/using_matchers#checkingThatCodeDoesNotCompile
23 | // test(s"The inner type of $option65 .getOrElse($optionHello) should not be Int") {
24 | // "val foo: FPOption[Int] = option65.orElse(optionHello)" shouldNot typeCheck
25 | // }
26 |
27 | // test(s"The inner type of $option65 .getOrElse($optionHello) should not be String") {
28 | // "val foo: FPOption[String] = option65.orElse(optionHello)" shouldNot typeCheck
29 | // }
30 |
31 | // test(s"The ASCII capital character for code 65 is FPSome('A')") {
32 | // capitalLetter(65) shouldBe (FPSome('A'))
33 | // }
34 |
35 | // test(s"The ASCII capital character for code 64 is FPNone") {
36 | // capitalLetter(64) shouldBe (FPNone)
37 | // }
38 |
39 | // test(s"option65.flatMap(capitalLetter) is FPSome('A')") {
40 | // option65.flatMap(capitalLetter) shouldBe (FPSome('A'))
41 | // }
42 |
43 | // test(s"noInt.flatMap(capitalLetter) is FPNone") {
44 | // noInt.flatMap(capitalLetter) shouldBe (FPNone)
45 | // }
46 |
47 | // test(s"The sum of FPSome(64) and FPSome(65) is FPSome(129)") {
48 | // option64.map2(option65)(_+_) shouldBe (FPSome(129))
49 | // }
50 |
51 | // test(s"The sum of FPSome(64) and FPSome(65) should not be FPNone") {
52 | // option64.map2(option65)(_+_) should not be (FPNone)
53 | // }
54 |
55 | }
56 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4/SafeDivision.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4
2 |
3 |
4 | import scala.Option
5 | import scala.Some
6 | import scala.None
7 |
8 | import cats.Applicative
9 | import cats.Traverse
10 | import cats.std.list._
11 |
12 |
13 | object SafeDivision {
14 |
15 | // Task (2a)
16 | def safeDiv(x: Int, y: Int): Option[Double] =
17 | ???
18 |
19 | def divTuple(tup: (Int, Int)): Option[Double] =
20 | safeDiv(tup._1, tup._2)
21 |
22 |
23 | import TraverseOption._
24 |
25 | // Task (2b)
26 | def traverseFractions(ll: List[(Int, Int)]): Option[List[Double]] =
27 | ???
28 |
29 |
30 | // Task (2c)
31 | def traverseSqrtFractions(ll: List[(Int, Int)]): Option[List[Double]] =
32 | ???
33 |
34 | }
35 |
36 |
37 | object SafeDivisionExamples extends App {
38 |
39 | import SafeDivision._
40 |
41 | println("Divide 7 by 2")
42 | println(divTuple((7,2)))
43 |
44 | println("Divide 7 by 0")
45 | println(divTuple((7,0)))
46 |
47 | }
48 |
49 | object SafeDivisionTraversalExamples extends App {
50 | import SafeDivision._
51 |
52 | val a = (6 to 11).toList
53 | val b = (-3 to 2).toList
54 | val fracsFailing: List[Tuple2[Int, Int]] = a.zip(b)
55 |
56 | val optionList1: Option[List[Double]] =
57 | traverseFractions(fracsFailing)
58 |
59 | println("Option[List[Double]] in one step, using `traverse`: ")
60 | println("should fail")
61 | println(optionList1)
62 |
63 |
64 | println("-----------------")
65 | val c = (6 to 11).toList
66 | val d = (2 to 7).toList
67 | val fracsSuccessful: List[Tuple2[Int, Int]] = c.zip(d)
68 |
69 | println("These fractions do not include an undefined number")
70 | val optionList2: Option[List[Double]] =
71 | traverseFractions(fracsSuccessful)
72 |
73 | println("Option[List[Double]] in one step, using `traverse`: ")
74 | println(optionList2)
75 |
76 | println("-----------------")
77 |
78 | val optionSqrt1: Option[List[Double]] = traverseSqrtFractions(fracsFailing)
79 | println("Square root of fractions using `traverse`: ")
80 | println("Should fail")
81 | println(optionSqrt1)
82 |
83 | val optionSqrt2: Option[List[Double]] = traverseSqrtFractions(fracsSuccessful)
84 | println("Square root of fractions using `traverse`: ")
85 | println("These fractions do not include an undefined number and should succeed")
86 | println(optionSqrt2)
87 |
88 | }
89 |
90 |
91 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture3/Database.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture3
2 |
3 |
4 | import cats.data.Reader
5 | import cats.syntax.applicative._
6 |
7 | import cats.MonadReader
8 |
9 | import scala.collection.mutable.{Set => MutableSet}
10 | import scala.collection.mutable.{HashSet => MutableHashSet}
11 | import scala.collection.mutable.{Map => MutableMap}
12 | import scala.collection.mutable.HashMap
13 |
14 | import org.mindrot.jbcrypt.BCrypt
15 |
16 | import scala.util.Random
17 | /*
18 | Note that in Reader, the `S` is static
19 | In `State`, `S` is intended to change.
20 | So this example does not "pass along" new copies of an immutable database
21 | */
22 |
23 | sealed trait Database {
24 |
25 | // user ID, username
26 | val users: MutableMap[Int, String]
27 |
28 | // username, (salt, hash)
29 | val passwords: MutableMap[String, (String,String)]
30 |
31 | def genId: Int
32 |
33 | override def toString: String = {
34 | val userString = users.toList.map(_.toString + '\n').mkString
35 | val pwString = passwords.toList.map(_.toString + '\n').mkString
36 |
37 | "Users: "+userString+" passwords: "+pwString
38 |
39 | }
40 | }
41 |
42 | case class TestDatabase() extends Database {
43 | // user ID, username
44 | val users: MutableMap[Int, String] = MutableMap.empty[Int,String]
45 |
46 | // username, (salt, hash)
47 | val passwords: MutableMap[String, (String, String)] =
48 | MutableMap.empty[String,(String, String)]
49 |
50 | val rand = new Random()
51 |
52 | // unsafe if all ints used...
53 | @annotation.tailrec
54 | final def genId: Int = {
55 | val r = rand.nextInt().abs
56 | if (users.contains(r))
57 | genId
58 | else
59 | r
60 | }
61 |
62 |
63 | }
64 |
65 |
66 | object DatabaseQueriesAndUpdates {
67 |
68 |
69 | // Task 2a
70 | // type DatabaseReader[A] = ???
71 |
72 | // Task 2b
73 | // def findUsername(userId: Int): ??? = ???
74 |
75 |
76 | // Task 2c
77 | // def findUserId(username: String): ??? = ???
78 |
79 | // Task 2d
80 | // def userExists(username: String): ??? = ???
81 |
82 | // Task 2e
83 | // def checkPassword(username: String, passwordClear: String): ??? = ???
84 |
85 | // Task 2f
86 | // def checkLogin(userId: Int, passwordClear: String): ??? = ???
87 |
88 |
89 | // Task 2g
90 |
91 | // def createUser(username: String, passwordClear: String): ??? = ???
92 |
93 | }
94 |
95 |
96 |
--------------------------------------------------------------------------------
/README.html:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
8 | README.html
9 |
10 |
11 |
12 |
13 |
14 | Functional Scala for Data Engineers
15 | A fast-paced introduction to Scala's FP ecosystem for data engineers.
16 | These slides loosely follow Chiusano and Bjarnason's Functional Programming in Scala with an emphasis on introducing Cats and various other FP libraries. Please read chapters 1-3 before beginning.
17 | Welsh and Gurnell's Advanced Scala with Cats is an optional supplementary text, and their Essential Scala is a minimal prerequisite for the course. The first two courses in Coursera's Functional Programming in Scala Specialization are also highly recommended.
18 | Slides are viewable here .
19 |
20 | A link to ScalaDoc will be available in the slide table of contents, above.
21 | Functional Scala for Data Engineers is licensed under a Creative Commons CC0 1.0 Universal License .
22 | DS12/scala-class build status
23 |
24 | DS12/scala-class-private build status
25 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4/Covariance.scala:
--------------------------------------------------------------------------------
1 |
2 | package com.datascience.education.tutorial.lecture4
3 |
4 |
5 |
6 |
7 |
8 | object Covariance {
9 | sealed trait Coin
10 | case object Heads extends Coin
11 | case object Tails extends Coin
12 |
13 | // 4a
14 |
15 | sealed trait LinkedListInt
16 | case class ConsInt(h: Int, t: LinkedListInt) extends LinkedListInt
17 | case object NilInt extends LinkedListInt
18 |
19 | /*
20 | Demonstrations of generics without covariance - flawed design
21 | */
22 |
23 |
24 |
25 | // 4b
26 | sealed trait LinkedList1[A]
27 | case class Cons1[A](h: A, t: LinkedList1[A]) extends LinkedList1[A]
28 | /* bad form;
29 | a different instance of NilLL for every empty LinkedList?
30 | */
31 | case class Nil1[A]() extends LinkedList1[A]
32 |
33 | /*
34 | We want to re-use the same empty list, like Scala Collections:
35 | http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Nil$
36 | */
37 |
38 |
39 | // 4c
40 | sealed trait LinkedList2[A] {
41 | def prepend(a: A): LinkedList2[A] = Cons2(a, this)
42 | }
43 | case class Cons2[A](h: A, t: LinkedList2[A]) extends LinkedList2[A]
44 |
45 | /*
46 | Nil2 is an immutable, singleton object that will be re-used
47 | by LinkedList2's of many different types:
48 | LinkedList2[Int],
49 | LinkedList2[String],
50 | etc.
51 |
52 | A case object cannot create a generic type like a case class,
53 | explaining why this is not Nil2[A]
54 |
55 | `Nothing` is a subtype of every type,
56 | so is an apporiate concrete type to fill generic `A`
57 | in LinkedList2[A].
58 | */
59 | case object Nil2 extends LinkedList2[Nothing]
60 |
61 |
62 | // 4d
63 | sealed trait LinkedList3[+A] {
64 | def map[B](f: A => B): LinkedList3[B] = this match {
65 | case Cons3(h, t) => Cons3(f(h), t.map(f))
66 | case Nil3 => Nil3
67 | }
68 |
69 | // def prepend(a: A): LinkedList3[A] =
70 | // Cons3(a, this)
71 |
72 | }
73 | case class Cons3[+A](h: A, t: LinkedList3[A]) extends LinkedList3[A]
74 | case object Nil3 extends LinkedList3[Nothing]
75 |
76 |
77 | // 4e
78 | sealed trait LinkedList4[+A] {
79 | def map[B](f: A => B): LinkedList4[B] = this match {
80 | case Cons4(h, t) => Cons4(f(h), t.map(f))
81 | case Nil4 => Nil4
82 | }
83 |
84 | def prepend[B >: A](b: B): LinkedList4[B] =
85 | Cons4(b, this)
86 |
87 | }
88 | case class Cons4[+A](h: A, t: LinkedList4[A]) extends LinkedList4[A]
89 | case object Nil4 extends LinkedList4[Nothing]
90 |
91 |
92 |
93 | }
94 |
--------------------------------------------------------------------------------
/slides/theme/js/squeezeFrame.js:
--------------------------------------------------------------------------------
1 | // squeezeFrame.js; standalone JS to solve small rendering issues that cause
2 | // content to be inaccessible or scrollbars to appear on iframes
3 | //
4 | // version: 201003221700
5 | //
6 | // author: frank -futtta- goossens
7 | // License: CreativeCommons Attribution-Share Alike
8 | // (http://creativecommons.org/licenses/by-sa/3.0/) or
9 | // GNU LGPL (http://www.gnu.org/licenses/lgpl-3.0.txt)
10 | // more info: http://blog.futtta.be/2010/03/24/
11 | //
12 | // usage:
13 | // * include this script in the head of the iframe-content (i.e. in the
14 | // page that is displayed inside the iframe)
15 | // * set "myContainer" to the URL of the iframe container page (i.e. the
16 | // page in which the iframe is created/ defined), to redirect users
17 | // accessing the iframe-content out of context
18 | // * optionally set "myMax" with the maximum positive/negative zoom
19 | // allowed, e.g. 0.25 means that the page can zoom between 75 to 125%,
20 | // default is 0.10, so 90->110%
21 | // * optionally set "myRedraw" to "both" (default is "width") to adjust
22 | // to both width and height
23 | //
24 | // example code:
25 | //
26 | //
31 | //
32 | // bugs & issues:
33 | // * embedded YouTube in Firefox becomes invisible (but Vimeo for example
34 | // does work)
35 | // * the vertical scrollbar does not always disappear in FF
36 | // * does not work in Opera
37 |
38 | window.onload=function() {
39 | if (self !== top) {
40 | if (typeof myMax!=="number") { max=0.1; } else { max=myMax;}
41 | if (typeof myRedraw!=="string") myRedraw="width";
42 |
43 | b=document.getElementsByTagName('body')[0];
44 |
45 | zW=(b.clientWidth-5)/b.scrollWidth;
46 |
47 | if (myRedraw==="both") {
48 | zH=(b.clientHeight)/b.scrollHeight;
49 | if (zH1+max) { z=1+max; } else if (z<1-max) { z=1-max; }
56 |
57 | s="zoom:"+z+"; -moz-transform: scale("+z+"); -moz-transform-origin: 0 0;";
58 |
59 | if (typeof b.setAttribute === "function") b.setAttribute('style', s);
60 | else if (typeof b.style.setAttribute === "object") b.style.setAttribute('cssText', s);
61 | } else {
62 | if (typeof myContainer==="string") { window.location=myContainer; }
63 | }
64 | }
65 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/SafeDivision.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 |
4 | object SafeDivisionOption {
5 |
6 | def safeDivInt(numerator: Int, denominator: Int): Option[Int] =
7 | try {
8 | Some(numerator / denominator)
9 | } catch {
10 | case ae: java.lang.ArithmeticException => None
11 | }
12 |
13 | def squareRootFrac(numerator: Int, denominator: Int): Option[Double] =
14 | safeDivInt(numerator, denominator).flatMap { _ =>
15 | val squareRoot: Double =
16 | math.sqrt(numerator.toDouble / denominator)
17 | if (squareRoot.isNaN)
18 | None
19 | else
20 | Some(squareRoot)
21 | }
22 |
23 |
24 | def squareRootFrac(tup: (Int, Int)): Option[Double] =
25 | squareRootFrac(tup._1, tup._2)
26 |
27 |
28 | import TraverseOption._
29 |
30 | def traverseFractions(ll: List[(Int, Int)]): Option[List[Double]] =
31 | traverse(ll)(squareRootFrac)
32 |
33 |
34 | }
35 |
36 |
37 | object SafeDivisionOptionExamples extends App {
38 |
39 | import SafeDivisionOption._
40 |
41 |
42 | println("sqrt(7/2)")
43 | println(squareRootFrac(7,2))
44 |
45 | println("-----------------")
46 |
47 | println("sqrt(7/0)")
48 | println(squareRootFrac(7,0))
49 |
50 | println("-----------------")
51 |
52 | println("sqrt(-4/3)")
53 | println(squareRootFrac(-4,3))
54 |
55 |
56 | }
57 |
58 |
59 | import cats.data.Xor
60 | import cats.data.Xor.Left
61 | import cats.data.Xor.Right
62 |
63 | object SafeDivisionXor {
64 |
65 | // Task 2a
66 | def safeDivInt(numerator: Int, denominator: Int): Xor[Exception, Int] =
67 | ???
68 |
69 |
70 |
71 | // Task 2b
72 | def squareRootFrac(numerator: Int, denominator: Int):
73 | Xor[Exception, Double] = ???
74 |
75 |
76 | def squareRootFrac(tup: (Int, Int)): Xor[Exception, Double] =
77 | squareRootFrac(tup._1, tup._2)
78 |
79 |
80 |
81 | }
82 |
83 | object SafeDivIntXorExamples extends App {
84 | import SafeDivisionXor._
85 |
86 | println("7/2")
87 | println(safeDivInt(7,2))
88 |
89 | println("-----------------")
90 |
91 | println("7/0")
92 | println(safeDivInt(7,0))
93 |
94 |
95 | }
96 |
97 |
98 | object SquareRootFracXorExamples extends App {
99 | import SafeDivisionXor._
100 |
101 | println("sqrt(7/2)")
102 | println(squareRootFrac(7,2))
103 |
104 | println("-----------------")
105 |
106 | println("sqrt(7/0)")
107 | println(squareRootFrac(7,0))
108 |
109 | println("-----------------")
110 |
111 | println("sqrt(-4/3)")
112 | println(squareRootFrac(-4,3))
113 |
114 |
115 |
116 | }
117 |
118 |
119 |
120 |
121 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/XorErrors.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import cats.data.Xor
4 | import cats.data.Xor.Left
5 | import cats.data.Xor.Right
6 | import cats.data.NonEmptyList
7 |
8 |
9 | object XorErrors {
10 | import XorHelpers._
11 |
12 | type XorErrors[E, A] = Xor[NonEmptyList[E], A]
13 |
14 | // use Right and Left instead
15 | // def right[E,A](a: A): XorErrors[Nothing, A] = Right(a)
16 | // def left[E](e: E): XorErrors[E, Nothing] = Left(NonEmptyList(e))
17 |
18 |
19 | // think of map2 as an `And` operation
20 | def map2[E, A, B, C](xorErrors1: XorErrors[E,A], xorErrors2: XorErrors[E,B])
21 | (f: Function2[A, B, C]): XorErrors[E,C] =
22 | (xorErrors1, xorErrors2) match {
23 | case (Right(a1), Right(b2)) => Right(f(a1,b2))
24 | case (Left(e1), Right(b2)) => Left(e1)
25 | case (Right(a1), Left(e2)) => Left(e2)
26 | case (Left(e1), Left(e2)) => Left(concat(e1, e2))
27 | }
28 |
29 | // not really good form
30 | def concatErrors[E]
31 | (xorErrors1: XorErrors[E,Nothing], xorErrors2: XorErrors[E,Nothing]):
32 | XorErrors[E,Nothing] = (xorErrors1, xorErrors2) match {
33 | case (Left(e1), Left(e2)) => Left(concat(e1, e2))
34 | }
35 |
36 |
37 | def map4[Err, A, B, C, D, E](xorErrors1: XorErrors[Err, A],
38 | xorErrors2: XorErrors[Err, B],
39 | xorErrors3: XorErrors[Err, C],
40 | xorErrors4: XorErrors[Err, D])
41 | (f: Function4[A, B, C, D, E]): XorErrors[Err, E] = {
42 |
43 | val xorAB: XorErrors[Err, Tuple2[A,B]] = map2(xorErrors1, xorErrors2)((_,_))
44 | val xorCD: XorErrors[Err, Tuple2[C,D]] = map2(xorErrors3, xorErrors4)((_,_))
45 |
46 | val g: Function2[Tuple2[A, B], Tuple2[C, D], E] =
47 | (tupAB: Tuple2[A,B], tupCD: Tuple2[C,D]) => {
48 | val a: A = tupAB._1
49 | val b: B = tupAB._2
50 | val c: C = tupCD._1
51 | val d: D = tupCD._2
52 | f(a,b,c,d): E
53 | }
54 |
55 |
56 | val xorE: XorErrors[Err, E] = map2(xorAB, xorCD)(g)
57 |
58 | xorE
59 | }
60 |
61 |
62 | def and[E, A](xorErrors1: XorErrors[E,A], xorErrors2: XorErrors[E,A]): XorErrors[E,A] =
63 | (xorErrors1, xorErrors2) match {
64 | case (Right(a1), Right(a2)) => Right(a1)
65 | case (Left(e1), Right(a2)) => Left(e1)
66 | case (Right(a1), Left(e2)) => Left(e2)
67 | case (Left(e1), Left(e2)) => Left(concat(e1, e2))
68 | }
69 |
70 | def or[E, A](xorErrors1: XorErrors[E,A], xorErrors2: XorErrors[E,A]): XorErrors[E,A] =
71 | (xorErrors1, xorErrors2) match {
72 | case (Right(a1), Right(a2)) => Right(a1)
73 | case (Left(e1), Right(a2)) => Right(a2) // information lost about Left error
74 | case (Right(a1), Left(e2)) => Right(a1) // information lost about Right error
75 | case (Left(e1), Left(e2)) => Left(concat(e1, e2))
76 | }
77 |
78 |
79 |
80 |
81 |
82 | }
83 |
--------------------------------------------------------------------------------
/project/Dependencies.scala:
--------------------------------------------------------------------------------
1 | // taken from https://github.com/TrueCar/mleap/blob/master/project/Dependencies.scala
2 |
3 | import sbt._
4 |
5 | object Dependencies {
6 | import Common.scalaVer
7 |
8 |
9 | val catsVersion = "0.6.0"
10 | val dogsVersion = "0.2.2"
11 | val algebirdVersion = "0.12.1"
12 | val shapelessVersion = "2.3.2"
13 | val framelessVersion = "0.1.0"
14 | val summingbirdVersion = "0.11.0-RC1"
15 | val breezeVersion = "0.12"
16 | val spireVersion = "0.12.0"
17 | val json4sVersion = "3.4.0"
18 |
19 | val scalatestVersion = "3.0.0"
20 |
21 | // will use Spark 2.0 and Scala 2.11
22 | // Spark 1.6, Scala 2.10 could be delicately joined with the rest of the 2.11 repo
23 | // Fortunately this is no longer necessary
24 | //val sparkVer = "1.6.2"
25 |
26 | val kindProjector = compilerPlugin("org.spire-math" % "kind-projector" % "0.8.0" cross CrossVersion.binary)
27 | val si2712 = compilerPlugin("com.milessabin" % "si2712fix-plugin" % "1.2.0" cross CrossVersion.full)
28 |
29 | lazy val dependencies = Seq(
30 | "org.typelevel" %% "cats" % catsVersion,
31 | "org.typelevel" %% "dogs-core" % dogsVersion,
32 | "com.twitter" %% "algebird-core" % algebirdVersion,
33 | "com.twitter" %% "algebird-test" % algebirdVersion,
34 | "com.twitter" %% "algebird-util" % algebirdVersion,
35 | "com.twitter" %% "algebird-bijection" % algebirdVersion,
36 | "com.chuusai" %% "shapeless" % shapelessVersion,
37 | "io.github.adelbertc" %% "frameless-cats" % framelessVersion,
38 | "io.github.adelbertc" %% "frameless-dataset" % framelessVersion,
39 | "io.github.adelbertc" %% "frameless-dataframe" % framelessVersion,
40 | "org.scalatest" %% "scalatest" % scalatestVersion % "test",
41 | "org.scalacheck" % "scalacheck_2.11" % "1.13.2" % "test",
42 | "org.scalanlp" %% "breeze" % breezeVersion,
43 | "org.scalanlp" %% "breeze-natives" % breezeVersion,
44 | "org.scalanlp" %% "breeze-viz" % breezeVersion,
45 | "org.spire-math" %% "spire" % spireVersion,
46 | "de.svenkubiak" % "jBCrypt" % "0.4.1",
47 | "com.twitter" %% "summingbird" % summingbirdVersion,
48 | "com.twitter" %% "summingbird-example" % summingbirdVersion,
49 | "com.twitter" %% "summingbird-core" % summingbirdVersion,
50 | "com.twitter" %% "summingbird-client" % summingbirdVersion,
51 | "com.twitter" %% "summingbird-chill" % summingbirdVersion,
52 | "com.twitter" %% "summingbird-batch" % summingbirdVersion,
53 | "com.twitter" %% "summingbird-builder" % summingbirdVersion,
54 | "com.twitter" %% "summingbird-storm" % summingbirdVersion,
55 | "org.json4s" %% "json4s-native" % json4sVersion,
56 | "commons-validator" % "commons-validator" % "1.5.1",
57 | kindProjector,
58 | si2712
59 | )
60 |
61 |
62 | // lazy val sparkDependencies = Seq(
63 | // "org.apache.spark" %% "spark-core" % sparkVer % "provided",
64 | // "org.apache.spark" %% "spark-sql" % sparkVer % "provided").union(dependencies)
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/RequestResponse.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import scala.util.Random
4 |
5 | import cats.data.Xor
6 | import cats.data.Xor.Left
7 | import cats.data.Xor.Right
8 |
9 | import java.lang.{ String => JString }
10 |
11 | object RequestResponse {
12 |
13 | val rand = new Random
14 |
15 | def randString: String =
16 | rand.alphanumeric.take(8).toList.foldLeft("")(_ + _)
17 |
18 |
19 | trait ClientException extends Exception {
20 | def message: String
21 | def cause: Throwable
22 | }
23 |
24 |
25 | class BadRequestException(val message: String = null, val cause: Throwable = null)
26 | extends ClientException
27 |
28 | class CorruptPayloadException(val message: String = null, val cause: Throwable = null)
29 | extends ClientException
30 |
31 |
32 | case class Request(req: String)
33 | case class Response(arr: Array[Byte])
34 | case class Payload(pay: String)
35 |
36 |
37 | def sendRequestUnsafe(request: Request): Response =
38 | if (rand.nextDouble() < 0.02)
39 | throw new BadRequestException(s"No response received for request: $request")
40 | else {
41 | val bytes = { request.req }.getBytes()
42 |
43 | Response(bytes)
44 | }
45 |
46 | def unpackResponseUnsafe(
47 | response: Response, outOfMemory: Boolean = false): Payload = {
48 |
49 | if(outOfMemory)
50 | throw new Exception("out of memory")
51 |
52 |
53 | if (rand.nextDouble() < 0.02)
54 | throw new CorruptPayloadException(s"Payload of response corrupted: $response")
55 | else {
56 | val pay = response.arr
57 | Payload(new JString(response.arr))
58 | }
59 |
60 | }
61 | def clientUnsafe(request: Request): Payload =
62 | unpackResponseUnsafe(sendRequestUnsafe(request))
63 |
64 |
65 | // Task 3a
66 | def sendRequest(request: Request):
67 | Xor[BadRequestException, Response] =
68 | ???
69 |
70 | // Task 3b
71 | def unpackResponse(response: Response)(outOfMemory: Boolean):
72 | Xor[CorruptPayloadException, Payload] =
73 | ???
74 |
75 | // Task 3c
76 | def client(request: Request, outOfMemory: Boolean = false):
77 | Xor[ClientException, Payload] =
78 | ???
79 |
80 |
81 | }
82 |
83 | object RequestResponseExample extends App {
84 | import RequestResponse._
85 |
86 | val requests = (1 to 8).map(_ => Request(randString))
87 |
88 | requests.foreach { request =>
89 | val payload: Xor[Throwable, Payload] = client(request)
90 | println("------------------")
91 | println(s"sending request: $request")
92 | println(payload)
93 | }
94 |
95 |
96 | println("-------------------------------")
97 | println("Catastrophic exception should not be caught")
98 |
99 | // Task 3d
100 | // requests.foreach { request =>
101 | // val payload: Xor[Throwable, Payload] = client(request, true)
102 | // println("------------------")
103 | // println(s"sending request: $request")
104 | // println(payload)
105 | // }
106 |
107 |
108 | }
109 |
110 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/TraverseOption.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import scala.Option
4 | import scala.Some
5 | import scala.None
6 |
7 | import cats.Applicative
8 | import cats.std.list._
9 |
10 | /*
11 | `traverse` and `sequence` from Chapter 4,
12 | implemented on Scala Collections' `Option`
13 |
14 | */
15 |
16 | object TraverseOption {
17 | /*
18 | `traverse2` and `sequence2` are implemented from scratch (`sequence2` uses `traverse2`)
19 | `traverse` and `sequence` are implemented on top of Cats.
20 | It is preferable to use the implementation of `traverse`
21 | provided by Cats.
22 |
23 | Cost of Cats implementation
24 | Cats' `traverse` implementation obfuscates the solution to our challenge
25 |
26 | Benefit of Cats implementation
27 | `traverse` as implemented in FPiS Chapter 4 is simplified.
28 | (A => Option[B]) => Option[List[B]] *really* should be a combinator on
29 | `List`, not `Option`.
30 |
31 | Cats and Scalaz both implement it this way.
32 |
33 | FPiS' implementation of `traverse` for both Option and Either is simplified
34 |
35 | */
36 |
37 | /*
38 | Implement `prepend`, a helper function for `traverse2`
39 | */
40 | private def prepend[A](opA: Option[A], opListA: Option[List[A]]): Option[List[A]] =
41 | opA.flatMap { (a: A) =>
42 | opListA.map { (listA: List[A]) => a :: listA }
43 | }
44 |
45 | /*
46 | Implement `traverse2` using `prepend`. Do not use `sequence2`.
47 | */
48 | def traverse2[A, B](a: List[A])(f: A => Option[B]): Option[List[B]] =
49 | a.foldRight[Option[List[B]]](Some(List[B]())) { (a: A, opListB: Option[List[B]]) =>
50 | val opB: Option[B] = f(a)
51 | prepend(opB, opListB)
52 | }
53 |
54 | /*
55 | Implement `sequence2` using `traverse2`.
56 | The body of this method is a one-liner.
57 | */
58 | def sequence2[A, B](listOpA: List[Option[A]]): Option[List[A]] =
59 | traverse2(listOpA) { (opA: Option[A]) => opA }
60 |
61 | /*
62 | Requirement for production-ready implementation of `traverse` and `sequence` below.
63 | */
64 | implicit val applicativeOption = new Applicative[Option] {
65 | def pure[A](a: A): Option[A] = Some(a)
66 | // Members declared in cats.Apply
67 | def ap[A, B](ff: Option[A => B])(fa: Option[A]): Option[B] =
68 | (ff, fa) match {
69 | case (Some(ab), Some(a)) => Some(ab(a))
70 | case _ => None
71 | }
72 | // Members declared in cats.Cartesian
73 | override def product[A, B](fa: Option[A], fb: Option[B]): Option[(A, B)] =
74 | (fa, fb) match {
75 | case (Some(a), Some(b)) => Some((a, b))
76 | case _ => None
77 | }
78 | // Members declared in cats.Functor
79 | override def map[A, B](fa: Option[A])(f: A => B): Option[B] =
80 | fa.map(f)
81 | }
82 |
83 | /*
84 | Here, G = Option, and Applicative[G] = Applicative[Option]
85 | */
86 | def traverse[A, B](listA: List[A])(f: A => Option[B]): Option[List[B]] =
87 | listInstance.traverse(listA)(f)(applicativeOption)
88 |
89 | def sequence[A](loa: List[Option[A]]): Option[List[A]] =
90 | listInstance.traverse(loa) { (oa: Option[A]) => oa }(applicativeOption)
91 |
92 | }
93 |
94 |
95 |
--------------------------------------------------------------------------------
/tutorial/src/main/scala/com/datascience/education/tutorial/lecture4a/XorWebForm.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.tutorial.lecture4a
2 |
3 | import cats.data.Xor
4 | import cats.data.Xor.Left
5 | import cats.data.Xor.Right
6 | import cats.data.NonEmptyList
7 | import org.apache.commons.validator.routines.EmailValidator
8 | import XorErrors._
9 |
10 | import scala.language.higherKinds
11 |
12 | object XorWebFormVerifier
13 | extends WebFormVerifier[XorErrors] {
14 |
15 | //http://stackoverflow.com/a/19754142/1007926
16 | val alpha = (('a' to 'z') ++ ('A' to 'Z')).toSet
17 |
18 | def isAlpha(string: String): XorErrors[String, String] =
19 | ???
20 |
21 | def minimumLength(minLength: Int)(string: String): XorErrors[String, String] =
22 | ???
23 |
24 | /*
25 | This version of `validateName` runs two checks on `name: String` --
26 | the string must only contain alphabetic characters,
27 | and the string must be at least 3 characters long.
28 |
29 | Here, "failing fast" means if `isAlpha` fails,
30 |
31 |
32 | def verifyName(name: String): XorErrors[String, String] =
33 | isAlpha(name).flatMap { alphaName =>
34 | minimumLength(3)(alphaName)
35 | }
36 | */
37 |
38 | /*
39 | For first and last name
40 | */
41 | def verifyName(name: String): XorErrors[String, String] = {
42 | ???
43 | }
44 |
45 |
46 | // http://stackoverflow.com/a/19590634/1007926
47 | def numDigits(num: Long, length: Int): XorErrors[String, Long] =
48 | ???
49 |
50 | def verifyPhoneNumber(phoneNumber: Long): XorErrors[String, Long] = {
51 | ???
52 | }
53 |
54 | /*
55 | Email address validation
56 | " What is the best Java email address validation method? "
57 | http://stackoverflow.com/a/624590/1007926
58 | https://commons.apache.org/proper/commons-validator/apidocs/org/apache/commons/validator/routines/EmailValidator.html
59 | */
60 |
61 | val validator: EmailValidator = EmailValidator.getInstance()
62 |
63 | def validEmailAddress(emailAddress: String): Boolean = ???
64 |
65 | def verifyEmailAddress(emailAddress: String): XorErrors[String, String] = {
66 | ???
67 | }
68 |
69 |
70 |
71 | def verify(unverifiedWebForm: UnverifiedWebForm):
72 | XorErrors[String, VerifiedWebForm] = {
73 | ???
74 | }
75 | }
76 |
77 |
78 |
79 | object XorWebFormVerifierExample extends App {
80 |
81 | import XorWebFormVerifier._
82 |
83 | val unverified = UnverifiedWebForm("P3t3r", "Bec1ch", 1234, "no@suffix")
84 |
85 | val verified = verify(unverified)
86 |
87 | println("unverified: ")
88 | println(unverified)
89 |
90 | println("result of verification: ")
91 | println(verified)
92 |
93 | println("--------------------")
94 |
95 | val unverified2 = UnverifiedWebForm("P3t3r", "Bec1ch", 1234567890, "no@suffix")
96 |
97 | val verified2 = verify(unverified2)
98 |
99 | println("unverified: ")
100 | println(unverified2)
101 |
102 | println("result of verification: ")
103 | println(verified2)
104 |
105 | println("--------------------")
106 |
107 | val unverified3 = UnverifiedWebForm("Peter", "Becich", 1234567890, "peter@datascience.com")
108 | println("unverified: ")
109 | println(unverified3)
110 |
111 | val verified3 = verify(unverified3)
112 |
113 | println("result of verification: ")
114 | println(verified3)
115 |
116 |
117 |
118 |
119 | }
120 |
121 |
122 |
--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Scala by DS12
7 |
8 |
17 |
30 |
31 |
32 |
33 |
34 |
108 |
109 | Lectures 4-13a are numbered according to their corresponding chapter in Functional Programming in Scala .
110 |
111 |
115 |
{{ head_title }}
29 |
30 | {% if embed %}
31 |
34 |
37 | {% else %}
38 |
87 |
88 |
91 |
92 | {% for slide in slides %}
93 |
94 |
95 |
96 |
97 | {% if slide.header %}
98 |
99 | {% endif %}
100 | {% if slide.content %}
101 |
102 | {% endif %}
103 |
104 |
105 |
106 |
107 | {% if slide.presenter_notes %}
108 | {{ slide.presenter_notes }}
109 | {% endif %}
110 |
111 |
112 |
113 |
114 |
115 | {% if slide.source %}
116 |
119 | {% endif %}
120 |
121 | {{ slide.number }}/{{ num_slides }}
122 |
123 |
124 |
125 |
126 |
127 | {% endfor %}
128 |
129 |
').
8 | completions Displays a list of completions for the given argument string (run 'completions ').
9 | about Displays basic information about sbt and the build.
10 | tasks Lists the tasks defined for the current project.
11 | reload (Re)loads the current project or changes to plugins project or returns from it.
12 | projects Lists the names of available projects or temporarily adds/removes extra builds to the session.
13 | project Displays the current project or changes to the provided `project`.
14 | last Displays output from a previous command or the output from a specific task.
15 | last-grep Shows lines from the last output for 'key' that match 'pattern'.
16 | exit Terminates the build.
17 |
18 | All commands -- common to all SBT projects
19 |
20 | > help
21 | help
22 |
23 | debugging Add debugging flags to all forked JVM processes.
24 | debugging-off Remove debugging flags from all forked JVM processes.
25 | help Displays this help message or prints detailed help on requested commands (run 'help ').
26 | completions Displays a list of completions for the given argument string (run 'completions ').
27 | about Displays basic information about sbt and the build.
28 | tasks Lists the tasks defined for the current project.
29 | settings Lists the settings defined for the current project.
30 | reload (Re)loads the current project or changes to plugins project or returns from it.
31 | projects Lists the names of available projects or temporarily adds/removes extra builds to the session.
32 | project Displays the current project or changes to the provided `project`.
33 | set [every] Evaluates a Setting and applies it to the current project.
34 | session Manipulates session settings. For details, run 'help session'.
35 | inspect [uses|tree|definitions] Prints the value for 'key', the defining scope, delegates, related definitions, and dependencies.
36 | Sets the logging level to 'log-level'. Valid levels: debug, info, warn, error
37 | plugins Lists currently available plugins.
38 | ; (; )* Runs the provided semicolon-separated commands.
39 | ~ Executes the specified command whenever source files change.
40 | last Displays output from a previous command or the output from a specific task.
41 | last-grep Shows lines from the last output for 'key' that match 'pattern'.
42 | export + Executes tasks and displays the equivalent command lines.
43 | exit Terminates the build.
44 | -- Schedules a command to run before other commands on startup.
45 | show Displays the result of evaluating the setting or task associated with 'key'.
46 | all + Executes all of the specified tasks concurrently.
47 |
48 |
49 | Most important tasks -- configurable by SBT project but usually unchanged
50 |
51 | This is a list of tasks defined for the current project.
52 | It does not list the scopes the tasks are defined in; use the 'inspect' command for that.
53 | Tasks produce values. Use the 'show' command to run the task and print the resulting value.
54 |
55 | clean Deletes files produced by the build, such as generated sources, compiled classes, and task caches.
56 | compile Compiles sources.
57 | console Starts the Scala interpreter with the project classes on the classpath.
58 | consoleProject Starts the Scala interpreter with the sbt and the build definition on the classpath and useful imports.
59 | consoleQuick Starts the Scala interpreter with the project dependencies on the classpath.
60 | run Runs a main class, passing along arguments provided on the command line.
61 | runMain Runs the main class selected by the first argument, passing the remaining arguments to the main method.
62 | test Executes all tests.
63 |
64 |
65 |
66 | All tasks -- configurable by SBT project but usually unchanged
67 |
68 | This is a list of tasks defined for the current project.
69 | It does not list the scopes the tasks are defined in; use the 'inspect' command for that.
70 | Tasks produce values. Use the 'show' command to run the task and print the resulting value.
71 |
72 | clean Deletes files produced by the build, such as generated sources, compiled classes, and task caches.
73 | compile Compiles sources.
74 | console Starts the Scala interpreter with the project classes on the classpath.
75 | consoleProject Starts the Scala interpreter with the sbt and the build definition on the classpath and useful imports.
76 | consoleQuick Starts the Scala interpreter with the project dependencies on the classpath.
77 | copyResources Copies resources to the output directory.
78 | doc Generates API documentation.
79 | package Produces the main artifact, such as a binary jar. This is typically an alias for the task that actually does the packaging.
80 | packageBin Produces a main artifact, such as a binary jar.
81 | packageDoc Produces a documentation artifact, such as a jar containing API documentation.
82 | packageSrc Produces a source artifact, such as a jar containing sources and resources.
83 | publish Publishes artifacts to a repository.
84 | publishLocal Publishes artifacts to the local Ivy repository.
85 | publishM2 Publishes artifacts to the local Maven repository.
86 | run Runs a main class, passing along arguments provided on the command line.
87 | runMain Runs the main class selected by the first argument, passing the remaining arguments to the main method.
88 | test Executes all tests.
89 | testOnly Executes the tests provided as arguments or all tests if no arguments are provided.
90 | testQuick Executes the tests that either failed before, were not run or whose transitive dependencies changed, among those provided as arguments.
91 | update Resolves and optionally retrieves dependencies, producing a report.
92 |
--------------------------------------------------------------------------------
/stylesheets/styles.css:
--------------------------------------------------------------------------------
1 | @font-face {
2 | font-family: 'Noto Sans';
3 | font-weight: 400;
4 | font-style: normal;
5 | src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot');
6 | src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot?#iefix') format('embedded-opentype'),
7 | local('Noto Sans'),
8 | local('Noto-Sans-regular'),
9 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff2') format('woff2'),
10 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff') format('woff'),
11 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.ttf') format('truetype'),
12 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.svg#NotoSans') format('svg');
13 | }
14 |
15 | @font-face {
16 | font-family: 'Noto Sans';
17 | font-weight: 700;
18 | font-style: normal;
19 | src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot');
20 | src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot?#iefix') format('embedded-opentype'),
21 | local('Noto Sans Bold'),
22 | local('Noto-Sans-700'),
23 | url('../fonts/Noto-Sans-700/Noto-Sans-700.woff2') format('woff2'),
24 | url('../fonts/Noto-Sans-700/Noto-Sans-700.woff') format('woff'),
25 | url('../fonts/Noto-Sans-700/Noto-Sans-700.ttf') format('truetype'),
26 | url('../fonts/Noto-Sans-700/Noto-Sans-700.svg#NotoSans') format('svg');
27 | }
28 |
29 | @font-face {
30 | font-family: 'Noto Sans';
31 | font-weight: 400;
32 | font-style: italic;
33 | src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot');
34 | src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot?#iefix') format('embedded-opentype'),
35 | local('Noto Sans Italic'),
36 | local('Noto-Sans-italic'),
37 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff2') format('woff2'),
38 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff') format('woff'),
39 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.ttf') format('truetype'),
40 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.svg#NotoSans') format('svg');
41 | }
42 |
43 | @font-face {
44 | font-family: 'Noto Sans';
45 | font-weight: 700;
46 | font-style: italic;
47 | src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot');
48 | src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot?#iefix') format('embedded-opentype'),
49 | local('Noto Sans Bold Italic'),
50 | local('Noto-Sans-700italic'),
51 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff2') format('woff2'),
52 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff') format('woff'),
53 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.ttf') format('truetype'),
54 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.svg#NotoSans') format('svg');
55 | }
56 |
57 | body {
58 | background-color: #fff;
59 | padding:50px;
60 | font: 14px/1.5 "Noto Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
61 | color:#727272;
62 | font-weight:400;
63 | }
64 |
65 | h1, h2, h3, h4, h5, h6 {
66 | color:#222;
67 | margin:0 0 20px;
68 | }
69 |
70 | p, ul, ol, table, pre, dl {
71 | margin:0 0 20px;
72 | }
73 |
74 | h1, h2, h3 {
75 | line-height:1.1;
76 | }
77 |
78 | h1 {
79 | font-size:28px;
80 | }
81 |
82 | h2 {
83 | color:#393939;
84 | }
85 |
86 | h3, h4, h5, h6 {
87 | color:#494949;
88 | }
89 |
90 | a {
91 | color:#39c;
92 | text-decoration:none;
93 | }
94 |
95 | a:hover {
96 | color:#069;
97 | }
98 |
99 | a small {
100 | font-size:11px;
101 | color:#777;
102 | margin-top:-0.3em;
103 | display:block;
104 | }
105 |
106 | a:hover small {
107 | color:#777;
108 | }
109 |
110 | .wrapper {
111 | width:860px;
112 | margin:0 auto;
113 | }
114 |
115 | blockquote {
116 | border-left:1px solid #e5e5e5;
117 | margin:0;
118 | padding:0 0 0 20px;
119 | font-style:italic;
120 | }
121 |
122 | code, pre {
123 | font-family:Monaco, Bitstream Vera Sans Mono, Lucida Console, Terminal, Consolas, Liberation Mono, DejaVu Sans Mono, Courier New, monospace;
124 | color:#333;
125 | font-size:12px;
126 | }
127 |
128 | pre {
129 | padding:8px 15px;
130 | background: #f8f8f8;
131 | border-radius:5px;
132 | border:1px solid #e5e5e5;
133 | overflow-x: auto;
134 | }
135 |
136 | table {
137 | width:100%;
138 | border-collapse:collapse;
139 | }
140 |
141 | th, td {
142 | text-align:left;
143 | padding:5px 10px;
144 | border-bottom:1px solid #e5e5e5;
145 | }
146 |
147 | dt {
148 | color:#444;
149 | font-weight:700;
150 | }
151 |
152 | th {
153 | color:#444;
154 | }
155 |
156 | img {
157 | max-width:100%;
158 | }
159 |
160 | header {
161 | width:270px;
162 | float:left;
163 | position:fixed;
164 | -webkit-font-smoothing:subpixel-antialiased;
165 | }
166 |
167 | header ul {
168 | list-style:none;
169 | height:40px;
170 | padding:0;
171 | background: #f4f4f4;
172 | border-radius:5px;
173 | border:1px solid #e0e0e0;
174 | width:270px;
175 | }
176 |
177 | header li {
178 | width:89px;
179 | float:left;
180 | border-right:1px solid #e0e0e0;
181 | height:40px;
182 | }
183 |
184 | header li:first-child a {
185 | border-radius:5px 0 0 5px;
186 | }
187 |
188 | header li:last-child a {
189 | border-radius:0 5px 5px 0;
190 | }
191 |
192 | header ul a {
193 | line-height:1;
194 | font-size:11px;
195 | color:#999;
196 | display:block;
197 | text-align:center;
198 | padding-top:6px;
199 | height:34px;
200 | }
201 |
202 | header ul a:hover {
203 | color:#999;
204 | }
205 |
206 | header ul a:active {
207 | background-color:#f0f0f0;
208 | }
209 |
210 | strong {
211 | color:#222;
212 | font-weight:700;
213 | }
214 |
215 | header ul li + li + li {
216 | border-right:none;
217 | width:89px;
218 | }
219 |
220 | header ul a strong {
221 | font-size:14px;
222 | display:block;
223 | color:#222;
224 | }
225 |
226 | section {
227 | width:500px;
228 | float:right;
229 | padding-bottom:50px;
230 | }
231 |
232 | small {
233 | font-size:11px;
234 | }
235 |
236 | hr {
237 | border:0;
238 | background:#e5e5e5;
239 | height:1px;
240 | margin:0 0 20px;
241 | }
242 |
243 | footer {
244 | width:270px;
245 | float:left;
246 | position:fixed;
247 | bottom:50px;
248 | -webkit-font-smoothing:subpixel-antialiased;
249 | }
250 |
251 | @media print, screen and (max-width: 960px) {
252 |
253 | div.wrapper {
254 | width:auto;
255 | margin:0;
256 | }
257 |
258 | header, section, footer {
259 | float:none;
260 | position:static;
261 | width:auto;
262 | }
263 |
264 | header {
265 | padding-right:320px;
266 | }
267 |
268 | section {
269 | border:1px solid #e5e5e5;
270 | border-width:1px 0;
271 | padding:20px 0;
272 | margin:0 0 20px;
273 | }
274 |
275 | header a small {
276 | display:inline;
277 | }
278 |
279 | header ul {
280 | position:absolute;
281 | right:50px;
282 | top:52px;
283 | }
284 | }
285 |
286 | @media print, screen and (max-width: 720px) {
287 | body {
288 | word-wrap:break-word;
289 | }
290 |
291 | header {
292 | padding:0;
293 | }
294 |
295 | header ul, header p.view {
296 | position:static;
297 | }
298 |
299 | pre, code {
300 | word-wrap:normal;
301 | }
302 | }
303 |
304 | @media print, screen and (max-width: 480px) {
305 | body {
306 | padding:15px;
307 | }
308 |
309 | header ul {
310 | width:99%;
311 | }
312 |
313 | header li, header ul li + li + li {
314 | width:33%;
315 | }
316 | }
317 |
318 | @media print {
319 | body {
320 | padding:0.4in;
321 | font-size:12pt;
322 | color:#444;
323 | }
324 | }
325 |
--------------------------------------------------------------------------------
/docs/stylesheets/styles.css:
--------------------------------------------------------------------------------
1 | @font-face {
2 | font-family: 'Noto Sans';
3 | font-weight: 400;
4 | font-style: normal;
5 | src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot');
6 | src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot?#iefix') format('embedded-opentype'),
7 | local('Noto Sans'),
8 | local('Noto-Sans-regular'),
9 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff2') format('woff2'),
10 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff') format('woff'),
11 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.ttf') format('truetype'),
12 | url('../fonts/Noto-Sans-regular/Noto-Sans-regular.svg#NotoSans') format('svg');
13 | }
14 |
15 | @font-face {
16 | font-family: 'Noto Sans';
17 | font-weight: 700;
18 | font-style: normal;
19 | src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot');
20 | src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot?#iefix') format('embedded-opentype'),
21 | local('Noto Sans Bold'),
22 | local('Noto-Sans-700'),
23 | url('../fonts/Noto-Sans-700/Noto-Sans-700.woff2') format('woff2'),
24 | url('../fonts/Noto-Sans-700/Noto-Sans-700.woff') format('woff'),
25 | url('../fonts/Noto-Sans-700/Noto-Sans-700.ttf') format('truetype'),
26 | url('../fonts/Noto-Sans-700/Noto-Sans-700.svg#NotoSans') format('svg');
27 | }
28 |
29 | @font-face {
30 | font-family: 'Noto Sans';
31 | font-weight: 400;
32 | font-style: italic;
33 | src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot');
34 | src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot?#iefix') format('embedded-opentype'),
35 | local('Noto Sans Italic'),
36 | local('Noto-Sans-italic'),
37 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff2') format('woff2'),
38 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff') format('woff'),
39 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.ttf') format('truetype'),
40 | url('../fonts/Noto-Sans-italic/Noto-Sans-italic.svg#NotoSans') format('svg');
41 | }
42 |
43 | @font-face {
44 | font-family: 'Noto Sans';
45 | font-weight: 700;
46 | font-style: italic;
47 | src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot');
48 | src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot?#iefix') format('embedded-opentype'),
49 | local('Noto Sans Bold Italic'),
50 | local('Noto-Sans-700italic'),
51 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff2') format('woff2'),
52 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff') format('woff'),
53 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.ttf') format('truetype'),
54 | url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.svg#NotoSans') format('svg');
55 | }
56 |
57 | body {
58 | background-color: #fff;
59 | padding:50px;
60 | font: 14px/1.5 "Noto Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
61 | color:#727272;
62 | font-weight:400;
63 | }
64 |
65 | h1, h2, h3, h4, h5, h6 {
66 | color:#222;
67 | margin:0 0 20px;
68 | }
69 |
70 | p, ul, ol, table, pre, dl {
71 | margin:0 0 20px;
72 | }
73 |
74 | h1, h2, h3 {
75 | line-height:1.1;
76 | }
77 |
78 | h1 {
79 | font-size:28px;
80 | }
81 |
82 | h2 {
83 | color:#393939;
84 | }
85 |
86 | h3, h4, h5, h6 {
87 | color:#494949;
88 | }
89 |
90 | a {
91 | color:#39c;
92 | text-decoration:none;
93 | }
94 |
95 | a:hover {
96 | color:#069;
97 | }
98 |
99 | a small {
100 | font-size:11px;
101 | color:#777;
102 | margin-top:-0.3em;
103 | display:block;
104 | }
105 |
106 | a:hover small {
107 | color:#777;
108 | }
109 |
110 | .wrapper {
111 | width:860px;
112 | margin:0 auto;
113 | }
114 |
115 | blockquote {
116 | border-left:1px solid #e5e5e5;
117 | margin:0;
118 | padding:0 0 0 20px;
119 | font-style:italic;
120 | }
121 |
122 | code, pre {
123 | font-family:Monaco, Bitstream Vera Sans Mono, Lucida Console, Terminal, Consolas, Liberation Mono, DejaVu Sans Mono, Courier New, monospace;
124 | color:#333;
125 | font-size:12px;
126 | }
127 |
128 | pre {
129 | padding:8px 15px;
130 | background: #f8f8f8;
131 | border-radius:5px;
132 | border:1px solid #e5e5e5;
133 | overflow-x: auto;
134 | }
135 |
136 | table {
137 | width:100%;
138 | border-collapse:collapse;
139 | }
140 |
141 | th, td {
142 | text-align:left;
143 | padding:5px 10px;
144 | border-bottom:1px solid #e5e5e5;
145 | }
146 |
147 | dt {
148 | color:#444;
149 | font-weight:700;
150 | }
151 |
152 | th {
153 | color:#444;
154 | }
155 |
156 | img {
157 | max-width:100%;
158 | }
159 |
160 | header {
161 | width:270px;
162 | float:left;
163 | position:fixed;
164 | -webkit-font-smoothing:subpixel-antialiased;
165 | }
166 |
167 | header ul {
168 | list-style:none;
169 | height:40px;
170 | padding:0;
171 | background: #f4f4f4;
172 | border-radius:5px;
173 | border:1px solid #e0e0e0;
174 | width:270px;
175 | }
176 |
177 | header li {
178 | width:89px;
179 | float:left;
180 | border-right:1px solid #e0e0e0;
181 | height:40px;
182 | }
183 |
184 | header li:first-child a {
185 | border-radius:5px 0 0 5px;
186 | }
187 |
188 | header li:last-child a {
189 | border-radius:0 5px 5px 0;
190 | }
191 |
192 | header ul a {
193 | line-height:1;
194 | font-size:11px;
195 | color:#999;
196 | display:block;
197 | text-align:center;
198 | padding-top:6px;
199 | height:34px;
200 | }
201 |
202 | header ul a:hover {
203 | color:#999;
204 | }
205 |
206 | header ul a:active {
207 | background-color:#f0f0f0;
208 | }
209 |
210 | strong {
211 | color:#222;
212 | font-weight:700;
213 | }
214 |
215 | header ul li + li + li {
216 | border-right:none;
217 | width:89px;
218 | }
219 |
220 | header ul a strong {
221 | font-size:14px;
222 | display:block;
223 | color:#222;
224 | }
225 |
226 | section {
227 | width:500px;
228 | float:right;
229 | padding-bottom:50px;
230 | }
231 |
232 | small {
233 | font-size:11px;
234 | }
235 |
236 | hr {
237 | border:0;
238 | background:#e5e5e5;
239 | height:1px;
240 | margin:0 0 20px;
241 | }
242 |
243 | footer {
244 | width:270px;
245 | float:left;
246 | position:fixed;
247 | bottom:50px;
248 | -webkit-font-smoothing:subpixel-antialiased;
249 | }
250 |
251 | @media print, screen and (max-width: 960px) {
252 |
253 | div.wrapper {
254 | width:auto;
255 | margin:0;
256 | }
257 |
258 | header, section, footer {
259 | float:none;
260 | position:static;
261 | width:auto;
262 | }
263 |
264 | header {
265 | padding-right:320px;
266 | }
267 |
268 | section {
269 | border:1px solid #e5e5e5;
270 | border-width:1px 0;
271 | padding:20px 0;
272 | margin:0 0 20px;
273 | }
274 |
275 | header a small {
276 | display:inline;
277 | }
278 |
279 | header ul {
280 | position:absolute;
281 | right:50px;
282 | top:52px;
283 | }
284 | }
285 |
286 | @media print, screen and (max-width: 720px) {
287 | body {
288 | word-wrap:break-word;
289 | }
290 |
291 | header {
292 | padding:0;
293 | }
294 |
295 | header ul, header p.view {
296 | position:static;
297 | }
298 |
299 | pre, code {
300 | word-wrap:normal;
301 | }
302 | }
303 |
304 | @media print, screen and (max-width: 480px) {
305 | body {
306 | padding:15px;
307 | }
308 |
309 | header ul {
310 | width:99%;
311 | }
312 |
313 | header li, header ul li + li + li {
314 | width:33%;
315 | }
316 | }
317 |
318 | @media print {
319 | body {
320 | padding:0.4in;
321 | font-size:12pt;
322 | color:#444;
323 | }
324 | }
325 |
--------------------------------------------------------------------------------
/misc/src/main/scala/com/datascience/education/misc/sudoku/Sudoku.scala:
--------------------------------------------------------------------------------
1 | package com.datascience.education.misc.sudoku
2 |
3 | import scala.language.postfixOps
4 |
5 | object Sudoku {
6 |
7 | /*
8 | "Unflatten" an element and return the row index it belongs to.
9 | 0-indexed
10 |
11 | val initial = List((0,5),(1,3),(4,7),(9,6),(12,1),(13,9),(14,5),...
12 |
13 | For example, element (1,3) belongs to row 0.
14 | */
15 | def row(element: (Int, Int)): Int = element._1 / 9
16 |
17 | /*
18 | "Unflatten" an element and return the column index it belongs to.
19 | 0-indexed
20 |
21 | For example, element(1,3) belongs to column 1.
22 | */
23 | def column(element: (Int, Int)): Int = element._1 % 9
24 |
25 | /*
26 | Tiles
27 |
28 | v index 0
29 | > 0 0 0 1 1 1 2 2 2
30 | 0 0 0 1 1 1 2 2 2
31 | 0 0 0 1 1 1 2 2 2
32 | 3 3 3 4 4 4 5 5 5
33 | 3 3 3 4 4 4 5 5 5
34 | 3 3 3 4 4 4 5 5 5
35 | 6 6 6 7 7 7 8 8 8 <- index 62
36 | 6 6 6 7 7 7 8 8 8
37 | 6 6 6 7 7 7 8 8 8 <- index 80
38 | ^
39 | "Unflatten" an element and return the tile index it belongs to.
40 |
41 | For example, element (1,3) belongs to tile 0.
42 |
43 | */
44 |
45 | def tile(element: (Int, Int)): Int = {
46 | val j = column(element)
47 | val tileX = j/3
48 |
49 | val i = row(element)
50 | val tileY = i/3
51 |
52 | val tile = tileX+3*tileY
53 |
54 | tile
55 | }
56 |
57 |
58 | /*
59 | 1a
60 | check rows for uniqueness
61 |
62 | In a valid Sudoku board,
63 | each row contains only one copy of each digit 1-9.
64 | In other words, the 9 elements of each row correspond one-to-one with the 9 digits in [1,9].
65 |
66 | Check that each row satisfies this requirement.
67 | */
68 | def checkX(board: List[(Int,Int)], next: (Int,Int)): Boolean = {
69 | def check(b: Boolean, tuple: (Int,Int)): Boolean = {
70 | b && ((row(tuple) == row(next) && tuple._2 != next._2) || row(tuple) != row(next))
71 |
72 | }
73 |
74 | val c = board.foldLeft(0)((count: Int, _: (Int, Int)) => count+1)
75 |
76 |
77 | board.foldLeft(true)(check)
78 | }
79 |
80 | /*
81 | TASK
82 | check columns for uniqueness
83 |
84 | In a valid Sudoku board,
85 | each column contains only one copy of each digit 1-9.
86 | This is the same rule as in `checkX`, but for columns.
87 |
88 | Check that each column satisfies this requirement.
89 | */
90 | def checkY(board: List[(Int,Int)], next: (Int,Int)): Boolean = ???
91 |
92 | /*
93 | TASK 1b
94 | check tiles for uniqueness
95 |
96 | A Sudoku board contains 9 3x3 tiles.
97 |
98 | As with each row and each column of the board,
99 | each tile must contain only one copy of each digit 1-9.
100 |
101 | */
102 | def checkT(board: List[(Int,Int)], next: (Int,Int)): Boolean = ???
103 | /*
104 | TASK 1c
105 | check that a given position has not been filled
106 | */
107 | def notPlayed(board: List[(Int,Int)], index: Int): Boolean = ???
108 |
109 | /*
110 | TASK 1d
111 | check that a given position is legal with respect to checkX, checkY, checkT
112 | */
113 | def isLegal(board: List[(Int,Int)], next: (Int,Int)): Boolean = ???
114 |
115 | //recursively provide all solutions to puzzle w/ given initial conds
116 | def sudokuSolve(initial: List[(Int,Int)]): Set[List[(Int,Int)]] = {
117 |
118 | // indices of empty board elements, given initial conditions (pre-filled board)
119 | val indices: List[Int] =
120 | (0 until 81) filter { index => notPlayed(initial, index)} toList
121 |
122 | /*
123 | TASK 1e
124 | */
125 | def sudokuIter(indices: List[Int]): Set[List[(Int,Int)]] = ???
126 |
127 | sudokuIter(indices)
128 | }
129 |
130 |
131 | def sudokuAll(index: Int): Set[List[(Int,Int)]] = {
132 | if (index == -1) Set(List())
133 | else
134 | for {
135 | board <- sudokuAll(index-1)
136 | k <- 0 until 9
137 | if isLegal(board, (index,k))
138 | } yield (index,k)::board
139 | }
140 |
141 | //plotting util
142 | def sudokuPlot(board: List[(Int,Int)]): String = {
143 | val out = Array.ofDim[Int](9,9)
144 | for {move <- board} out(move._1 / 9)(move._1 % 9) = move._2
145 | out.map({_.mkString(" ")}).mkString("\n")
146 | }
147 |
148 | /*
149 |
150 | A sample Sudoku board as a List of (position, value) tuples. Positions are in row major format.
151 |
152 | Row-major order
153 | https://en.wikipedia.org/wiki/Row-major_order
154 |
155 | Each element of the list below corresponds to an element in the Sudoku board.
156 | This board has been "flattened" into a row-major list. The first element of each tuple is the "flattened" coordinate in the Sudoku board (explained momentarily), and the second element of each tuple is the value itself.
157 |
158 | First, let's establish syntax for elements of the board
159 |
160 | Given element M_ij,
161 | i is the row and j is the column
162 |
163 | Our row and column indices are 0-indexed, in contrast to the 1-indexed convention of a mathematical matrix.
164 |
165 | A Sudoku board is 9 by 9 elements.
166 |
167 | (0, 5) is placed at M_00
168 | (1, 3) is placed at M_01
169 | (4, 7) is placed at M_04
170 | (12, 1) is placed at M_13
171 |
172 | Here is partial plot of these four elements, with absent elements of the board filled by 0
173 |
174 | 5 3 0 0 7 0 0 0 0
175 | 0 0 0 1 0 0 0 0 0
176 | 0 0 0 0 0 0 0 0 0
177 | 0 0 0 0 0 0 0 0 0
178 | 0 0 0 0 0 0 0 0 0
179 | 0 0 0 0 0 0 0 0 0
180 | 0 0 0 0 0 0 0 0 0
181 | 0 0 0 0 0 0 0 0 0
182 | 0 0 0 0 0 0 0 0 0
183 |
184 | You can print all of `initial` by running `SudokuPreview`
185 | */
186 | val initial = List((0,5),(1,3),(4,7),(9,6),(12,1),(13,9),(14,5),
187 | (19,9),(20,8),(25,6),(27,8),(31,6),(35,3),(36,4),
188 | (39,8),(41,3),(44,1),(45,7),(49,2),(53,6),(55,6),
189 | (60,2),(61,8),(66,4),(67,1),(68,9),(71,5),(76,8),(79,7),(80,9))
190 |
191 | val initial2 = List((0,5),(1,3),(4,7), (12,1),(13,9),(14,5),
192 | (19,9),(20,8), (27,8),(31,6),(35,3),
193 | (39,8), (44,1),(45,7),(49,2), (55,6),
194 | (60,2),(61,8),(66,4), (68,9),(71,5),(76,8),(79,7),(80,9))
195 |
196 |
197 |
198 | }
199 |
200 | object SudokuPreview extends App {
201 | import Sudoku._
202 |
203 |
204 | println("find solutions for this Sudoku board:")
205 |
206 | println(sudokuPlot(initial))
207 |
208 | val test: List[(Int, Int)] = (0 until 81).toList.map(d => (d, d))
209 |
210 | val rows = test.map(tuple => (tuple._1, row(tuple)))
211 |
212 | println("rows")
213 | println(sudokuPlot(rows))
214 |
215 | val columns = test.map(tuple => (tuple._1, column(tuple)))
216 |
217 | println("columns")
218 | println(sudokuPlot(columns))
219 |
220 | val tiles = test.map(tuple => (tuple._1, tile(tuple)))
221 |
222 | println("tiles")
223 | println(sudokuPlot(tiles))
224 |
225 | }
226 |
227 | // TASK 1f
228 | object SudokuSolver extends App {
229 | import Sudoku._
230 |
231 | println("find solutions for this Sudoku board:")
232 | println(sudokuPlot(initial))
233 |
234 | val solutionStrings: Set[String] = sudokuSolve(initial).map(board => sudokuPlot(board))
235 |
236 | solutionStrings.foreach { (solution: String) => println(s"solution \n $solution") }
237 |
238 |
239 |
240 | println("-----------------")
241 |
242 |
243 |
244 | println("find solutions for this Sudoku board (initial2):")
245 | println(sudokuPlot(initial2))
246 |
247 | val solutionStrings2: Set[String] = sudokuSolve(initial2).map(board => sudokuPlot(board))
248 |
249 | solutionStrings2.foreach { (solution: String) => println(s"solution \n $solution") }
250 |
251 |
252 |
253 |
254 |
255 | }
256 |
257 |
258 |
--------------------------------------------------------------------------------
/slides/lecture6.md:
--------------------------------------------------------------------------------
1 |
2 | #Lecture 6: Purely Functional State
3 |
4 |
303 | scala> u(a)
304 | res2: (Int, RNG) = (1,RNG(123))
305 |
306 | 
5 |