pattern a :: b :: rest matches lists of length 2 or greater

object List_Pattern_rest extends App {

  val lst=List("america","india","china")

  val a :: b :: rest= lst
  //matches lists of length 2 or greater

//  a: String = america 
  // b: String = india 
  // rest: List[String] = List(china)

}

List patterns correspond one-by-one to list expressions.

match on all elements of a list -using pattern List(…)

or take lists apart bit by bit – using patterns composed from the :: operator and the Nil constant.

val country= “america” :: (“india” :: (“china” :: Nil))

val country = List(“america”,”india”,”china”)

object List_Methods extends App{

  val country= "america" :: ("india" :: ("china" :: Nil))

  val country_1 = List("america","india","china")
  println(country.head)
  println(country.tail)
  println(country.tail.head)

}

x :: xs represents a list whose first element is x, followed by (the elements of) list xs

head returns the first element of a list

tail returns a list consisting of all elements except the first

isEmpty returns true if the list is empty

The head and tail methods are defined only for non-empty lists

 Nil.head 

Nil.head java.util.NoSuchElementException: head of empty list

Note – Nil is the empty list 

val empty_1:List[Nothing]=Nil

Because it ends in a colon, the :: (cons) operation associates to the right: A :: B :: C is interpreted as A :: (B :: C). Therefore, you can drop the parentheses in the previous definitions.

val v1: List[Int] = List(1, 2, 3)
val v1_1: List[Int] = 1 :: (2 :: (3 :: Nil))

val v1_2: List[Int] = 1 :: 2 :: 3 :: Nil


println(v1)
println(v1_1)
println(v1_2)

All lists are built from two fundamental building blocks, Nil and :: (pronounced “cons”).

Nil represents the empty list.

val empty_1:List[Nothing]=Nil
println(empty_1)

The infix operator, ::, expresses list extension at the front.

val lstNested: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))

can be written as

val lstNested_1: List[List[Int]] = (1::(2::(3::Nil))) ::
  (4::(5::List(6)))::Nil

object Lists_Operations extends App {


  val v1: List[Int] = List(1, 2, 3)
  val v1_1: List[Int] = 1 :: (2 :: (3 :: Nil))

  println(v1)
  println(v1_1)

  val lstNothing: List[Nothing] = List()
  val lstString: List[String] = List()
  val empty = Nil
  println(empty)

  val lstNested: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))
  println(lstNested)

  val lstNested_1: List[List[Int]] = (1 :: (2 :: (3 :: Nil))) ::
    (4 :: (5 :: List(6))) :: Nil

  println(lstNested_1)

  val lstNested_2: List[List[Int]] = (1 :: (2 :: (3 :: Nil))) ::
    (4 :: (5 :: (6 :: Nil))) :: Nil

  println(lstNested_2)
}

The list type in Scala is covariant. This means that for each pair of types S and T, if S is a subtype of T, then List[S] is a subtype of List[T].

Nothing is the bottom type in Scala’s class hierarchy. It is a subtype of every other Scala type. Because lists are covariant, it follows that List[Nothing] is a subtype of List[T], for any type T.

object Lists_Operations extends App {

  val lstNested: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))
  println(lstNested)

  val lstNothing: List[Nothing] = List()
  val lstString: List[String] = List()

}

Lists are immutable.

Lists are recursive (linked list) whereas Arrays are flat.

object ListsEx extends App {

  val intLst = List(1,2,3,4)
  val strLst=List("usa","india","russia")
  val emptyLst=List()
  val nestedLst=List(List(1,2,3),List("usa","india"))
  println("int list:"+intLst)


}

trait Color {

val thickness:Int=100;
def beautify() {
println(“lets add red color and some sparkles!”)
}
}

class BirthdayCelebration extends Color {
}

class Selection {}
class Potluck extends Selection with Color
{}