aboutsummaryrefslogtreecommitdiff
path: root/tests/pos/desugar.scala
blob: f0d8645b7830bc4e78364151f908d2c2c8c86048 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
object desugar {

  // variables
  var x: Int = 2
  var y = x * x
  val list = List(1, 2, 3)

  { var z: Int = y }
 
  def foo0(first: Int, second: Int = 2, third: Int = 3) = first + second
  def foo1(first: Int, second: Int = 2)(third: Int = 3) = first + second
  def foo2(first: Int)(second: Int = 2)(third: Int = 3) = first + second
  
  object caseClasses { self =>
    trait List[+T] {
      def head: T
      def tail: List[T]
    }

    case class Cons[+T](val head: T, val tail: List[T]) extends List[T]

    object Cons {
      def apply[T](head: T): Cons[T] = apply(head, Nil)
    }

    case object Nil extends List[Nothing]
  }
    
  object patDefs {
    
    import caseClasses._

    val xs: List[Int] = Cons(1, Cons(2, Nil))
    
    val Cons(y, ys) = xs 
    val Cons(z, _) = xs
    val Cons(_, _) = xs
   
    val (cons: Cons[Int]) = xs
    
    val x1, y1, z1: Int = 1
  }
  
  object Binops {
    
    x :: y :: Nil
    
    val x :: y :: Nil = list
    
  }
  
  object fors {
        
    for (x <- List(1, 2, 3)) yield 2
    for (x <- List(1, 2, 3) if x % 2 == 0) yield x * x
    for (x <- List(1, 2, 3); y <- 0 to x) yield x * y
    for (x <- List(1, 2, 3); y <- 0 to x; if x + y % 2 == 0) yield x * y
    for (x <- List(1, 2, 3); y = x * x; if x + y % 2 == 0) yield x * y
    for (x <- List(1, 2, 3); y = x * x; z = x * y; u <- 0 to y) yield x * y * z * u

    for (x <- List(1, 2, 3)) println(x)
    for (x <- List(1, 2, 3) if x % 2 == 0) println(x * x)
    for (x <- List(1, 2, 3); y <- 0 to x) println(x * y)
    for (x <- List(1, 2, 3); y <- 0 to x; if x + y % 2 == 0) println(x * y)
    for (x <- List(1, 2, 3); y = x * x; if x + y % 2 == 0) println(x * y)
    for (x <- List(1, 2, 3); y = x * x; z = x * y; u <- 0 to y) println(x * y * z * u)
  }
  
  object misc {
    'hello
    s"this is a $x + ${x + y} string"
    type ~ = Tuple2
    val pair: Int ~ String = 1 -> "abc"
    def foo(xs: Int*) = xs.length
    foo(list: _*)
    println(list: _*)
    (list length)
    - desugar.x
    def bar(x: => Int) = x
    (x + y) + 1
    while (x < 10) x += 1
    do x -= 1 while (x > 0)
  }

}