I understand that a view is a light-weight collection and that it is lazy. I would like to understand what makes a view light weight.

Say I have a list of 1000 random numbers. I'll like to find even numbers in this list and pick only 1st 10 even numbers. I believe using a view here is better because we can avoid creating an intermediate list esp because I'll pick only 1st 10 even numbers. Initially, I thought that the the optimization is achieved because the function I'll use in the filter method will not get executed till the method force is called but this isn't correct I believe. I am struggling to understand what makes using the view better in this scenario. Or have I picked a wrong example?

```
val r = scala.util.Random

val l:List[Int] = List.tabulate(1000)(x=>r.nextInt())

//without view, I'll get an intermediate list. The function x%2==0 will be on each elemenet of l
val l1 = l.filter(x=>(x%2 == 0))

//this will give size of l2. I got size as 508 but yours could be different depending on the random numbers generated in your case
l1.size

//pick 1st 10 even numbers
val l2 = l1.take(10)

//using view. I thought that x%2==0 will not be executed right now

val lv1 = l.view.filter(x=>(x%2 == 0))
lv1: scala.collection.SeqView[Int,List[Int]] = SeqViewF(...)

lv1.size //this is same as l1 size so my assumption that x%2==0 will not be executed is wrong else lv1.size will not be same as l1.size

val lv2 = lv1.take(10).force

```

\*\*Question 1 - if I use view, how is the processing optimised? 

Question 2 - lv1 is of type SeqViewF, F is related to filter but what does it mean?

Question 3 - what do the elements of lv1 look like (l1 for example are integers)\*\*