open Avalonia
open Avalonia.Controls
open Avalonia.Markup.Xaml
open FSharp.Control.Reactive
open Avalonia.Threading

type AppState =
    { Count: int
      EnableTimer: bool }

    static member Zero = { Count = 0; EnableTimer = true }

type MainWindow() as this =
    inherit Window()
    do this.InitializeComponent()

    member private this.InitializeComponent() =
#if DEBUG
        this.AttachDevTools()
#endif
        AvaloniaXamlLoader.Load(this)

        let count = Subject.behavior (AppState.Zero)

        let tb = this.FindControl<TextBlock>("info")
        let btn = this.FindControl<Button>("inc")
        let inc = fun (x: AppState) -> { x with Count = x.Count + 1 }

        btn.Click.Add(fun _ ->
            if count.Value.EnableTimer then
                count.OnNext(
                    { count.Value with
                        Count = count.Value.Count + 1
                        EnableTimer = false }
                )
            else
                count.OnNext(inc count.Value))

        count.Subscribe(fun x -> Dispatcher.UIThread.Invoke(fun _ -> tb.Text <- $"Count: {x.Count}"))
        |> ignore

        task {
            while count.Value.EnableTimer do
                do! Async.Sleep 1000
                count.OnNext(inc count.Value)
        }
        |> ignore

from d in _dates select d.AddDays(17).AddYears(-1);

S>Form form = new() {
S>   header: new(content: aaa)
S>   main= new() { 
S>    list new(){
S>      ItemA = new(id= 'a', content= yyy ),
S>      ItemB = new(id= 'a', content= zzz ),
S>   }
S>   },
S>   footer= OkCancelFooter {onOk = onOkHandler, onCancel= onCancelHandler, onDispose= onDisposeHandler}
S>}
S>

[
      ItemA {id: 'a', content: yyy },
      ItemB {id: 'a', content: zzz },
]

/// Simplicity
module FP =
    let add_v1 = fun a b -> a + b
    let add_v2 = (+)
    let add_v3 a b = a + b


FP.add_v1 1 1 |> printfn "%d"

/// Complexity
module OOP =
    type Add(a) =
        class
            member it.Value = a
            member it.Plus(b) = Add((b :> Add).Value + a)
        end

OOP.Add(1).Plus(OOP.Add(1)).Value |> printfn "%d"

- Ваша главная слабость?
— Правильно интерпретирую семантику вопроса, но игнорирую его суть.
— Не могли бы вы привести пример?
— Мог бы⁠⁠.

Вот помню я программировал на Фортране, Паскале (не Турбо). Там никакого ООП не было. Только процедурное программирование. Но было состояние. Глобальные переменные и переменные функции и параметры.
Которые в огромном количестве передавались из метода в метод.
Что бы не таскать переменные через параметры, решили передавать через ссылку на структуру.
А затем, зачем нам передавать явно, давай прикрутим методы к структуре, а self будем передавать неявно через регистр, прикрутили наследование и VMT, информацию о типе, ну и так далее Получился ООП

struct Out { virtual void write(const Data&) const = 0; };

struct Console { virtual void write(const Data&) const { ... }; };

struct File { virtual void write(const Data&) const { ... }; };

void foo(const Data& d, Out& out) {
    out.write(d);
}

void main(){
    const auto console = Console{};
    const auto file = File{};
    const Data d{42};
    foo(d, console);
    foo(d, file);
}

void write_to_console(const Data& ) { ... }
void write_to_file(const Data& ) { ... }

void foo(const Data& d, auto write) {
    write(d);
}

void main() {
    const auto log = [file = "log.txt"](const Data& d) { write_to_file(file, d); };
    const Data d{42};
    foo(d, log);
    foo(d, write_to_console);
}

SP>struct Out { virtual void write(const Data&) const = 0; };

SP>struct Console { virtual void write(const Data&) const { ... }; };

SP>struct File { virtual void write(const Data&) const { ... }; };

SP>void foo(const Data& d, Out& out) {
SP>    out.write(d);
SP>}

SP>void main(){
SP>    const auto console = Console{};
SP>    const auto file = File{};
SP>    const Data d{42};
SP>    foo(d, console);
SP>    foo(d, file);
SP>}
SP>

struct Out { write: (Data) -> void}

public interface IGroup<T>
{
  public T NeutralElement {get;}
  public T Combine(T a, T b)
} 

public class IntAddition: IGroup<int>
{
   public int NeutralElement { get => 0; }
   public int Combine(int a, int b) => a + b;
}

public static class H
{
   public static T Reduce<T>(this IEnumerable<T> input, IGroup<T> group)
   {
      var r = group.NeutralElement;
      foreach(var i in input)
        r = group.Combine(r, i);
      return r;
   }
}

public static class Program
{
   public static void Main()
   {
      var t = new[] {4, 8, 15, 16, 23, 42};
      var sum = t.Reduce(new IntAddition()); 
   }
}

   public static T Reduce(this IEnumerable<T> input, (Func<T> neutralElement, Func<T, T, T> combine))
   {
      var r = group.neutralElement();
      foreach(var i in input)
        r = group.combine(r, i);
      return r;
   }
public static class Program
{
   public static void Main()
   {
      var t = new[] {4, 8, 15, 16, 23, 42};
      var intAddition = (()=>0, (int x, int y)=>x+y);
      var sum = t.Reduce(intAddition); 
   }
}

public interface IAccumulator<T>
{
  public T Current{get;}
  public void Accumulate(T value);
} 

public class AddAccumulator: IAccumulator<int>
{
   private _value = 0;
   public int Current{ get => _value; }
   public void Accumulate(int value) => _value += value;
}

public static class H
{
   public static T Reduce<T>(this IEnumerable<T> input, IAccumulator<T> accumulator)
   {
      foreach(var i in input)
        accumulator.Accumulate(i);
      return accumulator.Current;
   }
}

public static class Program
{
   public static void Main()
   {
      var t = new[] {4, 8, 15, 16, 23, 42};
      var sum = t.Reduce(new AddAccumulator()); 
   }
}

public struct record Accumulator<T>(T value, Func<T, Accumulator<T>> accumulate);

public static class H
{
   public static T Reduce<T>(this IEnumerable<T> input, Accumulator accumulator)
   {
      foreach(var i in input)
        accumulator = accumulator.Accumulate(i);
      return accumulator.Current;
   }
   public static Accumulator<T> CreateAccumulator<T>(T value, Func<T, T, T> combine)
     => new Accumulator(value, (T x) => CreateAccumulator(combine(value, x), combine);
}


public static class Program
{
   public static void Main()
   {
      var t = new[] {4, 8, 15, 16, 23, 42};
      var addAccumulator = H.CreateAccumulator(0, (x, y)=> x+y);
      var sum = t.Reduce(addAccumulator); 
   }
}

S>public interface IGroup<T>
S>{
S>  public T NeutralElement {get;}
S>  public T Combine(T a, T b)
S>} 

S>public class IntAddition: IGroup<int>
S>{
S>   public int NeutralElement { get => 0; }
S>   public int Combine(int a, int b) => a + b;
S>}

S>public static class H
S>{
S>   public static T Reduce<T>(this IEnumerable<T> input, IGroup<T> group)
S>   {
S>      var r = group.NeutralElement;
S>      foreach(var i in input)
S>        r = group.Combine(r, i);
S>      return r;
S>   }
S>}

S>public static class Program
S>{
S>   public static void Main()
S>   {
S>      var t = new[] {4, 8, 15, 16, 23, 42};
S>      var sum = t.Reduce(new IntAddition()); 
S>   }
S>}
S>

class MyObject {
    int _v;
    public: void setField(int v) { _v = v; }
};

class MyObject {
    int _v;
    public: MyObject setField(int v)&& { this->_v = v; return *this; }
}

SP>>class MyObject {
SP>>    int _v;
SP>>    public: MyObject setField(int v)&& { this->_v = v; return *this; }
SP>>}
SP>>

#include <string>
#include <cstdio>

using namespace std;

class MyObject {
    int _v;
    public: MyObject setField(int v)&& { this->_v = v; return *this; }
};

int main() {
    auto m = MyObject().setField(1); // ok

    auto m2 = MyObject();
    m2.setField(1); //  error: 'this' argument to member function 'setField' is an lvalue, but function has rvalue ref-qualifier
}

_NN>#include <string>
_NN>#include <cstdio>

_NN>using namespace std;

_NN>class MyObject {
_NN>    int _v;
_NN>    public: MyObject setField(int v)&& { this->_v = v; return *this; }
_NN>};

_NN>int main() {
_NN>    auto m = MyObject().setField(1); // ok

_NN>    auto m2 = MyObject();
_NN>    m2.setField(1); //  error: 'this' argument to member function 'setField' is an lvalue, but function has rvalue ref-qualifier
_NN>}
_NN>

...
auto m2 = m.setField(2);

const auto m = MyObject().setField1(1).setField2(2).setField3(3);

const auto anotherObj = m.copy().setField1(10);

fn main() {
    let strings = vec!["tofu", "93", "18"];
    let (numbers, errors): (Vec<_>, Vec<_>) = strings
        .into_iter()
        .map(|s| s.parse::<i32>())
        .partition(Result::is_ok);
    errors.map(|e| println!("Error: {0}", e););
}

SP>const auto m = MyObject().setField1(1).setField2(2).setField3(3);
SP>

const auto m = MyObject(1, 2, 3);

auto m_temp = MyObject().setField1(1).setField2(2);
const auto m = (conditional_expression) ? m_temp.setField3(17) : m_temp.setField4(42);
return m;

SP>const auto anotherObj = m.copy().setField1(10);
SP>

SP>fn main() {
SP>    let strings = vec!["tofu", "93", "18"];
SP>    let (numbers, errors): (Vec<_>, Vec<_>) = strings
SP>        .into_iter()
SP>        .map(|s| s.parse::<i32>())
SP>        .partition(Result::is_ok);
SP>    errors.map(|e| println!("Error: {0}", e););
SP>}
SP>

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

public static Func<T2, R> FixX<T1, T2, R>(Func<T1, T2, R> f, T1 x) => (T2 y) => f(x, y);


public static int Main()
{
  var encapsulated = AddX(3); // объединили функцию и значение
  Console.WriteLine(encapsulated(42));
  
  var enc2 = FixX(Add, 5);  // объединили функцию и значение
  Console.WriteLine(enc2(17));
}

return new User()
   .withName('Коля')
   .withEmail('коля+2024@гемайл.ком')
   .withImage('data:image/png;base64,...')

P>>>return new User()
P>>>   .withName('Коля')
P>>>   .withEmail('коля+2024@гемайл.ком')
P>>>   .withImage('data:image/png;base64,...')
P>>>

public void ExampleMethod(int required, string optionalstr = "default string",
    int optionalint = 10)

[q]
Если вы знаете имя третьего параметра, можете использовать для выполнения задачи именованный аргумент.

anExample.ExampleMethod(3, optionalint: 4);

Form {
   header: {content: aaa} 
   main: { 
     list: [
      ItemA {id: 'a', content: yyy },
      ItemB {id: 'a', content: zzz },
    ]
   },
   footer: OkCancelFooter {onOk: onOkHandler, onCancel: onCancelHandler, onDispose: onDisposeHandler}
}

Form form = new() {
   header: new() {content: aaa} 
   main= new() { 
    list new(){
      ItemA = new() {id= 'a', content= yyy },
      ItemB = new() {id= 'a', content= zzz },
   }
   },
   footer= OkCancelFooter {onOk= onOkHandler, onCancel= onCancelHandler, onDispose= onDisposeHandler}
}

Form form = new() {
   header: new(content: aaa)
   main= new() { 
    list new(){
      ItemA = new(id: 'a', content: yyy ),
      ItemB = new(id: 'a', content: zzz ),
   }
   },
   footer= OkCancelFooter {onOk = onOkHandler, onCancel= onCancelHandler, onDispose= onDisposeHandler}
}

P>Подозреваю, я xaml попробовал задолго до того, как вы про него узнали Не впечатлил — громоздко, многословно, тормозно

S>>Form form = new() {
S>>   header: new(content: aaa)
S>>   main= new() { 
S>>    list new(){
S>>      ItemA = new(id= 'a', content= yyy ),
S>>      ItemB = new(id= 'a', content= zzz ),
S>>   }
S>>   },
S>>   footer= OkCancelFooter {onOk = onOkHandler, onCancel= onCancelHandler, onDispose= onDisposeHandler}
S>>}
S>>

 list = new List<object>

P>[
P>      ItemA {id: 'a', content: yyy },
P>      ItemB {id: 'a', content: zzz },
P>]
P>

      new ItemA() {id= 'a', content= yyy },
      new ItemB() {id= 'a', content= zzz },

      new ItemA(id: 'a', content: yyy),
      new ItemB(id: 'a', content: zzz ),

struct A {
    void non_const() { }

    void const_() const { }

    void ref() & { }
    
    void rvalue_ref() && { }

    void ref_const() const & { }

    void rvalue_ref_const() const && { }
};

int main()
{
    // ------
    // lvalue
    A lvalue;
    
    lvalue.non_const();
    lvalue.const_();
    lvalue.ref();
    // lvalue.rvalue_ref(); // Error
    lvalue.ref_const();
    //lvalue.rvalue_ref_const(); // Error

    // -----
    // const lvalue
    const A const_lvalue;
    
    // const_lvalue.non_const(); // Error
    const_lvalue.const_();
    // const_lvalue.ref(); // Error
    // const_lvalue.rvalue_ref(); // Error
    const_lvalue.ref_const();
    // const_lvalue.rvalue_ref_const(); // Error

    // -----
    // rvalue
    A().non_const();
    A().const_();
    // A().ref(); // Error
    A().rvalue_ref();
    A().ref_const();
    A().rvalue_ref_const(); // Error

    // -----
    A&& rvalue = A();

    rvalue.non_const();
    rvalue.const_();
    rvalue.ref();
    // rvalue.rvalue_ref(); // Error
    rvalue.ref_const();
    // rvalue.rvalue_ref_const(); // Error   

    // -----
    const A&& const_rvalue = A();

    // const_rvalue.non_const(); // Error
    const_rvalue.const_();
    // const_rvalue.ref(); // Error
    // const_rvalue.rvalue_ref(); // Error
    const_rvalue.ref_const();
    // const_rvalue.rvalue_ref_const(); // Error   
}