MI-PSL-6

Question 1

1. What is it a literal pattern? Write a simple example.

Answer 1

Pattern je konstrukt, který může být porovnáván vůči hodnotě.
Výraz je porovnáván vůči literálu (konstantě) a vyhoví, pokud equals.

def spell(x: Int) =
   x match {
      case 0 => "zero" // 0 is a literal pattern hear
      case 1 => "one"
      case 2 => "two"
   }

Question 2

2. What happens if no matching pattern is found.

Answer 2

MatchError exception je vyhozena

Question 3

3. What is it a placeholder pattern and where it is usually used?

Answer 3

Placeholder pattern je něco jako default u switche v javě. Je to wildcard, když nic jiného nematchuje. Zapisuje se podtržítkem. Volitelně je možné uvést typ, který musí hodnota splňovat.

x match {
    // ...
    case _ : Int => "an integer"
    case _ => "something else"
}

Question 4

4. What is it a variable pattern?

Answer 4

Variable pattern matchuje s každým výrazem a jeho hodnotu přiřadí do dané proměnné. Název proměnné musí začínat malým písmenem. Volitelně je možné uvést typ, který musí hodnota splňovat (hodnota null neprojde).

x match {
case i : Int => “celočíselná hodnota: “ + i
case n => “hodnota je: “ + n
}

Question 5

5. What is it a constructor pattern?

Answer 5

Constructor pattern matchuje s case classes, které mají stejné hodnoty v konstruktoru.

x match {
    case Rect(1, 2) => "obdélník 1×2"
    case Rect(1, h) => "obdélník o šířce 1 a výšce " + h
}

Question 6

6. What is it a extractor pattern?

Answer 6

Má stejnou syntaxi jako constructor pattern, na daném objektu je zavolána metoda unapply, která musí vracet buď typ Boolean (hodnota matchuje při vrácení true), nebo Option (hodnota matchuje při vrácení Some).

object Positive {
    def unapply(x : Int) : Boolean = x > 0
}
object PositiveOrNegative {
    def unapply(x : Int) : Option[String] =
            if(x > 0) Some("positive")
            else if(x  "x is positive"
    case PositiveOrNegative(result) => "x is " + result  // "x is positive" nebo "x is negative"
}

Question 7

7. What is it a tuple pattern?

Answer 7

Tupple pattern se matchuje vůči Tuplen třídě. Jednoduchý příklad:

def reverse(t : (Int, Int)) =
  t match {
    case (x, y) => (y, x)
  }
 reverse(1,2)

Question 8

8. Do write an example of pattern guard.

Answer 8

Pattern guard obchází nutnost mít různě pojmenované proměnné např v konstruktor patternu.

def simplify(e: Expr) = e match {
   case BinOp("+", x, y)
     if x == y => BinOp("*", x, Number(2))
   case _ => e
 }

Question 9

9. What is it an infix operation pattern?

Answer 9

def printTail(l : AnyRef) {
    l match {
      case head :: tail => println("tail:" + tail)
      case _ => println("not list")
    }
  }

Question 10

10. What is a difference between variable and StableId pattern?

Answer 10

U stableId patternu se porovnává matchovaná hodnota s hodnotou zadané proměnné. Tato proměnná musí začínat velkým písmenem, jinak musí být uzavřená zpětnými apostrofy:

val One = 1
val one = 1
x match {
    case One => "jednička"
    // případně
    case `one` => "jednička"
}
Naproti tomu u variable patternu vyhoví jakákoliv hodnota (volitelně omezená typem proměnné) a ta se přiřadí do zadané proměnné:

x match {
case num => “hodnota je “ + num
}