// Scala Lecture 1

//=================

// Value assignments

// (their names should be lower case)

//===================================

val x = 42

val y = 3 + 4

val z = x / y

// (you cannot reassign values: z = 9 will give an error)

// Collections

//=============

List(1,2,3,1)

Set(1,2,3,1)

1 to 10

(1 to 10).toList

(1 until 10).toList

// an element in a list

val lst = List(1, 2, 3, 1)

lst(0)

lst(2)

// some alterative syntax for lists

1::2::3::Nil

List(1, 2, 3) ::: List(4, 5, 6)

// Printing/Strings

//==================

println("test")

val tst = "This is a " + "test\n" 

println(tst)

val lst = List(1,2,3,1)

println(lst.toString)

println(lst.mkString("\n"))

println(lst.mkString(", "))

// some methods take more than one argument

println(lst.mkString("[", ",", "]"))

// Conversion methods

//====================

List(1,2,3,1).toString

List(1,2,3,1).toSet

"hello".toList

1.toDouble

// useful list methods

List(1,2,3,4).length

List(1,2,3,4).reverse

List(1,2,3,4).max

List(1,2,3,4).min

List(1,2,3,4).sum

List(1,2,3,4).take(2).sum

List(1,2,3,4).drop(2).sum

List(1,2,3,4,3)indexOf(3)

"1,2,3,4,5".split(",").mkString("\n")

"1,2,3,4,5".split(",3,").mkString("\n")

// Types

//=======

/* Scala is a strongly typed language

 * some base types

    Int, Long, BigInt, Float, Double

    String, Char

    Boolean

 * some compound types 

    List[Int],

    Set[Double]

    Pairs: (Int, String)        

    List[(BigInt, String)]

*/

// Smart Strings

//===============

println(">\n\n<")

println(""">\n<""")

println("""">\n<"""")

/* in Java

val lyrics = "Baa, Baa, Black Sheep \n" +

             "Have you any wool? \n" +

             "Yes, sir, yes sir \n" +

             "Three bags full"

*/ 

val lyrics = """Baa, Baa, Black Sheep  

                |Have you any wool?

                |Yes, sir, yes sir

                |Three bags full""".stripMargin

println(lyrics)

// Pairs/Tuples

//==============

val p = (1, "one")

p._1

p._2

val t = (4,1,2,3)

t._4

// Function Definitions

//======================

def incr(x: Int) : Int = x + 1

def double(x: Int) : Int = x + x

def square(x: Int) : Int = x * x

square(6)

// The general scheme for a function: you have to give a type 

// to each argument and a return type of the function

//

//  def fname(arg1: ty1, arg2: ty2,..., argn: tyn): rty = {

//    body 

//  }

// If-Conditionals

//=================

def fact(n: Int): Int = 

  if (n == 0) 1 else n * fact(n - 1)

fact(5)

fact(150)

/* boolean operators

   ==     equals

   !      not

   && ||  and, or

*/

def fact2(n: BigInt): BigInt = 

  if (n == 0) 1 else n * fact2(n - 1)

fact2(150)

def fib(n: Int): Int =

  if (n == 0) 1 else

    if (n == 1) 1 else fib(n - 1) + fib(n - 2)

//gcd - Euclid's algorithm

def gcd(a: Int, b: Int) : Int =

  if (b == 0) a else gcd(b, a % b)

gcd(48, 18)

def power(x: Int, n: Int) : Int =

  if (n == 0) 1  else x * power(x, n - 1) 

power(5, 5)

// String Interpolations

//=======================

val n = 3

println("The square of " + n + " is " + square(n) + ".")

println(s"The square of ${n} is ${square(n)}.")

def gcd_db(a: Int, b: Int) : Int = {

  println(s"Function called with ${a} and ${b}.")

  if (b == 0) a else gcd_db(b, a % b)

}

gcd_db(48, 18)

// Asserts/Testing

//================

assert(gcd(48, 18) == 6)

assert(gcd(48, 18) == 5, "The gcd test failed")

// For-Comprehensions (not For-Loops)

//====================================

for (n <- (1 to 10).toList) yield square(n)

for (n <- (1 to 10).toList; 

     m <- (1 to 10).toList) yield m * n

val mult_table = 

  for (n <- (1 to 10).toList; 

       m <- (1 to 10).toList) yield m * n

mult_table.sliding(10,10).mkString("\n")

// with if-predicates

for (n <- (1 to 3).toList; 

     m <- (1 to 3).toList;

     if (n + m) % 2 == 0) yield (n, m)

// with patterns

for ((m, n) <- List((1, 4), (2, 3), (3, 2), (4, 1))) yield m + n 

for (p <- List((1, 4), (2, 3), (3, 2), (4, 1))) yield p._1 + p._2 

// with only a side-effect (no list is produced),

// has no "yield"

for (n <- (1 to 10)) println(n)

// concurrency (ONLY WORKS IN SCALA 2.11.8, not in SCALA 2.12.0)

for (n <- (1 to 10)) println(n)

for (n <- (1 to 10).par) println(n)

// for measuring time

def time_needed[T](i: Int, code: => T) = {

  val start = System.nanoTime()

  for (j <- 1 to i) code

  val end = System.nanoTime()

  ((end - start) / i / 1.0e9) + " secs"

}

val list = (1 to 1000000).toList

time_needed(10, for (n <- list) yield n + 42)

time_needed(10, for (n <- list.par) yield n + 42)

// Webpages

//==========

import io.Source

// obtaining a webpage

val url = """https://nms.kcl.ac.uk/christian.urban/""" 

Source.fromURL(url)("ISO-8859-1").mkString

// function for looking up stockmarket data 

def price_lookup(symbol: String) : String = {

  val url = "https://download.finance.yahoo.com/d/quotes.csv?s=" + symbol + "&f=snl1"

  Source.fromURL(url).mkString.drop(1).dropRight(2)

}

price_lookup("GOOG")

price_lookup("AAPL")

val companies = 

  List("GOOG", "AAPL", "MSFT", "IBM", "FB", "YHOO", "AMZN", "BIDU")

for (s <- companies) println(price_lookup(s))

// A Web Crawler 

//===============

//

// the idea is to look for dead links using the

// regular expression "https?://[^"]*"

import io.Source

import scala.util.matching.Regex

import scala.util._

// gets the first 10K of a web-page

def get_page(url: String) : String = {

  Try(Source.fromURL(url)("ISO-8859-1").take(10000).mkString).

    getOrElse { println(s"  Problem with: $url"); ""}

}

// regex for URLs

val http_pattern = """"https?://[^"]*"""".r

// drops the first and last character from a string

def unquote(s: String) = s.drop(1).dropRight(1)

def get_all_URLs(page: String): Set[String] = 

  http_pattern.findAllIn(page).map(unquote).toSet

// naive version of crawl - searches until a given depth,

// visits pages potentially more than once

def crawl(url: String, n: Int): Unit = {

  if (n == 0) ()

  else {

    println(s"Visiting: $n $url")

    for (u <- get_all_URLs(get_page(url))) crawl(u, n - 1)

  }

}

// some starting URLs for the crawler

val startURL = """https://nms.kcl.ac.uk/christian.urban/"""

//val startURL = """http://www.inf.kcl.ac.uk/staff/mcburney"""

crawl(startURL, 2)

// Further Information

//=====================

// The Scala home page and general information is at

//

//  http://www.scala-lang.org

//	http://docs.scala-lang.org

//

//

// It should be fairly easy to install the Scala binary and

// run Scala on the commandline. There are also at least 

// four IDEs you can use with Scala:

//

//  (0) Some general information about setting up IDEs

//	    with Scala support can be found at

//

//         http://docs.scala-lang.org/getting-started.html 

//

//

//  (1) Eclipse for Scala (one big bundle)

//

//         http://scala-ide.org/download/sdk.html

//  

//  (2) IntelliJ (needs additional Plugins)

//

//         https://www.jetbrains.com/idea/

//		   http://docs.scala-lang.org/getting-started-intellij-track/getting-started-with-scala-in-intellij.html	  

//

//  (3) Sublime (not free, but unlimited trial period; 

//	    needs Scala and SublimeREPL plugin)

//

//         https://www.sublimetext.com

//

//  (4) Emacs (old-fashioned, but reliable)

//

//         https://www.gnu.org/software/emacs/

//

//      I use the old scala-tool support for Emacs distributed at

//

//         https://github.com/scala/scala-tool-support/tree/master/tool-support/emacs 

//

//      but there is also support for the newer Ensime Scala Mode

//

//         http://ensime.org/editors/emacs/scala-mode/   

//   

// There is also Scala support in the Atom editor, but my

// experience is mixed. People also use Scala with Vim and Jedit.

// Finally there is an online editor specifically designed for 

// running Scala applications (but do not blame mne if you lose all 

// what you typed in):

//

//      https://scalafiddle.io 

//

//

//

// All of the IDEs above support a REPL for Scala. Some of them have

// the very nifty feature of a Scala Worksheet -- you just save your

// file and it will be automatically evaluated and the result pasted

// into your file. However, this way of writing Scala code never worked

// for me. I just use the REPL.

//

//

// Scala Library Docs

//====================

//

//  http://www.scala-lang.org/api/current/

//

// Scala Tutorials

//

//  http://docs.scala-lang.org/tutorials/

//

// There are also a massive number of Scala tutorials on youtube

// and there are tons of books and free material.

//