Катастрофа при Extract Method

string someMethodResult = new SomeClass1().SomeMethod1();

string someMethodResult = ExtractedMethod1().SomeMethod1();

SomeClass1 ExtractedMethod1()
{
    return new SomeClass1();
}

string someMethodResult = null.SomeMethod1(); //ошибка компиляции

string someMethodResult = ExtractedMethod1().SomeMethod1(); //ошибка в run time-е

SomeClass1 ExtractedMethod1()
{
    return null;
}

1. для передачи значений в уже имеющиеся методы (например, третий аргумент в методе PropertyInfo.SetValue),
   
2. в операторе сравнения (фактически вариант а),
   
3. может что-то забыл .

1. field-ы классов инициализируются null-ами,
   
2. оператор "as" возвращает null,
   
3. уже имеющиеся библиотеки поставляют null-ы.

string someMethodResult = OptionalValue.Nothing<SomeClass1>().Process(
    value => value.SomeMethod1(),
    () => "[Экземпляр класса SomeClass1 не существует]");

string someMethodResult = ExtractedMethod1().Process(
    value => value.SomeMethod1(),
    () => "[Экземпляр класса SomeClass1 не существует]");

IOptionalValue<SomeClass1> ExtractedMethod1()
{
    return OptionalValue.Nothing<SomeClass1>();
}

Схожесть с System.Nullable

1. OptionalValue работает и для reference и для value типов, System.Nullable только для value типов,
   
2. у OptionalValue generic параметр ковариантный.

The Maybe Monad

Query comprehension syntax

Интересные ссылки на эту тему

I call it my billion-dollar mistake. It was the invention of the null reference in 1965. At that time ...
http://en.wikipedia.org/wiki/C._A._R._Hoare

A more elegant solution that will never come true is to apply value type syntax for reference types: all references are implicitly not nulls for the compiler, but a question mark after a type (ie: «string?» or «Customer?») allows you to set null to the variable.
http://codevanced.net/post/One-Annotations-Way-Resharper.aspx

1.0 Non-Null Types Many errors in modern programs manifest themselves as null-dereference errors, suggesting the importance of a programming language providing the ability to discriminate between expressions that may evaluate to null and those that are sure not to (for some experimental evidence, see [24, 22]). In fact, we would like to eradicate all null dereference errors.
http://stackoverflow.com/questions/1943465/avoiding-null-reference-exceptions

Source code of OptionalValue

    public interface IOptionalValue<out TValue>
    {
        TResult Process<TResult>(Func<TValue, TResult> existFunc, Func<TResult> notExistFunc);
    }

    public static class OptionalValue
    {
        public static IOptionalValue<TValue> Nothing<TValue>()
        {
            return NotExistOptionalValue<TValue>.Instance;
        }

        public static IOptionalValue<TValue> AsOptionalValue<TValue>(
            this TValue value)
        {
            return new ExistOptionalValue<TValue>(value);
        }

        public static IOptionalValue<TTarget> ProcessValue<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, TTarget> func)
        {
            return optionalValue.ProcessValue(value => func(value).AsOptionalValue());
        }

        public static IOptionalValue<TTarget> ProcessValue<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<TTarget>> func)
        {
            return optionalValue.Process(func, Nothing<TTarget>);
        }

        public static void Process<TValue>(
            this IOptionalValue<TValue> optionalValue, 
            Action<TValue> existAction, 
            Action notExistAction)
        {
            optionalValue.Process(existAction.ToFunc(), notExistAction.ToFunc());
        }

        public static void ProcessValue<TValue>(
            this IOptionalValue<TValue> optionalValue, 
            Action<TValue> existAction)
        {
            Process(optionalValue, existAction, () => { });
        }

        public static IOptionalValue<TTarget> Select<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, TTarget> func)
        {
            return optionalValue.ProcessValue(func);
        }

        public static IOptionalValue<TTarget> SelectMany<TValue, TTarget>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<TTarget>> func)
        {
            return optionalValue.ProcessValue(func);
        }

        public static IOptionalValue<T2> SelectMany<TValue, T1, T2>(
            this IOptionalValue<TValue> optionalValue,
            Func<TValue, IOptionalValue<T1>> func1,
            Func<TValue, T1, T2> func2)
        {
            return optionalValue.SelectMany(
                value => func1(value).Select(
                    value1 => func2(value, value1)
                         )
                );
        }

        public static bool HasValue<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(delegate { return true; }, () => false);
        }

        public static TValue GetValue<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(
                value => value,
                () =>
                    {
                        throw new InvalidOperationException(
                            string.Format("Optional value of '{0}' type has no value.", typeof (TValue)));
                    }
                );
        }

        public static TValue GetValueOrDefault<TValue>(
            this IOptionalValue<TValue> optionalValue)
        {
            return optionalValue.Process(value => value, () => default(TValue));
        }

        public static IOptionalValue<TValue> ToOptionalValue<TValue>(
            this TValue value) where TValue : class
        {
            return value == null ? Nothing<TValue>() : value.AsOptionalValue();
        }

        private class NotExistOptionalValue<TValue> : IOptionalValue<TValue>
        {
            public static readonly IOptionalValue<TValue> Instance = new NotExistOptionalValue<TValue>();

            private NotExistOptionalValue()
            {
            }

            public TResult Process<TResult>(
                Func<TValue, TResult> existFunc, Func<TResult> notExistFunc)
            {
                return notExistFunc();
            }
        }

        private class ExistOptionalValue<TValue> : IOptionalValue<TValue>
        {
            private readonly TValue value;

            public ExistOptionalValue(TValue value)
            {
                this.value = value;
            }

            public TResult Process<TResult>(
                Func<TValue, TResult> existFunc, Func<TResult> notExistFunc)
            {
                return existFunc(value);
            }
        }
    }

AP>    public interface IOptionalValue<out TValue>
AP>    {
AP>        TResult Process<TResult>(Func<TValue, TResult> existFunc, Func<TResult> notExistFunc);
AP>    }
AP>
AP>    [skipped]

public abstract class Option<T>
{
    class Just:Option<T>
    {
        T value;

        public Just(T value)
        {
            this.value = value;
        }

        public override bool HasValue
        {
            get { return true; }
        }

        public override T Value
        {
            get { return this.value; }
        }
    }

    class NoneClass:Option<T>
    {
        public override bool HasValue
        {
            get { return false; }
        }

        public override T Value
        {
            get { throw new InvalidOperationException("Value is empty"); }
        }
    }

    public abstract T Value { get; }
    public abstract bool HasValue { get; }

    private Option()
    {
    }

    public static readonly Option<T> None = new NoneClass();
    public static Option<T> Create(T value)
    {
        if (value == null)
        {
            throw new ArgumentNullException("value");
        }
        return new Just(value);
    }

    public static implicit operator Option<T>(T value)
    {
        if (value != null)
        {
            return Create(value);
        }
        else
        { 
            return None;
        }
    }

    public static explicit operator T(Option<T> option)
    {
        return option.Value;
    }
}

public static class Option
{
    public static Option<T> None<T>()
    {
        return Option<T>.None;
    }

    public static Option<T> ToOption<T>(this T value)
    {
        return value;
    }
        
    public static Option<V> SelectMany<T,V>(this Option<T> value, Func<T, Option<V>> selector)
    {
        return value.HasValue ? selector(value.Value) : None<V>();
    }

    public static Option<V> SelectMany<T,K,V>(this Option<T> value, Func<T, Option<K>> selector, Func<T,K,V> resultSelector)
    {
        return value.SelectMany(left => selector(left).SelectMany(right => resultSelector(left, right).ToOption()));
    }

    public static Option<V> Select<T,V>(this Option<T> value, Func<T, V> selector)
    {
        return value.SelectMany(v => selector(v).ToOption());
    }

    public static Option<T> Where<T>(this Option<T> value, Func<T, bool> predicate)
    {
        return value.SelectMany(v => predicate(v) ? v.ToOption() : None<T>());
    }

    public static V Process<T,V>(this Option<T> value, Func<T, V> success, Func<V> fail)
    {
        return value.HasValue ? success(value.Value) : fail();
    }

}

class Program
{
    static void Main(string[] args)
    {
        var z1 = from c1 in 2.ToOption()
                    from c2 in 3.ToOption()
                    select c1 + c2;
        Console.WriteLine(z1.HasValue);
        Console.WriteLine(z1.Value);

        var z2 = from c1 in 2.ToOption()
                    from c2 in 3.ToOption()
                    where c2 > 3
                    select c1 + c2;
        Console.WriteLine(z2.HasValue);
    }
}

// псевдокод
static TResult Process(
     this IOptionalValue optionalValue, 
     Func<TValue, TResult> existFunc, 
     Func<TResult> notExistFunc)
{
    if(optionalValue is ExistOptionalValue)
       return existFunc(optionalValue.Value)
    else 
       return notExistFunc();
}

AP>>Скорее нет, чем да. Если пользоваться описаниями ссылка1, ссылка2, то Null Object Pattern предлагает делать кастомный интерфейс и кастомную реализацию Null Object-а для каждого случая. A OptionalValue один для всех .

A Linked list is either a head element and a tail which is a list or empty (i.e. Null). Thus is makes sense to model an abstract linked list with a class List which has two methods getTail and accept as per the Visitor pattern [GHJV95, page 331].
http://www.cs.oberlin.edu/~jwalker/nullObjPattern/

1. Нет методов Process, нет перегруженных методов ProcessValue. А это ценно.
   
2. Нет ковариантности generic параметра. Поэтому нельзя пользоваться полиморфизмом по generic параметру, что очень печально.
   
3. Метод Select по правилам должен называться SelectMany.
   
4. Нет методов SelectMany и Select для поддержки query comprehension syntax.
   
5. Метод Some должен быть extension методом.

public static void Process<TValue>(
    this IOptionalValue<TValue> optionalValue, 
    Action<TValue> existAction, 
    Action notExistAction)
{
    optionalValue.Process(
        value =>
            {
                existAction(value);
                return new {};
            },
        () =>
            {
                notExistAction();
                return new {};
            });
}

G>public abstract class Option<T>

G>>    public static V Process<T,V>(this Option<T> value, Func<T, V> success, Func<V> fail)
G>>    {
G>>        return value.HasValue ? success(value.Value) : fail();
G>>    }
G>>

1. Не хочется иметь в базовом интерфейсе свойство, кидающее исключение.
   
2. В случае если не срабатывает type inference, то для extension метода Process придется явно прописывать значения обоих generic параметров. А если Process является методом интерфейса, то прописывать придется значение только одного generic параметра.

Хочется иметь такую технику кодирования, чтобы Extract Method не переводил ошибки компиляции в ошибки run time-а.

var x = Method1().Method2().Method3().Method4();

var x1 = Method1();
if(x1 == null) return null;
var x2 = x1.Method2();
if(x2 == null) return null;
var x3 = x2.Method3();
if(x3 == null) return null;
return x3.Method4();

void Method(Option<T> opt)
{
 //неважно
}

Method(null)

public struct Option<T> : IEquatable<Option<T>>
{
    public Option(T value)
    {
        Contract.Requires(value != null);
        this.value = value;
        this.hasValue = true;
    }

    public T Value
    {
        get
        {
            if (this.hasValue)
            {
                return this.value;
            }
            else
            {
                throw new InvalidOperationException("Value is empty");
            }
        }
    }

    public bool HasValue
    {
        get { return this.hasValue; }
    }

    public bool Equals(Option<T> other)
    {
        return (this.hasValue == other.hasValue)
            && (!this.hasValue || EqualityComparer<T>.Default.Equals(this.value, other.value));
    }

    public override bool Equals(object obj)
    {
        if (obj == null || obj.GetType() != this.GetType())
        {
            return false;
        }

        var opt = (Option<T>)obj;

        return Equals(opt);
    }

    public override int GetHashCode()
    {
        return hasValue ? EqualityComparer<T>.Default.GetHashCode(value) : 0;
    }

    T value;
    bool hasValue;


    public static implicit operator Option<T>(T value)
    {
        if (value != null)
        {
            return new Option<T>(value);
        }
        else
        {
            return new Option<T>();
        }
    }

    public static explicit operator T(Option<T> option)
    {
        return option.Value;
    }

    [ContractInvariantMethod]
    void ObjectInvariant()
    {
        Contract.Invariant(!hasValue || value != null);
    }
}

public static class Option
{
    public static Option<T> None<T>()
    {
        return new Option<T>();
    }

    public static Option<T> ToOption<T>(this T value)
    {
        return value;
    }

    public static Option<V> SelectMany<T, V>(this Option<T> value, Func<T, Option<V>> selector)
    {
        Contract.Requires(selector != null);
        return value.HasValue ? selector(value.Value) : None<V>();
    }

    public static Option<V> SelectMany<T, K, V>(this Option<T> value, Func<T, Option<K>> selector, Func<T, K, V> resultSelector)
    {
        Contract.Requires(selector != null);
        Contract.Requires(resultSelector != null);
        return value.SelectMany(left => selector(left).SelectMany(right => resultSelector(left, right).ToOption()));
    }

    public static Option<V> Select<T, V>(this Option<T> value, Func<T, V> selector)
    {
        Contract.Requires(selector != null);
        return value.SelectMany(v => selector(v).ToOption());
    }

    public static Option<T> Where<T>(this Option<T> value, Func<T, bool> predicate)
    {
        Contract.Requires(predicate != null);
        return value.SelectMany(v => predicate(v) ? v.ToOption() : None<T>());
    }

    public static V Process<T, V>(this Option<T> value, Func<T, V> success, Func<V> fail)
    {
        Contract.Requires(success != null);
        Contract.Requires(fail != null);
        return value.HasValue ? success(value.Value) : fail();
    }
}

var result = optionalValue.Process<IA>(value => new B(), () => new C()); //если метод интерфейса
var result = optionalValue.Process<SomeClass, IA>(value => new B(), () => new C()); //если extension метод

interface IA {}
class B: IA { }
class C: IA { }

class WebServiceOptionalValue: IOptionalValue<DateTime>
{
    public TResult Process<TResult>(Func<DateTime, TResult> existFunc, Func<TResult> notExistFunc)
    {
        DateTime webServiceMethod;
        try
        {
            webServiceMethod = WebServiceMethod();
        }
        catch
        {
            return notExistFunc();
        }
        return existFunc(webServiceMethod);
    }
}

public interface IOptionalValue<TValue>
{
    TValue Value { get; }
    bool HasValue { get; }
}

AP>class WebServiceOptionalValue: IOptionalValue<DateTime>
AP>{
AP>    public TResult Process<TResult>(Func<DateTime, TResult> existFunc, Func<TResult> notExistFunc)
AP>    {
AP>        DateTime webServiceMethod;
AP>        try
AP>        {
AP>            webServiceMethod = WebServiceMethod();
AP>        }
AP>        catch
AP>        {
AP>            return notExistFunc();
AP>        }
AP>        return existFunc(webServiceMethod);
AP>    }
AP>}
AP>

AP>А попробуйте написать реализацию интерфейса с двумя методами :

public static Option<TResult> SafeWebServiceMethod(this WebService webService, ...)
{
    try
    {
        return  webService.WebServiceMethod(...);
    }
    catch
    {
        return Option.None<TResult>;
    }
}

AP>>Скорее нет, чем да. Если пользоваться описаниями ссылка1, ссылка2, то Null Object Pattern предлагает делать кастомный интерфейс и кастомную реализацию Null Object-а для каждого случая. A OptionalValue один для всех .

"[Одним из] недостатков является то, что паттерн 'Null Object' ... приводит к взрывному росту числа классов. Потому что необходимо создать свой 'пустой' класс для каждого абстрактного класса."

"Поедающий" сообщения nil

interface IOptionalValue<out T>
{
    //TResult Process<TResult>(Func<T, TResult> f1, Func<TResult> f2);
}

class OptionalValue<T> : IOptionalValue<T>
{
    private OptionalValue() {}

    public sealed class NothingValue : OptionalValue<T> { }

    public sealed class JustValue : OptionalValue<T>
    {
        public readonly T Value;

        public JustValue(T value) { Value = value; }
    }
}

G>>

class Ololo<T>: IOptionalValue<T>
{
    public TResult Process<TResult>(Func<T, TResult> existFunc, Func<TResult> notExistFunc)
    {
        return default(TResult);
    }
}

G>var x = Method1().Method2().Method3().Method4();
G>

G>var x1 = Method1();
G>if(x1 == null) return null;
G>var x2 = x1.Method2();
G>if(x2 == null) return null;
G>var x3 = x2.Method3();
G>if(x3 == null) return null;
G>return x3.Method4();
G>

var x = Method1().Method2().Method3().Method4();

G>>var x1 = Method1();
G>>if(x1 == null) return null;
G>>var x2 = x1.Method2();
G>>if(x2 == null) return null;
G>>var x3 = x2.Method3();
G>>if(x3 == null) return null;
G>>return x3.Method4();
G>>

S>var x = Method1().Method2().Method3().Method4();
S>

    class Program
    {
        static void Main(string[] args)
        {
            TestV1();
            TestV2();
        }

        static A Method1()
        {
            return null;
        }
        static IOptionalValue<A> TestV1()
        {
            return from x1 in Method1().ToOptionalValue()
                   from x2 in x1.Method2().ToOptionalValue()
                   from x3 in x2.Method3().ToOptionalValue()
                   select x3.Method4();
        }
        static IOptionalValue<A> TestV2()
        {
            return Method1().ToOptionalValue().SelectMany(x1 =>
                x1.Method2().ToOptionalValue().SelectMany(x2 =>
                x2.Method3().ToOptionalValue().SelectMany(x3 =>
                x3.Method4().ToOptionalValue())));
        }
    }

    class A {}

    static class AExtensions
    {
        public static A Method2(this A a)
        {
            return a;
        }
        public static A Method3(this A a)
        {
            return a;
        }
        public static A Method4(this A a)
        {
            return a;
        }
    }

S>    class Program
S>    {
S>        static IOptionalValue<A> TestV1()
S>        {
S>            return from x1 in Method1().ToOptionalValue()
S>                   from x2 in x1.Method2().ToOptionalValue()
S>                   from x3 in x2.Method3().ToOptionalValue()
S>                   select x3.Method4();
S>        }
S>        static IOptionalValue<A> TestV2()
S>        {
S>            return Method1().ToOptionalValue().SelectMany(x1 =>
S>                x1.Method2().ToOptionalValue().SelectMany(x2 =>
S>                x2.Method3().ToOptionalValue().SelectMany(x3 =>
S>                x3.Method4().ToOptionalValue())));
S>        }
S>    }
S>

Method1()
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method3());

var x = Method1()
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method3());

var x = Method1()
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method3())
    .ProcessValue(_ => _.Method4());

AP>

AP>var x = Method1()
AP>    .ProcessValue(_ => _.Method2())
AP>    .ProcessValue(_ => _.Method3())
AP>    .ProcessValue(_ => _.Method4());
AP>

Здесь любой из методов MethodX может возвращать как T так и IOptionalValue<T> запись от этого не меняется. И это классно .

static TResult ProcessValue<T, TResult>(this T value, Func<T, TResult> func)
   where T : class
   where TResult : class
{
     return (value != null) ? func(value) : default(TResult);
}

G>>var x1 = Method1();
G>>if(x1 == null) return null;
G>>var x2 = x1.Method2();
G>>if(x2 == null) return null;
G>>var x3 = x2.Method3();
G>>if(x3 == null) return null;
G>>return x3.Method4();
G>>

S>var x = Method1().Method2().Method3().Method4();
S>

var x = from x1 in Method1().ToOption()
        from x2 in x1.Method2().ToOption()
        from x3 in x2.Method3().ToOption()
        select x3.Method4();

G>>>

G>class Ololo<T>: IOptionalValue<T>
G>{
G>    public TResult Process<TResult>(Func<T, TResult> existFunc, Func<TResult> notExistFunc)
G>    {
G>        return default(TResult);
G>    }
G>}
G>

где, что не работает?
http://rsdn.ru/forum/design/3953905.1.aspx

Автор: Alexander Polyakov
Дата: 10.09.10

Type1 x = null;
var x1 = Method1();
if(x1 != null) 
{ 
  var x2 = x1.Method2();
  if(x2 != null) 
  { 
    var x3 = x2.Method3();
    if(x3 != null) 
    x = x3.Method4();
  }
}

S>Type1 x = null;
S>var x1 = Method1();
S>if(x1 != null) 
S>{ 
S>  var x2 = x1.Method2();
S>  if(x2 != null) 
S>  { 
S>    var x3 = x2.Method3();
S>    if(x3 != null) 
S>    x = x3.Method4();
S>  }
S>}
S>

Type1 x;
var x1 = Method1();
if (x1 == null)
    x = null;
else
{
    var x2 = x1.Method2();
    if (x2 == null)
        x = null;
    else
    {
        var x3 = x2.Method3();
        if (x3 == null)
            x = null;
        else
            x = x3.Method4();
    }
}

1. Надо ли показывать к каким косякам может привести изменяемое состояние в данном случае?
   
2. В каком варианте будем подсчитывать многословность (количество слов)?

var x = Method1()
    .ProcessValue(_ => _.Method2())
    .ProcessValue(_ => _.Method3())
    .ProcessValue(_ => _.Method4());

OptionalValue как раз и служит для разделение опциональных и не опциональных переменных. Соответственно, для первых применяем такую запись, а для вторых обычную. А какой будет переменная T или IOptionalValue<T> определяет поставщик переменной. Если мы знаем, что поставщик соблюдает это правило, то для T можно не беспокоиться об NRE. Если поставщик не соблюдает это правило, то все как обычно, т.е. хреново: писать или не писать if, если писать, то, что внутри этого if-а делать и т.д. Глупость заключается в том, чтобы создавать эту хреновую ситуацию и в случае, если вы сами являетесь тем поставщиком.
http://rsdn.ru/forum/design/3954267.1.aspx

Автор: Alexander Polyakov
Дата: 11.09.10

private static IOptionalValue<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
    string catalogNumber, string precededCatalogNumber, int releaseMark)
{
    if (string.IsNullOrEmpty(precededCatalogNumber))
    {
        return FindPreviousPublicationIdBySelfNumber(catalogNumber, releaseMark)
            .ProcessValue(value => new SelfNumberFollowingPublicationCalculator(value, catalogNumber));
    }
    else
    {
        return FindPreviousPublicationIdByOtherNumber(precededCatalogNumber)
            .ProcessValue(value => new OtherNumberFollowingPublicationCalculator(value, precededCatalogNumber));
    }
}

Extract Method становится безопасным при использовании техники кодирования, описанной в разделе “Катастрофа при Extract Method”. http://rsdn.ru/forum/design/3955011.1.aspx

Автор: Alexander Polyakov
Дата: 12.09.10

    match dict.TryGetValue "Brian" with 
    | Some(r) -> Console.WriteLine("Brian's favorite 32-bit integer is {0}", r) 
    | None    -> ()

dict.GetValueEx("Brian").Process(
    r => Console.WriteLine("Brian's favorite 32-bit integer is {0}", r), 
   () => ()
);

AP>private static IOptionalValue<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
AP>    string catalogNumber, string precededCatalogNumber, int releaseMark)
AP>{
AP>    if (string.IsNullOrEmpty(precededCatalogNumber))
AP>    {
AP>        return FindPreviousPublicationIdBySelfNumber(catalogNumber, releaseMark)
AP>            .ProcessValue(value => new SelfNumberFollowingPublicationCalculator(value, catalogNumber));
AP>    }
AP>    else
AP>    {
AP>        return FindPreviousPublicationIdByOtherNumber(precededCatalogNumber)
AP>            .ProcessValue(value => new OtherNumberFollowingPublicationCalculator(value, precededCatalogNumber));
AP>    }
AP>}
AP>

private static Option<IFollowingPublicationCalculator> GetByOtherNumber(string catalogNumber)
{  
    return from number in сatalogNumber.ToOption()
           where number != string.Empty
           from pub in FindPreviousPublicationIdByOtherNumber(number)
           select new OtherNumberFollowingPublicationCalculator(pub, number)
                    as IFollowingPublicationCalculator;
}

private static Option<IFollowingPublicationCalculator> GetBySelfNumber(string catalogNumber, int releaseMark)
{  
    return from number in catalogNumber.ToOption()
           where number != string.Empty
           from pub in FindPreviousPublicationIdBySelfNumber(number, releaseMark)
           select new SelfNumberFollowingPublicationCalculator(pub, number)
                    as IFollowingPublicationCalculator;
}

private static Optional<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
    string catalogNumber, string precededCatalogNumber, int releaseMark)
{
    var calc = GetByOtherNumber(precededCatalogNumber);
    return calc.HasValue ? calc : GetBySelfNumber(catalogNumber, releaseMark);
}

//! Далее везде readNum возвращает Option-type

// Haskell
do 
  x <- readNum
  y <- readNum
  return $ x + y

// Scala
for {
  x <- readNum()
  y <- readNum()
} yield (x+y)

from x in ReadNum()
from y in ReadNum()
select (x+y)

AP>>private static IOptionalValue<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
AP>>    string catalogNumber, string precededCatalogNumber, int releaseMark)
AP>>{
AP>>    if (string.IsNullOrEmpty(precededCatalogNumber))
AP>>    {
AP>>        return FindPreviousPublicationIdBySelfNumber(catalogNumber, releaseMark)
AP>>            .ProcessValue(value => new SelfNumberFollowingPublicationCalculator(value, catalogNumber));
AP>>    }
AP>>    else
AP>>    {
AP>>        return FindPreviousPublicationIdByOtherNumber(precededCatalogNumber)
AP>>            .ProcessValue(value => new OtherNumberFollowingPublicationCalculator(value, precededCatalogNumber));
AP>>    }
AP>>}
AP>>

G>private static Option<IFollowingPublicationCalculator> GetByOtherNumber(string catalogNumber)
G>{  
G>    return from number in сatalogNumber.ToOption()
G>           where number != string.Empty
G>           from pub in FindPreviousPublicationIdByOtherNumber(number)
G>           select new OtherNumberFollowingPublicationCalculator(pub, number)
G>                    as IFollowingPublicationCalculator;
G>}

G>private static Option<IFollowingPublicationCalculator> GetBySelfNumber(string catalogNumber, int releaseMark)
G>{  
G>    return from number in catalogNumber.ToOption()
G>           where number != string.Empty
G>           from pub in FindPreviousPublicationIdBySelfNumber(number, releaseMark)
G>           select new SelfNumberFollowingPublicationCalculator(pub, number)
G>                    as IFollowingPublicationCalculator;
G>}

G>private static Optional<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
G>    string catalogNumber, string precededCatalogNumber, int releaseMark)
G>{
G>    var calc = GetByOtherNumber(precededCatalogNumber);
G>    return calc.HasValue ? calc : GetBySelfNumber(catalogNumber, releaseMark);
G>}
G>

private static IOptionalValue<IFollowingPublicationCalculator> GetFollowingPublicationCalculator(
    string catalogNumber, string precededCatalogNumber, int releaseMark)
{
    if (string.IsNullOrEmpty(precededCatalogNumber))
    {
        return FindPreviousPublicationIdBySelfNumber(catalogNumber, releaseMark)
            .ProcessValue<IFollowingPublicationCalculator>(value => new SelfNumberFollowingPublicationCalculator(value, catalogNumber));
    }
    else
    {
        return FindPreviousPublicationIdByOtherNumber(precededCatalogNumber)
            .ProcessValue<IFollowingPublicationCalculator>(value => new OtherNumberFollowingPublicationCalculator(value, precededCatalogNumber));
    }
}