// Just and Nothing
var justInt = Maybe.Just(10);
var nothingString = Maybe.Nothing<string>();

// FromJust
var x = justInt.FromJust;

// Conversion from/to Nullable<T>
int? n1 = 10;
var mn = n1.ToMaybe();
var n2 = mn.ToNullable();

// Dictionary lookup
var dict = new Dictionary<int, string>
    {
        {1, "one"},
        {3, "three"}
    };
var mvJust = dict.GetValue(1);
var mvNothing = dict.GetValue(2);

// Basic pattern matching
Console.WriteLine("mvJust: {0}", mvJust.Match(a => a, () => "Nothing"));
Console.WriteLine("mvNothing: {0}", mvNothing.Match(a => a, () => "Nothing"));

// Bind
var ma = Maybe.Just(42);
var mb1 = ma.Bind(a => Maybe.Just(a * a)); // returns Maybe<int>
var mb2 = ma.Bind(a => Maybe.Return(a * a)); // returns Maybe<int>
var mb3 = ma.Bind(a => Maybe.Just(Convert.ToString(a * a))); // returns Maybe<string>
var mb4 = ma.Bind(a => Maybe.Return(Convert.ToString(a * a))); // returns Maybe<string>

// LiftM
var mc = Maybe.Just(12);
var md1 = mc.LiftM(a => a * a); // returns Maybe<int>
var md2 = mc.LiftM(a => Convert.ToString(a * a)); // returns Maybe<string>

using System;
using System.Collections.Generic;
using MonadLib;

namespace Monads
{
    using AssociationList = Dictionary<string, Maybe<string>>;

    public static class MaybeExample
    {
        public static void Demo()
        {
            var alist = new AssociationList
                {
                    {"title", Maybe.Just("Jaws")},
                    {"user", Maybe.Just("Jon")},
                    {"review", Maybe.Just("A film about a shark")}
                };

            // Using void Maybe.Match()
            GetMovieReview(alist).Match(
                movieReview => Console.WriteLine("GetMovieReview returned {0}.", MovieReview.Format(movieReview)),
                () => Console.WriteLine("GetMovieReview returned Nothing."));

            // Using T Maybe.Match<T>()
            Console.WriteLine(
                "GetMovieReview returned {0}.",
                GetMovieReview(alist).Match(
                    MovieReview.Format,
                    () => "Nothing"));
        }

        private static Maybe<MovieReview> GetMovieReview(AssociationList alist)
        {
            return Maybe.LiftM3(
                MovieReview.MakeMovieReview,
                Lookup(alist, "title"),
                Lookup(alist, "user"),
                Lookup(alist, "review"));
        }

        private static Maybe<string> Lookup(AssociationList alist, string key)
        {
            return alist
                .GetValue(key)
                .Bind(v => v.MFilter(s => !string.IsNullOrEmpty(s)));
        }
    }
}

// Either has two type parameters - TLeft and TA.
// This is a little trick to make EitherString an alias for Either<String>.
// EitherString is then a monad with a single type parameter - TA.
using EitherString = Either<String>;

// Creating a Left and Right
var eitherLeft = EitherString.Left<int>("an error message");
var eitherRight = EitherString.Right(10);

// Extracting values via Left and Right
var left = eitherLeft.Left;
var right = eitherRight.Right;

// Basic pattern matching
Console.WriteLine("eitherLeft: {0}", eitherLeft.Match(l => Convert.ToString(l), r => Convert.ToString(r)));
Console.WriteLine("eitherRight: {0}", eitherRight.Match(l => Convert.ToString(l), r => Convert.ToString(r)));

// Bind
var eitherRightSquared1 = eitherRight.Bind(r => EitherString.Right(r * r));
var eitherRightSquared2 = eitherRight.Bind(r => EitherString.Return(r * r));

// LiftM
var eitherRightSquared3 = eitherRight.LiftM(r => r * r);

// State has two type parameters - TS and TA.
// This is a little trick to make StateString an alias for State<string>.
// StateString is then a monad with a single type parameter - TA.
using TickState = State<int>;

var tick = TickState
    .Get()
    .Bind(n => TickState
                    .Put(n + 1)
                    .BindIgnoringLeft(TickState.Return(n)));

Console.WriteLine("tick.EvalState(5): {0}", tick.EvalState(5));
Console.WriteLine("tick.ExecState(5): {0}", tick.ExecState(5));

// Reader has two type parameters - TR and TA.
// This is a little trick to make ReaderConfig an alias for Reader<Config>.
// ReaderConfig is then a monad with a single type parameter - TA.
using ReaderConfig = Reader<Config>;

var config = new Config(2);

var reader1 = ReaderConfig
    .Ask()
    .Bind(c1 => ReaderConfig.Return(c1.Multiplier * 3));
Console.WriteLine("reader1.RunReader(config): {0}", reader1.RunReader(config));

var reader2 = ReaderConfig
    .Ask()
    .Local(c1 => new Config(c1.Multiplier * 2))
    .Bind(c2 => ReaderConfig.Return(c2.Multiplier * 3));
Console.WriteLine("reader2.RunReader(config): {0}", reader2.RunReader(config));

using MyWriter = Writer<ListMonoid<string>, string>;
using MyWriterInt = Writer<ListMonoid<string>, string, int>;
using MyWriterUnit = Writer<ListMonoid<string>, string, Unit>;

internal class Program
{
    private static void Main()
    {
        Print(MultWithLog().RunWriter);
    }

    private static void Print(Tuple<int, ListMonoid<string>> tuple)
    {
        var a = tuple.Item1;
        var w = tuple.Item2;
        Console.WriteLine("a: {0}", a);
        foreach (var msg in w.List) Console.WriteLine("msg: {0}", msg);
    }

    private static MyWriterInt MultWithLog()
    {
        return LogNumber(3).Bind(
            a => LogNumber(5).Bind(
                b => TellHelper(string.Format("multiplying {0} and {1}", a, b)).BindIgnoringLeft(
                    MyWriter.Return(a * b))));
    }

    private static MyWriterInt LogNumber(int x)
    {
        return TellHelper(string.Format("Got number: {0}", x))
            .BindIgnoringLeft(MyWriter.Return(x));
    }

    private static MyWriterUnit TellHelper(string s)
    {
        var listMonoid = new ListMonoid<string>(s);
        return MyWriter.Tell(listMonoid);
    }
}

        return MyWriter.Tell(listMonoid).ReplicateM_(5);