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);