Scala example source code file (patmatnew.scala)

This example Scala source code file (patmatnew.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Scala tags/keywords

any, foo, foo, int, int, list, list, pair, seq, some, string, testcase, testcase, tree

The Scala patmatnew.scala source code

trait Treez { self: Shmeez =>
  abstract class Tree
  case class Beez(i:Int) extends Tree
  case object HagbardCeline extends Tree
}

trait Shmeez extends AnyRef with Treez {
  val tree: Tree

  def foo = tree match {
    case Beez(2) => 1
    case HagbardCeline => 0
  }
}

import scala.testing.SUnit._

object Test extends TestConsoleMain {

  //just compilation
  def zipFun[a,b](xs:List[a], ys:List[b]):List[Pair[a,b]] = (Pair(xs,ys): @unchecked) match {
    // !!! case Pair(List(), _), Pair(_, List()) => List()
    case (x :: xs1, y :: ys1) => (x, y) :: zipFun(xs1, ys1)
  }

  def suite = new TestSuite(
      new TestSimpleIntSwitch,
      new SimpleUnapply,
      SeqUnapply,
      applyFromJcl,
      new Test717,
      TestGuards,
      TestEqualsPatternOpt,
      TestSequence01,
      TestSequence02,
      TestSequence03,
      TestSequence04,
      TestSequence05,
      TestSequence06,
      TestSequence07,
      TestSequence08,
      TestStream,
      new Test903,
      new Test1163_Order,
      new TestUnbox,
      Bug457,
      Bug508,
      Bug789,
      Bug995,
      Bug1093,
      Bug1094,
      ClassDefInGuard,
      Ticket2,
      Ticket11,
      Ticket37,
      Ticket44,
      Ticket346
    )

  class Foo(j:Int) {
    case class Bar(i:Int)
  }
  class SimpleUnapply extends TestCase("simpleUnapply") {
    override def runTest() { // from sortedmap, old version
      List((1, 2)).head match {
        case kv @ Pair(key, _) => kv.toString + " " + key.toString
      }


    }
  }

  object SeqUnapply extends TestCase("seqUnapply") {
    case class SFB(i: Int, xs: List[Int])
    override def runTest() { 
      List(1,2) match {
        case List(1) => assert(false, "wrong case")
        case List(1,2,xs @ _*) => assert(xs.isEmpty, "not empty")
        case Nil => assert(false, "wrong case")
      }
      SFB(1,List(1)) match {
        case SFB(_, List(x)) => assert(x == 1)
        case SFB(_, _) => assert(false)
      }
    }
  }

  object applyFromJcl extends TestCase("applyFromJcl") {
    override def runTest {
      val p = (1,2)
        Some(2) match {
          case Some(p._2) =>
          case _ => assert(false)
        }
    }
  }

  class TestSimpleIntSwitch extends TestCase("SimpleIntSwitch") {
    override def runTest() = {
      assertEquals("s1", 1, 1 match {
        case 3 => 3
        case 2 => 2
        case 1 => 1
        case 0 => 0
      })
      assertEquals("s2", 1, 1 match {
        case 1 => 1 
        case _ => 0
      })
      assertEquals("s2boxed", 1, (1:Any) match {
        case 1 => 1 
        case _ => 0
      })
      assertEquals("s3", 1, ("hello") match {
        case s:String => 1
        //case _        => 0 // unreachable!
      })
      val xyz: (Int, String, Boolean) = (1, "abc", true);
      assertEquals("s4", 1, xyz._1 match {
        case 1 => 1
        case _ => 0
      })
    }
  }
  class Test717 extends TestCase("#717 test path of case classes") {
    val foo1 = new Foo(1)
    val foo2 = new Foo(2)

    override def runTest() = {
      val res = (foo1.Bar(2):Any) match {
       case foo2.Bar(2) => false
       case foo1.Bar(2) => true
      }
      assertTrue("ok", res);
    }
  }

  object TestGuards extends TestCase("multiple guards for same pattern") with Shmeez {
    val tree:Tree = Beez(2)
    override def runTest = {
      val res = tree match {
        case Beez(x) if x == 3 => false
        case Beez(x) if x == 2 => true
      }
      assertTrue("ok", res);
      val ret = (Beez(3):Tree) match {
        case Beez(x) if x == 3 => true
        case Beez(x) if x == 2 => false
      }
      assertTrue("ok", ret);
    }
  }

  object TestEqualsPatternOpt extends TestCase("test EqualsPatternClass in combination with MixTypes opt, bug #1276") {
    val NoContext = new Object
    override def runTest {
      assertEquals(1,((NoContext:Any) match {
        case that : AnyRef if this eq that => 0
        case NoContext => 1
        case _ => 2
      }))
    }
  }

  object TestSequence01 extends TestCase("uno (all ignoring patterns on List)") {
    def doMatch(xs: List[String]): String = xs match {
      case List(_*) => "ok"
    }
    def doMatch2(xs: List[String]): List[String] = xs match {
      case List(_, rest @ _*) => rest.toList
    }
    override def runTest() {
      val list1 = List()
      assertEquals(doMatch(list1), "ok")
      val list2 = List("1","2","3")
      assertEquals(doMatch(list2), "ok")
      val list3 = List("1","2","3")
      assertEquals(doMatch2(list3), List("2","3"))
    }
  }


  object TestSequence02 extends TestCase("due (all ignoring patterns on Seq)") {
    def doMatch(l: Seq[String]): String = l match {
      case Seq(_*) => "ok"
    }
    override def runTest() {
      val list1 = List()
      assertEquals(doMatch(list1), "ok")
      val list2 = List("1", "2", "3")
      assertEquals(doMatch(list2), "ok")
      val array3 = Array[String]()
      assertEquals(doMatch(array3), "ok")
      val array4 = Array[String]("ga", "gu")
      assertEquals(doMatch(array4), "ok")
    }
  }

  object TestSequence03 extends TestCase("tre (right-ignoring patterns on List, defaults)") {
    def doMatch(xs: List[String]): String = xs match {
      case List(_,_,_,_*) => "ok"
      case _ => "not ok"
    }
    override def runTest() {
      val list1 = List()
      assertEquals(doMatch(list1), "not ok")
      val list2 = List("1","2","3")
      assertEquals(doMatch(list2), "ok")
      val list3 = List("1","2","3","4")
      assertEquals(doMatch(list3), "ok")
    }
  }


  object TestSequence04 extends TestCase("quattro (all- and right-ignoring pattern on case class w/ seq param)") {
    case class Foo(i: Int, chars: Char*)

    override def runTest() = {
      val a = Foo(0, 'a') match {
        case Foo(i, c, chars @ _*) => c
        case _ => null
      }
      assertEquals(a, 'a')

      val b = Foo(0, 'a') match {
        case Foo(i, chars @ _*) => 'b'
        case _ => null
      }
      assertEquals(b, 'b')
    }
  }

  object TestSequence05 extends TestCase("cinque (sealed case class with ignoring seq patterns)") {
    sealed abstract class Con;

    case class Foo() extends Con
    case class Bar(xs:Con*) extends Con
    
    override def runTest() {
      val res = (Bar(Foo()):Con) match {
        case Bar(xs@_*) => xs // this should be optimized away to a pattern Bar(xs)
        case _ => Nil
      }
      assertEquals("res instance"+res.isInstanceOf[Seq[Con] forSome { type Con }]+" res(0)="+res(0), true, res.isInstanceOf[Seq[Foo] forSome { type Foo}] && res(0) == Foo() )
    }
  }

  object TestSequence06 extends TestCase("sei (not regular) fancy guards / bug#644 ") {
    
    case class A(i: Any)
     
    def doMatch(x: Any, bla: Int) = x match {
      case x:A if (bla==1) => 0
      case A(1) => 1
      case A(A(1)) => 2
    }

    override def runTest() {
      assertEquals(doMatch(A(null),1), 0)
      assertEquals(doMatch(A(1),2), 1)
      assertEquals(doMatch(A(A(1)),2), 2)
    }

  }

  object TestSequence07 extends TestCase("sette List of chars") {
    def doMatch1(xs: List[Char]) = xs match {
      case List(x, y, _*) => x::y::Nil
    }
    def doMatch2(xs: List[Char]) = xs match {
      case List(x, y, z, w) => List(z,w)
    }
    //def doMatch3(xs:List[char]) = xs match {
    //  case List(_*, z, w) => w::Nil
    //}
    // 
    // Since the second case should have been unreachable all along,
    // let's just comment this one out.
    //
    // def doMatch4(xs:Seq[Char]) = xs match {
    //   case Seq(x, y, _*) => x::y::Nil
    //   case Seq(x, y, z, w) => List(z,w) // redundant!
    // }
    def doMatch5(xs:Seq[Char]) = xs match {
      case Seq(x, y, 'c', w @ _*) => x::y::Nil
      case Seq(x, y, z @ _*)    => z
    }
    def doMatch6(xs:Seq[Char]) = xs match {
      case Seq(x, 'b')            => x::'b'::Nil
      case Seq(x, y, z @ _*)    => z.toList
    }

    override def runTest() {
      assertEquals(List('a','b'), doMatch1(List('a','b','c','d')))
      assertEquals(List('c','d'), doMatch2(List('a','b','c','d')))
      // assertEquals(doMatch3(List('a','b','c','d')), List('d'))
      // assertEquals(List('a','b'), doMatch4(List('a','b','c','d')))
      assertEquals(List('a','b'), doMatch5(List('a','b','c','d')))
      assertEquals(List('c','d'), doMatch6(List('a','b','c','d')))
    }
  }
 
  object TestSequence08 extends TestCase("backquoted identifiers in pattern") { 
    override def runTest() {
      val xs = List(2, 3)
      val ys = List(1, 2, 3) match {
        case x :: `xs` => xs
        case _ => Nil
      }
      assertEquals(xs, ys)
    }
  }


  object TestStream extends TestCase("unapply for Streams") {
    def sum(stream: Stream[Int]): Int =
      stream match {
        case Stream.Empty => 0
        case Stream.cons(hd, tl) => hd + sum(tl)
      }
    
    val str: Stream[Int] = List(1,2,3).iterator.toStream

    def runTest() = assertEquals(sum(str), 6)
  }
  
  class Test1163_Order extends TestCase("bug#1163 order of temps must be preserved") {
    abstract class Function
    case class Var(n: String) extends Function
    case class Const(v: Double) extends Function
    
    def f(): (Function, Function) = {
      (Var("x"): Function, Var("y"): Function) match {
        case (Const(v), Const(w)) => throw new Error
        case (leftOne, Var("z")) => throw new Error
        case (leftTwo, rightTwo) => (leftTwo, rightTwo) // was giving "y","x"
      }
    }
    
    def flips(l: List[Int]): Int = (l: @unchecked) match { 
      case 1 :: ls => 0
      case n :: ls => flips((l take n reverse) ::: (l drop n)) + 1
    }

    def runTest() =  assertEquals("both", (Var("x"),Var("y")), f) 
  }

  class TestUnbox extends TestCase("unbox") {
    override def runTest() {
      val xyz: (Int, String, Boolean) = (1, "abc", true)
      xyz._1 match {
        case 1 => "OK"
        case 2 => assert(false); "KO"
        case 3 => assert(false); "KO"
      }
    }
  }

  class Test806_818 { // #806, #811 compile only -- type of bind
    // bug811
    trait Core {
      trait NodeImpl
      trait OtherImpl extends NodeImpl
      trait DoubleQuoteImpl extends NodeImpl
      def asDQ(node : OtherImpl) = node match {
	case dq : DoubleQuoteImpl => dq
      }
    }
    
    trait IfElseMatcher { 
      type Node <: NodeImpl
      trait NodeImpl
      trait IfImpl
      private def coerceIf(node: Node) = node match {
        case node : IfImpl => node  // var node is of type Node with IfImpl!
        case _ => null
      }
    }    
  }


  class Person(_name : String, _father : Person) {
    def name = _name
    def father = _father
  }

  object PersonFather {
    def unapply(p : Person) : Option[Person]  = 
      if (p.father == null)
        None
      else
  	    Some(p.father)
  }

  class Test903 extends TestCase("bug903") {

  override def runTest = {
    val p1 = new Person("p1",null)
    val p2 = new Person("p2",p1)
    assertEquals((p2.name, p1.name), p2 match {
      case aPerson@PersonFather(f) => (aPerson.name,f.name)
      case _ => "No father"
    })
  }
  }


  object Test1253  { // compile-only
    def foo(t : (Int, String)) = t match {
      case (1, "") => throw new Exception
      case (r, _) => throw new Exception(r.toString)
    }
  }

  object Foo1258 {
    case object baz
    def foo(bar : AnyRef) = {
      val Baz = baz
      bar match {
        case Baz => ()
      }
    }
  }

  object Foo1 {
    class Bar1(val x : String)
    def p(b : Bar1) = Console.println(b.x)
    
    def unapply(s : String) : Option[Bar1] =
      Some(new Bar1(s))
  }
  
  object bug881 extends TestCase("881") {
    override def runTest = {
      "baz" match {
        case Foo1(x) =>
          Foo1.p(x)
      }
    }
  }


  // these are exhaustive matches
  //   should not generate any warnings
  def f[A](z:(Option[A],Option[A])) = z match {
    case Pair(None,Some(x)) => 1
    case Pair(Some(x),None ) => 2
    case Pair(Some(x),Some(y)) => 3
    case _ => 4
  }
  
  def g1[A](z:Option[List[A]]) = z match {
    case Some(Nil) => true    
    case Some(x::Nil) => true  
    case _ => true
  }
  
  def g2[A](z:Option[List[A]]) = z match {
    case Some(x::Nil) => true  
    case Some(_) => false
    case _ => true
  }
  
  def h[A](x: (Option[A],Option[A])) = x match {
    case Pair(None,_:Some[_]) => 1
    case Pair(_:Some[_],None ) => 2
    case Pair(_:Some[_],_:Some[_]) => 3
    case _ => 4
  }

  def j = (List[Int](), List[Int](1)) match {
    case (Nil, _) => 'a'
    case (_, Nil) => 'b'
    case (h1 :: t1, h2 :: t2) => 'c'
  }

  def k (x:AnyRef) = x match {
    case null => 1
    case _ => 2
  }

  val FooBar = 42
  def lala() = 42 match {
    case FooBar => true
  }

  object Bug1270  { // unapply13
  
    class Sync {
      def apply(x: Int): Int = 42
      def unapply(scrut: Any): Option[Int] = None
    }
    
    class Buffer {
      object Get extends Sync
      
      var ps: PartialFunction[Any, Any] = {
        case Get(y) if y > 4 => // y gets a wildcard type for some reason?! hack 
      }
    }
    
    println((new Buffer).ps.isDefinedAt(42))
  }

  object Bug1261 {
    sealed trait Elem
    case class Foo() extends Elem
    case class Bar() extends Elem
    trait Row extends Elem
    object Row {
      def unapply(r: Row) = true
      
      def f(elem: Elem) {
        elem match {
          case Bar() => ;
          case Row() => ;
          case Foo() => ; // used to give ERROR (unreachable code)
        }}}
  }
/*
  object Feature1196 {
    def f(l: List[Int]) { }
    
    val l: Seq[Int] = List(1, 2, 3)
    
    l match {
      case x @ List(1, _) => f(x) // x needs to get better type List[int] here
    }
  }
*/
  object TestIfOpt { //compile-only "test EqualsPatternClass in combination with MixTypes opt, bug #1278"
     trait Token {
       val offset : Int
       def matching : Option[Token]
     }
    def go(tok : Token) = (tok.matching: @unchecked) match {
      case Some(other) if true => Some(other)
      case _ if true => tok.matching match {
        case Some(other) => Some(other)
        case _ => None
      }
    }
  }

  object Go { // bug #1277 compile-only
    trait Core { def next : Position = null }
    trait Dir
    val NEXT = new Dir{}
    
    trait Position extends Core
    
    (null:Core, null:Dir) match {
      case (_, NEXT) if true => false // no matter whether NEXT test succeed, cannot throw column because of guard
      case (at2:Position,dir) => true
    }
  }

  trait Outer { // bug #1282 compile-only
    object No
    trait File {
      (null:AnyRef) match {
        case No => false
      }
    }
  }

  object cast2 { // #1281

    class Sync {
      def unapplySeq(scrut: Int): Option[Seq[Int]] = {
        println("unapplySeq: "+scrut)
        if (scrut == 42) Some(List(1, 2))
        else None
      }
    }
    
    class Buffer {
      val Get = new Sync
      
      val jp: PartialFunction[Any, Any] = {
        case Get(xs) => println(xs) // the argDummy <unapply-selector> should have proper arg.tpe (Int in this case)
      }
    }
    
    println((new Buffer).jp.isDefinedAt(40))
    println((new Buffer).jp.isDefinedAt(42))
  }

  object ClassDefInGuard extends TestCase("classdef in guard") { // compile-and-load only
    val z:PartialFunction[Any,Any] = {
      case x::xs if xs.forall { y => y.hashCode() > 0 } => 1
    }

    override def runTest {
    val s:PartialFunction[Any,Any] = {
      case List(4::xs)                => 1
      case List(5::xs)                => 1
      case _                if false                               => 
      case List(3::xs) if List(3:Any).forall { g => g.hashCode() > 0 } => 1
    }
      z.isDefinedAt(42)
      s.isDefinedAt(42)
      // just load the thing, to see if the classes are found

      (None:Option[Boolean] @unchecked) match {
        case x if x.map(x => x).isEmpty =>
      }
    }
  }

  // bug#457

  object Bug457 extends TestCase("Bug457") {
    def method1() = {
      val x = "Hello, world"; val y = 100;
      y match {
        case _: Int if (x match { case t => t.trim().length() > 0 }) => false;
        case _ => true;
      }}

    def method2(): scala.Boolean = {
      val x: String = "Hello, world"; val y: scala.Int = 100; {
        var temp1: scala.Int = y
        var result: scala.Boolean = false
        if (
          {
            var result1: scala.Boolean = true;
            if (y == 100)
              result1
            else
              throw new MatchError("crazybox.scala, line 11")
          } && (y > 90)
        )
          result
            else
              throw new MatchError("crazybox.scala, line 9")
      }}

    override def runTest {
      method1();
      method2();
    }
  }

  // bug#508

  object Bug508 extends TestCase("aladdin #508") { 
    case class Operator(x: Int);
    val EQ = new Operator(2);
    
    def analyze(x: Pair[Operator, Int]) = x match {
      case Pair(EQ, 0) => "0"
      case Pair(EQ, 1) => "1"
      case Pair(EQ, 2) => "2"
    }
    override def runTest {
      val x = Pair(EQ, 0);
      assertEquals("0", analyze(x)); // should print "0"
      val y = Pair(EQ, 1);
      assertEquals("1", analyze(y)); // should print "1"
      val z = Pair(EQ, 2);
      assertEquals("2", analyze(z)); // should print "2"
    }    
  }

  // bug#789
  
  object Bug789 extends TestCase("aladdin #789") { // don't do this at home

    trait Impl
    
    trait SizeImpl extends Impl { def size = 42 }
    
    trait ColorImpl extends Impl { def color = "red" }
    
    type Both = SizeImpl with ColorImpl
    
    def info(x:Impl) = x match {
      case x:Both      => "size  "+x.size+" color "+x.color // you wish
      case x:SizeImpl  => "!size "+x.size
      case x:ColorImpl => "color "+x.color
      case _           => "n.a."
    }
    
    def info2(x:Impl) = x match {
      case x:SizeImpl with ColorImpl  => "size  "+x.size+" color "+x.color // you wish
      case x:SizeImpl  => "!size "+x.size
      case x:ColorImpl => "color "+x.color
      case _           => "n.a."
    }
    
    override def runTest {
      // make up some class that has a size
      class MyNode extends SizeImpl
      assertEquals("!size 42", info(new MyNode))
      assertEquals("!size 42", info2(new MyNode))
    }
  }

  // bug#995

  object Bug995 extends TestCase("aladdin #995") {
    def foo(v: Any): String = v match {
      case s: Seq[_] => "Seq" // see hack in object Seq.unapplySeq
      case a: AnyRef if runtime.ScalaRunTime.isArray(a) => "Array"
      case _ => v.toString
    }
    override def runTest { assertEquals("Array", foo(Array(0))) } 
  }

  // bug#1093 (contribution #460)

  object Bug1093 extends TestCase("aladdin #1093") {
    override def runTest {assertTrue(Some(3) match {
      case Some(1 | 2) => false
      case Some(3) => true
    })}
  }

  // bug#1094 (contribution #461)

  object Bug1094 extends TestCase("aladdin #1094") {
    def foo(ps: String*) = "Foo"
    case class X(p: String, ps: String*)
    def bar =
      X("a", "b") match {
        case X(p, ps @ _*) => foo(ps : _*)
      }
    override def runTest { assertEquals("Foo", bar) }
  }

  // #2

  class Outer_2 {
    case class Foo(x: Int, y: Int) {
      override def equals(other: Any) = other match {
        case Outer_2.this.Foo(`x`, `y`) => true
        case _ => false
      }
    }
  }
  
  object Ticket2 extends TestCase("#2") { override def runTest {
    val o1 = new Outer_2; val o2 = new Outer_2; val x: Any = o1.Foo(1, 2); val y: Any = o2.Foo(1, 2)
    assertFalse("equals test returns true (but should not)", x equals y)
    assertTrue("match enters wrong case", x match {
      case o2.Foo(x, y) => false
      case o1.Foo(x, y) => true
      case _ => false
    })
  }}

// #11

  class MyException1 extends Exception

  // Commenting out the following line and uncommenting the second line
  // will cause the test to succeed.
  trait SpecialException extends MyException1
  // trait SpecialException
  
  class MyException2 extends MyException1 with SpecialException
  
  object Ticket11 extends TestCase("#11") {
    override def runTest {
      Array[Throwable](new Exception("abc"),
                       new MyException1,
                       new MyException2).foreach { e =>
                         try {
                           throw e
                         } catch {
                           case e : SpecialException => {
                             assume(e.isInstanceOf[SpecialException])
                           }
                           case e => {
                             assume(e.isInstanceOf[Throwable])
                           }
                         }
                       }
    }
  }

  // #37
  
  object Ticket37 extends TestCase("#37") {
    def foo() {}
    val (a,b) = { foo(); (2,3) }
    override def runTest { assertEquals(this.a, 2) }
  }

  // #44

  trait _X {
    case class _Foo();
    object _Bar {
      def unapply(foo: _Foo):Boolean = true;
    }
  }
  object Y extends _X {
    val foo = _Foo()
    foo match {
      case _Bar() => 
      case _      => assert(false)
    }
  }
  object Ticket44 extends TestCase("#44") {
    override def runTest { assert(Y.toString ne null) /*instantiate Y*/ }
  }

  object Ticket211 extends TestCase("#211") {
    override def runTest {
      (Some(123):Option[Int]) match {
        case (x:Option[a]) if false => {};
        case (y:Option[b]) => {};
      }
    }
  }

  sealed abstract class Tree
  case class Node(l: Tree, v: Int, r: Tree) extends Tree
  case object EmptyTree extends Tree
  
  object Ticket335 extends TestCase("#335") { // compile-only
    override def runTest {
      (EmptyTree: Tree @unchecked) match {
        case Node(_,v,_) if (v == 0) => 0
        case EmptyTree => 2
      }
    }
  }

// this test case checks nothing more than whether
//   case N for object N is translated to a check scrutinee.equals(N)
//  (or the other way round)... for a long time, we got away with
//  scrutinee eq N, but those golden days are, apparently, over.
  object Ticket346 extends TestCase("#346") {

class L(val content: List[Int]) {

    def isEmpty = content.isEmpty
    def head = content.head
    def tail = content.tail

    override def equals(that: Any): Boolean = {
        val result = that.isInstanceOf[N.type]
        println("L("+content+").equals("+that+") returning "+result)
        result
    }
}

object N extends L(Nil) {
    
    override def equals(that: Any): Boolean = {
        val result = (that.isInstanceOf[L] && that.asInstanceOf[L].isEmpty)
        //println("N.equals("+that+") returning "+result)
        result
    }
}

object C {

    def unapply(xs: L): Option[(Int, L)] = {
        if (xs.isEmpty)
            { println("xs is empty"); None }
        else
            Some((xs.head, new L(xs.tail)))
    }

}


    def empty(xs : L) : Boolean = xs match {
        case N => true
        case _ => false
    }

    def singleton(xs : L) : Boolean = xs match {
        case C(_, N) => true
        case _ => false
    }

override def runTest() {
    assertTrue(empty( new L(Nil) ))
    assertTrue(singleton( new L(List(1)) ))
}

}  // end Ticket346

  object Ticket495bis { // compile-only
    def signum(x: Int): Int = 
      x match { 
        case 0 => 0
        case _ if x < 0 => -1
        case _ if x > 0 => 1
      }
    def pair_m(x: Int, y: Int) = 
      (x,y) match {
        case (_, 0)  => 0
        case (-1, _) => -1
        case (_, _)  => 1
      }
  }

  object Ticket522 { // compile-only
  class Term[X]
  object App { 
     // i'm hidden
     case class InternalApply[Y,Z](fun:Y=>Z, arg:Y) extends Term[Z]

     def apply[Y,Z](fun:Y=>Z, arg:Y): Term[Z] = 
       new InternalApply[Y,Z](fun,arg)

     def unapply[X](arg: Term[X]): Option[(Y=>Z,Y)] forSome {type Y; type Z} = 
         arg match {
           case i:InternalApply[y,z] => Some(i.fun, i.arg)
           case _                    => None
         }
  }

  App({x: Int => x}, 5) match {
    case App(arg, a) => 
  }
  } // end Ticket522


  object Ticket710 {  // compile-only
    def method {
      sealed class Parent()
      case object Child extends Parent()
      val x: Parent = Child
      x match {
        case Child => ()
      }
    }
   }
}