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

Вот помню я программировал на Фортране, Паскале (не Турбо). Там никакого ООП не было. Только процедурное программирование. Но было состояние. Глобальные переменные и переменные функции и параметры.
Которые в огромном количестве передавались из метода в метод.
Что бы не таскать переменные через параметры, решили передавать через ссылку на структуру.
А затем, зачем нам передавать явно, давай прикрутим методы к структуре, а 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););
}