using System.Diagnostics;
using static System.Console;
using static LanguageExt.Prelude;
Try(() => { WriteLine("DONE");return true;}).Match(_ => WriteLine("OK"), exn => WriteLine(exn));

vaa>using System.Diagnostics;
vaa>using static System.Console;
vaa>using static LanguageExt.Prelude;
vaa>Try(() => { WriteLine("DONE");return true;}).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
vaa>

method Unit Match <A> (this Try<A> self, Action<A> Succ, Action<Exception> Fail)

Try(() => { WriteLine("DONE");}).Match( a => {a.GetType(); WriteLine("OK")}, exn => WriteLine(exn));

S>Try().Match( a => {a.GetType(); WriteLine("OK")}, exn => WriteLine(exn));
S>

    Try(fun(() => { WriteLine("DONE");}))

public static Func<int, int> MakeAdd(int x)
  => (int y) => x + y; 

[Fact]
public void TestAdd()
{
   Assert.Equal(42, MakeAdd(5)(37));
}

(setq a 10)
(setq f1 (lambda (b)
       (+ a b))) ;; (setq lexical-binding nil) даст (lambda (b) (+ a b))
;; (setq lexical-binding t) даст (closure (t) (b) (+ a b))
(funcall f1 1)

(let ((a 20))
  (funcall f1 1))
;; в первом случае 11 21
;; во втором случае 11 11

vaa>>Вот тут хороший пример https://habr.com/ru/post/511534/ (не косяки, а подводные камни )

vaa>;(setq a 10)
vaa>;(setq f1 (lambda (b)
vaa>;       (+ a b))) ;; (setq lexical-binding nil) даст (lambda (b) (+ a b))
vaa>;;; (setq lexical-binding t) даст (closure (t) (b) (+ a b))
vaa>;(funcall f1 1)

vaa>;(let ((a 20))
vaa>;  (funcall f1 1))
vaa>;;; в первом случае 11 21
vaa>;;; во втором случае 11 11
vaa>;

delegate Try <A>

void Main()
{
    var foo = Foo();
    var inc1 = foo();
    var inc2 = foo();
    
    inc1().Dump(); // 1
    inc2().Dump(); // 2
}

Func<Func<int>> Foo()
{
    int i = 0;
    return () => () => ++i;
}

vaa>>Да, видимо генератор доков сломался

Try((int x) => { WriteLine("DONE"); return x; }).Match(_ => WriteLine("OK"), exn => WriteLine(exn));

public Result delegate Try(); // non-generic Result behaves as non-generic Task: it either captures nothing or an exception thrown from action
public static class Prelude
{
  public static Try Try(Action a)
    => ()=>  { try {a(); return Result.Success;} 
               catch(Exception e) { return Result.FromException(e);
  }
}

public static class TryExtenions
{
  public static void Match(this Try ma; Action succ; Action<Exception> Fail)
  {
    var res = self.Try();
    if (res.IsFaulted)
      Fail(res.Exception);
    else
      Succ();
  }
}

public Result<A> delegate Try<T, A>(T t); 
public static class Prelude
{
  public static Try<T, A> Try<T, A>(Func<T, A> f) => (T x) => f(x);
}

public static class TryExtenions
{
  public static Func<T, R> Match<T, A, R>(this Try<T, A> ma; Func<A, R> succ; Func<Exception, R> fail)
    => (T x) => 
       {
      var res = self.Try(x); 
          return res.IsBottom ? Fail(res.Exception ?? new BottomException())
                : res.IsFaulted ? Fail(res.Exception)
                : Succ(res.Value);  
       }
}

using static System.Console;
var x = 42;
Action<int> closure = a => { WriteLine("closure = {0}", a + x); };
Action<int> lambda = Lambda(x);
closure(5);
lambda(5);
x = 11;
closure(5);
lambda(5);

Action<int> Lambda(int a) =>
    x => { WriteLine("lambda = {0}", x + a); };

using System;

private static void <Main>$(string[] args)
{
    int x2 = 42;
    Action<int> closure = delegate(int a)
    {
        Console.WriteLine("closure = {0}", a + x2);
    };
    Action<int> lambda = Lambda(x2);
    closure(5);
    lambda(5);
    x2 = 11;
    closure(5);
    lambda(5);
    static Action<int> Lambda(int a)
    {
        return delegate(int x)
        {
            Console.WriteLine("lambda = {0}", x + a);
        };
    }
}

closure = 47
lambda = 47
closure = 16
lambda = 47

using System;
using static System.Console;
var x = 42;
Action<int> closure = a => { WriteLine("closure = {0}", a + x); };
Func<Action<int>> lambda = ()=>{var y=x; return (a)=> WriteLine("lambda = {0}", a + y); };
closure(5);
lambda()(5);
x = 11;
closure(5);
lambda()(5);

S>Try((int x) => { WriteLine("DONE"); return x; }).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
S>

using LanguageExt;
using static System.Console;
using static LanguageExt.Prelude;

string message = "Done";
PrintMessage(message).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
//что эквивалентно, благодоря fun
Try(fun(() => WriteLine(message))).Match(_ => WriteLine("OK"), exn => WriteLine(exn));

Try<Unit> PrintMessage(string message)
{
    return () =>
    {
        WriteLine(message);
        return unit;
    };
}

S>>Try((int x) => { WriteLine("DONE"); return x; }).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
S>>

using LanguageExt;
using static System.Console;
using static LanguageExt.Prelude;

string message = "Done";
PrintMessage(message).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
//что эквивалентно, благодоря fun
Try(fun(() => WriteLine(message))).Match(_ => WriteLine("OK"), exn => WriteLine(exn));

Try<Unit> PrintMessage(string message)
{
    return () =>
    {
        WriteLine(message);
        return unit;
    };
}

Try((int x) => { WriteLine("DONE"); throw new InvalidOperationException(); return x; }).Match(_ => WriteLine("OK"), exn => WriteLine(exn));

S>>Try((int x) => { WriteLine("DONE"); throw new InvalidOperationException(); return x; }).Match(_ => WriteLine("OK"), exn => WriteLine(exn));
S>>

Func<int, int> foo = x => x % 2 == 0 ? 1 : throw new Exception("Oops");
Func<int> bar = () => foo(DateTime.Now.Millisecond);

// 1. Working with the parameterless function:
// 1.1. Wrapping into the Try monad:
var tryBar = Try(bar);
// 1.2 Direct execution (note the lack of params in Try):
var barResult = tryBar.Try(); // Result<int>
// 1.3. Coalescing exceptions into default value
var barFinalResult = barResult.Match(x => x, ex => 1);
Assert.Equal(1, barFinalResult);
// 1.4. Shortcut coalescing:
barFinalResult = tryBar.Match(x => x, ex => 1);
Assert.Equal(1, barFinalResult);
// 1.5. Returnless matching:
tryBar.Match(x => WriteLine(x), ex => WriteLine(ex));

var tryFoo = Try(foo);

method R Match <A, R> (this Try<A> self, Func<A, R> Succ, Func<Exception, R> Fail)

Try<Func<A>>, Try<Action>

Try((int x) => { WriteLine("DONE"); return x; })

using Try<A> = Func<Result<A>>

method Try<A>(Exception e): Func<Result<A>> {
  return () => ResultFail(e);
}
method Try<A>(A a): Func<Result<A>> {
  return () => ResultSuccess(e);
}
method Try<A>(Func<A> fn): Func<Result<A>> {
  return () => {
    try {
      ResultSuccess(fn()) // close to TrySucc
    } catch(Exception e) {
      ResultFail(e) // close to TryFail
    }
  }
}

method R Match <A, R> (this Try<A> self, Func<A, R> Succ, Func<Exception, R> Fail) {
  // force computation
  val resultValue: Result<A> = self()
  // and process outcomes, same as resultValue.Match(Succ, Fail)
  if (resultValue.isSuccess()) {
    return Succ(resultValue.value);
  } else {
    return Fail(resultValue.exception);
  }
}

method A Try<A>(this Try<A> self) {
  return self();
}

var tryFoo = Try(foo);
var appliedFoo = tryFoo.Map(fn => fn(DateTime.Now.Millisecond))
appliedFoo.Match(x => x, ex => 1)

S>>Try((int x) => { WriteLine("DONE"); return x; })
S>>

        public static Try<A> Try<A>(A v) =>
            () => v;

var Dictionary<string, string> hardcodedConfig = ...;

method Try<Dictionary<string, string>> getAppProperties() {
  // some implementation...
}

method Dictionary<string, string> loadConfigFromUrl(String url) {
  // some implementation, assume throws.
}

Dictionary<string, string> tryLoadConfig =
  getAppProperties()
    .Bind(appConf =>
      if (appConf.ContainsKey("dict.bootstrap.url")) {
        Try( () => loadConfigFromUrl(appConf["dict.bootstrap.url"]) ).Retry(3)
      } else {
        TrySucc(hardcodedConfig) // or Try(hardcodedConfig)
      }
    )

Dictionary<string, string> tryLoadConfig =
  getAppProperties()
    .Map(appConf =>
      if (appConf.ContainsKey("dict.bootstrap.url")) {
        Try( () => loadConfigFromUrl(appConf["dict.bootstrap.url"]) ).Retry(3).IfFailThrow
      } else {
        hardcodedConfig
      }
    )