Решить с помощью map не выйдет. так как в результате получим Maybe<Maybe<B>>, поэтому нам нужна еще одна функция
static class Monad {

scala> class A; class B; class C
defined class A
defined class B
defined class C

scala> def getA(i: Int) = Some(new A)
getA: (i: Int)Some[A]

scala> def getB(a: A) = Some(new B)
getB: (a: A)Some[B]

scala> def getC(b: B) = Some(new C)
getC: (b: B)Some[C]

scala> def getA(i: Int): Option[A] = Some(new A)
getA: (i: Int)Option[A]

scala> def getB(a: A): Option[B] = Some(new B)
getB: (a: A)Option[B]

scala> def getC(b: B): Option[C] = Some(new C)
getC: (b: B)Option[C]

scala> getA(0).flatMap(a => getB(a).flatMap(b => getC(b)))
res0: Option[C] = Some(C@a87f680)

for x in xs :
  for y in foo(x) :
    for z in bar(y) :
      # вот тебе, бабушка, и флэтмап!

Вот задачи:
есть два числа который надо сложить
решение
c = a + b.

есть три числа, два есть сейчас и одно принесет резиновая Зина, их надо сложить
решение
d = a + b + c.

есть четыре числа, два есть сейчас, одно принесет резиновая Зина, одно может через год, а может быть, через два, может быть подскажет тётя Зина из магазина, их надо сложить
решение
r = a + b + c + d

есть пять чисел, два есть сейчас, одно принесет резиновая Зина, одно может через год, а может быть, через два, может быть подскажет тётя Зина из магазина, одно это сумма потерь какой нибудь разини, их надо сложить
решение
r = a + b + c + d

Если добавить типы, то окажется ,что в первом случае числа просто инты, во втором добавляется M<int>, в третьем M1<int>, в четвертом M2<int>

В с++ ты вспотеешь описывать классы и перегрузку операторов для всех возможных комбинаций типов. Если в лоб, то в императивной реализации надо будет понавыдумать целый вагон способов диспетчерзации для случаев " может через год, а может быть, через два, может быть".

Для чего ?
Для того, что бы по прежнему сложить два числа.

И вот для того, что бы числа можно было просто складывать, и не возиться при этом с указателями, конструкторами, деструкторами и смартпоинтерами, люди придумали монады.

Итого: "Monad — just works"

class Show x where
  show :: x -> String -- тип и тип, ничего особенного

class Monad x where
  return :: y -> (x y)                    -- опа! тип x параметризуется типом y
  fail :: String -> x a                   -- пустая монада имеет неизвестно какой параметр, это будет уточнено при выводе типов, по месту использования
  (>>=) :: (x a) -> (a -> (x b)) -> (x b) -- параметр превращается... превращается...

-- тип Either l r - если его каррировать, то полученный Either l вполне может быть монадой
-- но для разных l будут разные монады
instance Monad (Either String) where -- это классика
  return r = Right r
  fail s = Left s
  ....
-- этого в Control.Monad.Instances, вроде бы, нет, но можно дописать руками:
instance Monad (Either ()) where -- левым типом может быть только такой, для которого существуют "дефолтные" значения
  ....
  fail s = Left ()
  ....
instance (Monad m) => Monad (Either (m x)) where
  ....
  fail s = Left (fail s)
  ....

multiplyAll xs ys = do -- (Monad m,  Num a) => m a -> m a -> m a
  x <- xs
  y <- ys
  return x*y

multiplyAll' xs ys = [x*y | x<-xs, y<-ys] -- (Num a) => [a] -> [a] -> [a], потому что дёрнули list comprehension

multiplySome' xs ys = do -- [Int] -> [Int] -> [Int], потому что length
  x <- xs
  y <- ys
  return x*y*(length xs)

readMutVar :: MutVar a -> a

writeMutVar :: MutVar a -> a -> ()

readMutVar :: MutVar a -> State -> (State, a)

writeMutVar :: MutVar a -> a -> State -> State

readMutVar :: MutVar a -> *State -> (*State, a)

writeMutVar :: MutVar a -> a -> *State -> *State

readMutVar :: MutVar a -> State -> (State, a)
-- слегка поправим сигнатуру:
writeMutVar :: MutVar a -> a -> State -> (State,())
-- теперь сходство становится очевидным:
newtype IO a = IO (State -> (State, a))

readMutVar :: MutVar a -> IO a
writeMutVar :: MutVar a -> a -> IO ()

return >=> f === f
f >=> return === f
(f >=> g) >=> h === f >=> (g >=> h)

...хватит уже умничать, Рваная резинка! Маленьким мальчикам пора спать!!!

DM>>Т.е. это все же safePerformIO, а не unsafe.

x = readInt();
y = readInt();
return f(x,y);

int x,y;
x = 1;
y = x;
x = 2;
return x + y;

string s = readLine();
writeLine(s);

int x,y;
x = 1;
string s = readLine();
y = x;
x = 2;
writeLine(s);
return x + y;

foo.Where(pred).Select(f).ToBar()

foo?Where(pred)?Select(f)?ToBar()

Func<Легко, НеВсеТак<Просто>>

Func<НеВсеТак<Легко>, НеВсеТак<Просто>>

Func<НеВсеТак<Легко>, Просто>

Func<НеВсеТак<Легко>, Просто>

Func<Легко, НеВсеТак<Просто>>

НеВсеТак<Легко> СейчасВсеБудет<Легко, Просто, НеВсеТак>(this Легко x, Func<Легко, НеВсеТак<Просто>> f)

?<ПрощеПростого> Lift<Легко, Просто, ПрощеПростого>(?<Легко> xs, ?<Просто> ys, Func<Легко, Просто, ПрощеПростого> f)
{
    from x in xs from y in ys select f(x, y)
}

bool read(string& s);
bool parse(const string& s, int& v);
void write(int v);

string s;
int v;
if(read(s)&&parse(s, v)) write(v);

template<typename R>
optional<R> F2O(bool (*f)(R& r))
{
    R r;
    return f(r)?optional<R>(r):optional<R>();
}
template<typename T, typename R>
optional<R> operator>>(optional<T> o, bool (*f)(const T&t, R& r))
{
    R r;
    return o&&f(*o, r)?optional<R>(r):optional<R>();
}
template<typename T>
void operator>>(optional<T> o, void (*f)(T))
{
    if(o) f(*o);
}

F2O(read)>>parse>>write;

optional<int> parse(const string& s)

optional<R> operator>>(optional<T> o, optional<R> (*f)(const T&))
{
    return o?f(*o):optional<R>();
}

НеВсеТак<Легко> СейчасВсеБудет<Легко, Просто, НеВсеТак>(this Легко x, Func<Легко, НеВсеТак<Просто>> f)

    public interface IMonad<T, TMonad> where TMonad: IMonad<T, TMonad>
    {
        TMonad Make(T value);

        TMonad Bind(TMonad monad, Func<T, T> apllyFunc);

        T Get(TMonad monad);
    }
    public class Easy { }
    public class Simple { }
    public class NotSo<T>: IMonad<T, NotSo<T>>
    {
        public NotSo<T> Make(T value)
        {
            ...
        }

        public NotSo<T> Bind(NotSo<T> monad, Func<T, T> apllyFunc)
        {
            ...
        }

        public T Get(NotSo<T> monad)
        {
            ...
        }
    }

    static class Program
    {
        public static TOut Make<TIn, TOut, TOutMonad>(this TIn x, TOut y, Func<TIn, TOut, TOutMonad> f)
            where TOutMonad: IMonad<TOut, TOutMonad>
        {
            ...
        }

        static void Main(string[] args)
        {
            new Easy().Make(new Simple(), (e, s) => new NotSo<Simple>());
        }
    }

int sum(int x, int y) { return x+y; }

Maybe<int> foo() {/*..*/}

sum(foo(),100);

int sum(int x, int y) { return x+y; }

sum(foo(),100);

sum : (Monad m, Num a) => m a -> m a -> m a   -- sum работает с любым числоподобным типов в любой монаде
sum x y =[| x + y |]    -- такие скобочки называются idiom brackets и делают всю магию

> sum (Id 1) (Id 2)
Id 3 : Identity Integer

> sum (Just 1) (Just 2)
Just 3 : Maybe Integer

> sum [1] [2]
[3] : List Integer

> sum [1] (Just 2)
Can't unify
        Maybe a
with
        List a

I>Эта монада не исключение, а maybe

string read();
int parse(string);
void write(int);

_>string read();
_>int parse(string);
_>void write(int);
_>

void DoAll()

I>void DoAll()
I>

try{
    write(parse(read()));
}catch(...){}

F2O(read)>>parse>>write;

string s;
int v;
if(read(s)&&parse(s, v)) write(v);

Делай то;
Делай сё

r1 = Делай то;
r2 = Делай сё

r1 = Делай то;
r2 = function(x) { 
       Делай сё(x) } (r1)

static void Main()
{
    var random = new Random();

    var values = Observable
        .Interval(TimeSpan.FromSeconds(1))
        .Select(_ => random.Next(1, 50));

    var ticks = values
        .Scan(StockTick.Empty, (acc, cur) => new StockTick(cur, cur - acc.Value))
        .Publish();

    var alerts = ticks.Parse(parser =>
        from next in parser
        let ups = next.Where(tick => tick.Change > 0)
        let downs = next.Where(tick => tick.Change < 0)
        let downAlert = from manyUps in ups.AtLeast(2).ToList()
                   from reversalDown in downs.NonGreedy()
                   where reversalDown.Change <= -11
                   select new StockAlert(manyUps, reversalDown)
        let upAlert = from manyDowns in downs.AtLeast(2).ToList()
                from reversalUp in ups.NonGreedy()
                where reversalUp.Change >= 21
                select new StockAlert(manyDowns, reversalUp)
        select downAlert.Or(upAlert).Ambiguous(untilCount: 1));

    using (ticks.Subscribe(WriteTick))
    using (alerts.Subscribe(WriteAlert))
    using (ticks.Connect())
    {
        Console.ReadKey();
    }
}