4 // pattern-matching

     4 //===================

     5 // polymorphic types

     6 // (algebraic) datatypes and pattern-matching

     7 // extensions and implicits

     6 // polymorphic types

     9 

    10 

    11 

    12 // You do not want to write functions like contains, first, 

    13 // length and so on for every type of lists.

    14 

    15 def length_int_list(lst: List[Int]): Int = lst match {

    16   case Nil => 0

    17   case _::xs => 1 + length_int_list(xs)

    18 }

    19 

    20 length_int_list(List(1, 2, 3, 4))

    21 

    22 def length_string_list(lst: List[String]): Int = lst match {

    23   case Nil => 0

    24   case _::xs => 1 + length_string_list(xs)

    25 }

    26 

    27 length_string_list(List("1", "2", "3", "4"))

    28 

    29 

    30 // you can make the function parametric in type(s)

    31 

    32 def length[A](lst: List[A]): Int = lst match {

    33   case Nil => 0

    34   case x::xs => 1 + length(xs)

    35 }

    36 length(List("1", "2", "3", "4"))

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

    38 

    39 

    40 length[String](List(1, 2, 3, 4))

    41 

    42 

    43 def map[A, B](lst: List[A], f: A => B): List[B] = lst match {

    44   case Nil => Nil

    45   case x::xs => f(x)::map(xs, f) 

    46 }

    47 

    48 map(List(1, 2, 3, 4), (x: Int) => x.toString)

    49 

    50                                                                 

    51 // Type inference is local in Scala

    52 

    53 def id[T](x: T) : T = x

    54 

    55 val x = id(322)          // Int

    56 val y = id("hey")        // String

    57 val z = id(Set(1,2,3,4)) // Set[Int]

    58 

    59 

    60 // The type variable concept in Scala can get 

    61 // really complicated.

    62 //

    63 // - variance (OO)

    64 // - bounds (subtyping)

    65 // - quantification

    66 

    67 // Java has issues with this too: Java allows

    68 // to write the following incorrect code, and

    69 // only recovers by raising an exception

    70 // at runtime.

    71 

    72 // Object[] arr = new Integer[10];

    73 // arr[0] = "Hello World";

    74 

    75 

    76 // Scala gives you a compile-time error, which

    77 // is much better.

    78 

    79 var arr = Array[Int]()

    80 arr(0) = "Hello World"

    81 

    43 List(1,2,3,4).map(x => x * x)

   118 //=================

    44 

   119 // Trees (example of an Algebraic Datatype)

    45 def my_map_int(lst: List[Int], f: Int => Int) : List[Int] = 

    46   lst match {

    47     case Nil => Nil

    48     case foo::xs => f(foo) :: my_map_int(xs, f)

    49   }

    50 

    51 def my_map_option(opt: Option[Int], f: Int => Int) : Option[Int] = 

    52   opt match {

    53     case None => None

    54     case Some(x) => {

    55       Some(f(x))

    56     }

    57   }

    58 

    59 my_map_option(None, x => x * x)

    60 my_map_option(Some(8), x => x * x)

    61 

    62 

    63 // you can also have cases combined

    64 def season(month: String) : String = month match {

    65   case "March" | "April" | "May" => "It's spring"

    66   case "June" | "July" | "August" => "It's summer"

    67   case "September" | "October" | "November" => "It's autumn"

    68   case "December" => "It's winter"

    69   case "January" | "February" => "It's unfortunately winter"

    70   case _ => "Wrong month"

    71 }

    72 

    73 // pattern-match on integers

    74 

    75 def fib(n: Int) : Int = n match { 

    76   case 0 | 1 => 1

    77   case _ => fib(n - 1) + fib(n - 2)

    78 }

    79 

    80 fib(10)

    81 

    82 // pattern-match on results

    83 

    84 // Silly: fizz buzz

    85 def fizz_buzz(n: Int) : String = (n % 3, n % 5) match {

    86   case (0, 0) => "fizz buzz"

    87   case (0, _) => "fizz"

    88   case (_, 0) => "buzz"

    89   case _ => n.toString  

    90 }

    91 

    92 for (n <- 1 to 20) 

    93  println(fizz_buzz(n))

    94 

    95 // guards in pattern-matching

    96 

    97 def foo(xs: List[Int]) : String = xs match {

    98   case Nil => s"this list is empty"

    99   case x :: xs if x % 2 == 0 

   100      => s"the first elemnt is even"

   101   case x if len(x) ==

   102      => s"this list has exactly two elements"   

   103   case x :: y :: rest if x == y

   104      => s"this has two elemnts that are the same"

   105   case hd :: tl => s"this list is standard $hd::$tl"

   106 }

   107 

   108 foo(Nil)

   109 foo(List(1,2,3))

   110 foo(List(1,1))

   111 foo(List(1,1,2,3))

   112 foo(List(2,2,2,3))

   113 

   114 

   115 

   116 

   117 abstract class Colour

   118 case object Red extends Colour 

   119 case object Green extends Colour 

   120 case object Blue extends Colour

   121 case object Yellow extends Colour

   122 

   123 

   124 def fav_colour(c: Colour) : Boolean = c match {

   125   case Green => true

   126   case Red => true

   127   case _  => false 

   128 }

   129 

   130 fav_colour(Blue)

   131 

   132 

   133 // ... a tiny bit more useful: Roman Numerals

   134 

   135 sealed abstract class RomanDigit 

   136 case object I extends RomanDigit 

   137 case object V extends RomanDigit 

   138 case object X extends RomanDigit 

   139 case object L extends RomanDigit 

   140 case object C extends RomanDigit 

   141 case object D extends RomanDigit 

   142 case object M extends RomanDigit 

   143 

   144 type RomanNumeral = List[RomanDigit] 

   145 

   146 List(I, M,C,D,X,X,V,I,I, A)

   147 

   148 /*

   149 I    -> 1

   150 II   -> 2

   151 III  -> 3

   152 IV   -> 4

   153 V    -> 5

   154 VI   -> 6

   155 VII  -> 7

   156 VIII -> 8

   157 IX   -> 9

   158 X    -> 10

   159 */

   160 

   161 def RomanNumeral2Int(rs: RomanNumeral): Int = rs match { 

   162   case Nil => 0

   163   case M::r    => 1000 + RomanNumeral2Int(r)  

   164   case C::M::r => 900 + RomanNumeral2Int(r)

   165   case D::r    => 500 + RomanNumeral2Int(r)

   166   case C::D::r => 400 + RomanNumeral2Int(r)

   167   case C::r    => 100 + RomanNumeral2Int(r)

   168   case X::C::r => 90 + RomanNumeral2Int(r)

   169   case L::r    => 50 + RomanNumeral2Int(r)

   170   case X::L::r => 40 + RomanNumeral2Int(r)

   171   case X::r    => 10 + RomanNumeral2Int(r)

   172   case I::X::r => 9 + RomanNumeral2Int(r)

   173   case V::r    => 5 + RomanNumeral2Int(r)

   174   case I::V::r => 4 + RomanNumeral2Int(r)

   175   case I::r    => 1 + RomanNumeral2Int(r)

   176 }

   177 

   178 RomanNumeral2Int(List(I,V))             // 4

   179 RomanNumeral2Int(List(I,I,I,I))         // 4 (invalid Roman number)

   180 RomanNumeral2Int(List(V,I))             // 6

   181 RomanNumeral2Int(List(I,X))             // 9

   182 RomanNumeral2Int(List(M,C,M,L,X,X,I,X)) // 1979

   183 RomanNumeral2Int(List(M,M,X,V,I,I))     // 2017

   186 case class Leaf(x: Int)

   122 case class Leaf(x: Int) extends Tree

   187 case class Branch(tl: Tree, tr: Tree)

   123 case class Node(s: String, left: Tree, right: Tree) extends Tree 

   124 

   125 val lf = Leaf(20)

   126 val tr = Node("foo", Leaf(10), Leaf(23))

   127 

   128 val lst : List[Tree] = List(lf, tr)

   129 

   130 

   208 // Trees (example of an Algebraic Datatype)

   151 

   209 

   210 

   211 abstract class Tree

   212 case class Leaf(x: Int) extends Tree

   213 case class Node(s: String, left: Tree, right: Tree) extends Tree 

   214 

   215 val lf = Leaf(20)

   216 val tr = Node("foo", Leaf(10), Leaf(23))

   217 

   218 val lst : List[Tree] = List(lf, tr)

   330 factT(10, 1)

   263 factT(1000,1)

   360 

   293 // default arguments

   361 // Polymorphic Types

   294 

   362 //===================

   295 def factT(n: BigInt, acc: BigInt = 1): BigInt =

   363 

   296   if (n == 0) acc else factT(n - 1, n * acc)

   364 // You do not want to write functions like contains, first, 

   297 

   365 // length and so on for every type of lists.

   298 factT(1_000_000)

   366 

   299 

   367 def length_int_list(lst: List[Int]): Int = lst match {

   300 

   301 def length[A](xs: List[A]) : Int = xs match {

   369   case _::xs => 1 + length_int_list(xs)

   303   case _ :: tail => 1 + length(tail)

   370 }

   304 }

   371 

   305 

   372 length_int_list(List(1, 2, 3, 4))

   306 length(List.fill(100000)(1))

   373 

   307 

   374 def length_string_list(lst: List[String]): Int = lst match {

   308 def lengthT[A](xs: List[A], acc : Int = 0) : Int = xs match {

   375   case Nil => 0

   309   case Nil => acc

   376   case _::xs => 1 + length_string_list(xs)

   310   case _ :: tail => lengthT(tail, 1 + acc)

   377 }

   311 }

   378 

   312 

   379 length_string_list(List("1", "2", "3", "4"))

   313 lengthT(List.fill(100000)(1))

   380 

   314 

   381 

   315 

   382 // you can make the function parametric in type(s)

   316 

   383 

   317 

   384 def length[A](lst: List[A]): Int = lst match {

   385   case Nil => 0

   386   case x::xs => 1 + length(xs)

   387 }

   388 length(List("1", "2", "3", "4"))

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

   390 

   391 

   392 length[String](List(1, 2, 3, 4))

   393 

   394 

   395 def map[A, B](lst: List[A], f: A => B): List[B] = lst match {

   396   case Nil => Nil

   397   case x::xs => f(x)::map(xs, f) 

   398 }

   399 

   400 map(List(1, 2, 3, 4), (x: Int) => x.toString)

   401 

   402 

   403 // should be

   404 def first[A, B](xs: List[A], f: A => Option[B]) : Option[B] = ???

   405 

   406 // Type inference is local in Scala

   407 

   408 def id[T](x: T) : T = x

   409 

   410 val x = id(322)          // Int

   411 val y = id("hey")        // String

   412 val z = id(Set(1,2,3,4)) // Set[Int]

   413 

   414 

   415 // The type variable concept in Scala can get really complicated.

   416 //

   417 // - variance (OO)

   418 // - bounds (subtyping)

   419 // - quantification

   420 

   421 // Java has issues with this too: Java allows

   422 // to write the following incorrect code, and

   423 // only recovers by raising an exception

   424 // at runtime.

   425 

   426 // Object[] arr = new Integer[10];

   427 // arr[0] = "Hello World";

   428 

   429 

   430 // Scala gives you a compile-time error, which

   431 // is much better.

   432 

   433 var arr = Array[Int]()

   434 arr(0) = "Hello World"

   675         searchT(cs.map(c => update(game, empty(game), c)) ::: rest, sols)

   538         searchT(cs.map(c => update(game, empty(game), c)) 

   539                   ::: rest, sols)

   733 // using implicit conversions.

   597 // using an extension.

   734 

   598 

   735 print("\n")

   599 

   736 print("""\n""")

   600 extension (s: String) {

   737 

   738 implicit class MyString(s: String) {

   761 implicit class Int2Duration(that: Int) {

   617 extension (that: Int) {

   800 implicit def string2rexp(s: String): Rexp = 

   655 given Conversion[String, Rexp] = 

   801   charlist2rexp(s.toList)

   656    (s => charlist2rexp(s.toList))

   807 implicit def RexpOps (r: Rexp) = new {

   662 extension (r: Rexp) {

   853 implicit def double2complex(re: Double) = Complex(re, 0)

   702 given Conversion[Double, Complex] = (re: Double) => Complex(re, 0)