Using LINQ query syntax with custom Maybe monad implementation

I am trying to write a simple Maybe monad in C#. I want to be able to use the LINQ query syntax with it. This is what I have come up with so far:

using System;
using System.Collections.Generic; 

abstract class Maybe<A> {
  public abstract Maybe<B> SelectMany<B>(Func<A, Maybe<B>> f);
  public abstract Maybe<B> Select<B>(Func<A, B> f);
}

class Just<A> : Maybe<A> {
  private readonly A a;

  public Just(A a) {
    this.a = a;
  }

  override public Maybe<B> SelectMany<B>(Func<A, Maybe<B>> f) {
    return f(a);
  }

  override public Maybe<B> Select<B>(Func<A, B> f) {
    return new Just<B>(f(a));
  }

  override public string ToString() {
    return "Just " + a;
  }
}

class Nothing<A> : Maybe<A> {
  override public Maybe<B> SelectMany<B>(Func<A, Maybe<B>> f) {
    return new Nothing<B>();
  }

  override public Maybe<B> Select<B>(Func<A, B> f) {
    return new Nothing<B>();
  }

  override public string ToString() {
    return "Nothing";
  }
}

static class Program {
  public static void Main(string[] args) {
    Maybe<int> m = new Just<int>(12);
    Maybe<int> n = new Nothing<int>();
    Maybe<int> result = from m0 in m
                        from n0 in n
                        select m0 + n0;
    Console.WriteLine(result);
  }
}

And this is the error message:

prog.cs(48,25): error CS1501: No overload for method `SelectMany' takes `2' arguments
prog.cs(5,28): (Location of the symbol related to previous error)
Compilation failed: 1 error(s), 0 warnin开发者_StackOverflowgs

Can anyone please guide me on what I should do to be able to use query syntax with my Maybe implementation? Thanks.

---

SelectMany must should be declared as an extension in a static class, for example:

public static class Maybe {

   public static Maybe<B> SelectMany<B>(this Maybe<A> maybe, Func<A, Maybe<B>> f) {
       return f(a);
   }

   ...
}

EDIT:

you still need a piece. With this should work:

public static Maybe<V> SelectMany<T, U, V>(this Maybe<T> m, Func<T, Maybe<U>> k, Func<T, U, V> s)
{
  return m.SelectMany(x => k(x).SelectMany(y => new Just<V>(s(x, y))));
}

You need this because:

 from m0 in m
 from n0 in n
 select m0 + n0

would be translated in:

 m.SelectMany(m0 => n, (m, n0) => m0 + n0);

Instead, for example:

 var aa = new List<List<string>>();
 var bb = from a in aa
          from b in a
          select b;

is translated in

 aa.SelectMany(a => a);