pep-material: comparison progs/lecture3.scala

equal deleted inserted replaced

-:15f1fca879c5
+:94b11ac19b41
 // Pattern Matching
 //==================
 // A powerful tool which is supposed to come to Java in a few years
 // time (https://www.youtube.com/watch?v=oGll155-vuQ)...Scala already
-// has it for many years. Other functional languages have it for
+// has it for many years. Other functional languages have it already for
-// decades. I think I would refuse to program in a language that
+// decades. I think I would be really upset if a programming language
-// does not have pattern matching....its is just so elegant. ;o)
+// I have to use does not have pattern matching....its is just so
+// useful. ;o)
 // The general schema:
 //
 //    expression match {
 //       case pattern1 => expression1
 // remember
 val lst = List(None, Some(1), Some(2), None, Some(3)).flatten
 def my_flatten(xs: List[Option[Int]]): List[Int] = {
-...?
+if (xs == Nil) Nil
-}
+else if (xs.head == None) my_flatten(xs.tail)
+else xs.head.get :: my_flatten(xs.tail)
+}
+val lst = List(None, Some(1), Some(2), None, Some(3))
 def my_flatten(lst: List[Option[Int]]): List[Int] = lst match {
 case Nil => Nil
 case None::xs => my_flatten(xs)
 case Some(n)::xs => n::my_flatten(xs)
 }
+my_flatten(lst)
+Nil == List()
 // another example including a catch-all pattern
 def get_me_a_string(n: Int): String = n match {
 case 0 => "zero"
 case 1 => "one"
 case 2 => "two"
 case _ => "many"
 }
-get_me_a_string(0)
+get_me_a_string(10)
 // you can also have cases combined
 def season(month: String) = month match {
 case "March" | "April" | "May" => "It's spring"
 case "June" | "July" | "August" => "It's summer"
 // What happens if no case matches?
 println(season("foobar"))
-// Collatz function on binary strings
+// we can also match more complicated pattern
+//
+// let's look at the Collatz function on binary strings
 // adding two binary strings in a very, very lazy manner
 def badd(s1: String, s2: String) : String =
 (BigInt(s1, 2) + BigInt(s2, 2)).toString(2)
-// collatz function on binary numbers
+"111".dropRight(1)
+"111".last
 def bcollatz(s: String) : Long = (s.dropRight(1), s.last) match {
-case ("", '1') => 1                                  // we reached 1
+case ("", '1') => 1                               // we reached 1
-case (rest, '0') => 1 + bcollatz(rest)               // even number => divide by two
+case (rest, '0') => 1 + bcollatz(rest)
-case (rest, '1') => 1 + bcollatz(badd(s + '1', s))   // odd number => s + '1' is 2 * s + 1
+// even number => divide by two
-//               add another s gives 3 * s + 1
+case (rest, '1') => 1 + bcollatz(badd(s + '1', s))
+// odd number => s + '1' is 2 * s + 1
+// add another s gives 3 * s + 1
 }
-bcollatz(9.toBinaryString)
+bcollatz(6.toBinaryString)
 bcollatz(837799.toBinaryString)
 bcollatz(100000000000000000L.toBinaryString)
 bcollatz(BigInt("1000000000000000000000000000000000000000000000000000000000000000000000000000").toString(2))
 // User-defined Datatypes
 //========================
 abstract class Colour
-case class Red() extends Colour
+case object Red extends Colour
-case class Green() extends Colour
+case object Green extends Colour
-case class Blue() extends Colour
+case object Blue extends Colour
 def fav_colour(c: Colour) : Boolean = c match {
-case Red()   => false
+case Red   => false
-case Green() => true
+case Green => true
-case Blue()  => false
+case Blue  => false
 }
+fav_colour(Green)
 // actually colors can be written with "object",
 // because they do not take any arguments
+// ... a bit more useful: Roman Numerals
-// Roman Numerals
 abstract class RomanDigit
 case object I extends RomanDigit
 case object V extends RomanDigit
 case object X extends RomanDigit
 case object L extends RomanDigit
 case V::r    => 5 + RomanNumeral2Int(r)
 case I::V::r => 4 + RomanNumeral2Int(r)
 case I::r    => 1 + RomanNumeral2Int(r)
 }
-RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid roman number)
 RomanNumeral2Int(List(I,V))             // 4
+RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid Roman number)
 RomanNumeral2Int(List(V,I))             // 6
 RomanNumeral2Int(List(I,X))             // 9
 RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979
 RomanNumeral2Int(List(M,M,X,V,I,I))     // 2017
 // another example
 //=================
-// Once upon a time, in a complete fictional country there were persons...
+// Once upon a time, in a complete fictional country there were Persons...
 abstract class Person
-case class King() extends Person
+case object King extends Person
 case class Peer(deg: String, terr: String, succ: Int) extends Person
 case class Knight(name: String) extends Person
 case class Peasant(name: String) extends Person
+case object Clown extends Person
 def title(p: Person): String = p match {
-case King() => "His Majesty the King"
+case King => "His Majesty the King"
 case Peer(deg, terr, _) => s"The ${deg} of ${terr}"
 case Knight(name) => s"Sir ${name}"
 case Peasant(name) => name
-}
+case Clown => "My name is Boris Johnson"
+}
+title(Clown)
 def superior(p1: Person, p2: Person): Boolean = (p1, p2) match {
-case (King(), _) => true
+case (King, _) => true
 case (Peer(_,_,_), Knight(_)) => true
 case (Peer(_,_,_), Peasant(_)) => true
-case (Peer(_,_,_), Clown()) => true
+case (Peer(_,_,_), Clown) => true
 case (Knight(_), Peasant(_)) => true
-case (Knight(_), Clown()) => true
+case (Knight(_), Clown) => true
-case (Clown(), Peasant(_)) => true
+case (Clown, Peasant(_)) => true
 case _ => false
 }
 val people = List(Knight("David"),
 Peer("Duke", "Norfolk", 84),
 Peasant("Christian"),
-King(),
+King,
-Clown())
+Clown)
 println(people.sortWith(superior(_, _)).mkString(", "))
 fact(10000)           // produces a stackoverflow
 def factT(n: BigInt, acc: BigInt): BigInt =
 if (n == 0) acc else factT(n - 1, n * acc)
+factT(10, 1)
 factT(100000, 1)
 // there is a flag for ensuring a function is tail recursive
 import scala.annotation.tailrec
 //candidates(game0, (0,0))
 def pretty(game: String): String =
 "\n" + (game sliding (MaxValue, MaxValue) mkString "\n")
+/////////////////////
 // not tail recursive
 def search(game: String): List[String] = {
 if (isDone(game)) List(game)
 else {
 val cs = candidates(game, emptyPosition(game))
 cs.map(c => search(update(game, empty(game), c))).toList.flatten
 }
 }
 // tail recursive version that searches
-// for all solution
+// for all solutions
 def searchT(games: List[String], sols: List[String]): List[String] = games match {
 case Nil => sols
 case game::rest => {
 if (isDone(game)) searchT(rest, game::sols)
 else {
 searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols)
 }
 }
 }
+searchT(List(game3), List()).map(pretty)
 // tail recursive version that searches
 // for a single solution
 def search1T(games: List[String]): Option[String] = games match {
 case Nil => None
 case game::rest => {
 if (isDone(game)) Some(game)
 else {
 val cs = candidates(game, emptyPosition(game))
 search1T(cs.map(c => update(game, empty(game), c)) ::: rest)
 }
 }
 }
+search1T(List(game3)).map(pretty)
 // game with multiple solutions
 val game3 = """.8...9743
 |.5...8.1.
 |.1.......
 |...3....6
 |.......7.
 |.3.5...8.
 |9724...5.""".stripMargin.replaceAll("\\n", "")
-searchT(List(game3), List()).map(pretty)
+searchT(List(game3), Nil).map(pretty)
 search1T(List(game3)).map(pretty)
 // Moral: Whenever a recursive function is resource-critical
-// (i.e. works with large recursion depths), then you need to
+// (i.e. works with large recursion depth), then you need to
 // write it in tail-recursive fashion.
 //
 // Unfortuantely, Scala because of current limitations in
 // the JVM is not as clever as other functional languages. It can
 // only optimise "self-tail calls". This excludes the cases of
 def length_string_list(lst: List[String]): Int = lst match {
 case Nil => 0
 case x::xs => 1 + length_string_list(xs)
 }
+def length_int_list(lst: List[Int]): Int = lst match {
+case Nil => 0
+case x::xs => 1 + length_int_list(xs)
+}
 length_string_list(List("1", "2", "3", "4"))
+length_int_list(List(1, 2, 3, 4))
+//-----
 def length[A](lst: List[A]): Int = lst match {
 case Nil => 0
 case x::xs => 1 + length(xs)
 }
+length(List("1", "2", "3", "4"))
+length(List(King, Knight("foo"), Clown))
-def map_int_list(lst: List[Int], f: Int => Int): List[Int] = lst match {
+length(List(1, 2, 3, 4))
+def map[A, B](lst: List[A], f: A => B): List[B] = lst match {
 case Nil => Nil
 case x::xs => f(x)::map_int_list(xs, f)
 }
 map_int_list(List(1, 2, 3, 4), square)
 // Remember?
 def first[A, B](xs: List[A], f: A => Option[B]): Option[B] = ...
 // Cool Stuff
 //============
 // Implicits
 //===========
 //
 case class ALT(r1: Rexp, r2: Rexp) extends Rexp     // alternative  r1 + r2
 case class SEQ(r1: Rexp, r2: Rexp) extends Rexp     // sequence     r1 o r2
 case class STAR(r: Rexp) extends Rexp               // star         r*
 // (ab)*
 val r0 = STAR(SEQ(CHAR('a'), CHAR('b')))
 // some convenience for typing in regular expressions
 }
 implicit def string2rexp(s: String): Rexp = charlist2rexp(s.toList)
 val r1 = STAR("ab")
-val r2 = STAR("")
+val r2 = STAR(ALT("ab"))
 val r3 = STAR(ALT("ab", "baa baa black sheep"))
 implicit def RexpOps (r: Rexp) = new {
 def | (s: Rexp) = ALT(r, s)
 def % = STAR(r)
 // Make your variables immutable, unless there's a good
 // reason not to.
 // You can be productive on Day 1, but the language is deep.
+//
-// I like best about Scala that it lets me write
+// http://scalapuzzlers.com
+//
+// http://www.latkin.org/blog/2017/05/02/when-the-scala-compiler-doesnt-help/
+List(1, 2, 3) contains "your mom"
+// I like best about Scala that it lets me often write
 // concise, readable code.

changeset 158	94b11ac19b41
parent 155	371acb50643d
child 170	37b1bfcdba79