for { case Some(x) <- foo } yield x

public static Func<?, ?, ?> Lift<TX, TY, TR>( Func<TX, TY, TR> f)
{
    return (? mx, ? my) => from x in mx
                           from y in my
                           select f(x, y) 
}

//псевдошарп
public interface Monad<M> where M : * -> *
{ 
  M<T> Return<T>(T a);
  M<T2> Bind<T, TR>(M<T> a, Func<T1, M<TR>> f);
}

trait Monad[M[_]] {
  def return[A](a: A): M[A]
  def bind[A, B](a: M[A], f: A => M[B]): M[B]
}

K>for { case Some(x) <- foo } yield x
K>

scala> for (Some(x) <- Some(1)::None::Some(2)::Nil) yield x
res0: List[Int] = List(1, 2)

scala>> for (Some(x) <- Some(1)::None::Some(2)::Nil) yield x
res0: List[Int] = List(1, 2)

for (p <- e; p' <- e' ...) yield e''

e.flatMap { case p => for (p' <- e' ...) yield e''}

def flatMap[B](f: A => Option[B]): Option[B] = 
    if (isEmpty) None else f(this.get)

K>for (p <- e; p' <- e' ...) yield e''
K>

K>e.flatMap { case p => for (p' <- e' ...) yield e''}
K>

K>def flatMap[B](f: A => Option[B]): Option[B] = 
K>    if (isEmpty) None else f(this.get)
K>

instance  Monad Maybe  where
    (Just x) >>= k      = k x
    Nothing  >>= _      = Nothing

instance MonadPlus Maybe where
   mzero = Nothing

   Nothing `mplus` ys  = ys
   xs      `mplus` _ys = xs

  def foo[A](xs:List[Option[A]]) = for { Some(x) <- xs } yield x

def foo[A](xs:List[Option[A]]) = xs.filter( (x) => x match {
  case Some(_) => true
  case _       => false
}).map( (y) => y match {
  case Some(z) => z
})