OOP is not that bad(osa1.net)

    def managedLogger(init: Logger): (IO Logger, Logger => IO ()) = {
        val ref = Ref.make(init)
        (ref.get, ref.set)
    }

  typedef struct {
      // Private stuff, do not rely on it
      int   bar;
      float baz;
  } foo_ctx;

  int  foo_init      (foo_ctx *ctx);
  void foo_cleanup   (foo_ctx *ctx);
  int  foo_frobnicate(foo_ctx *ctx, int frobnicator);

  struct foo_ctx;  // forward declare
  typedef struct foo_ctx foo_ctx;

  foo_ctx *foo_new       ();
  void     foo_delete    (foo_ctx *ctx);
  int      foo_frobnicate(foo_ctx *ctx, int frobnicator);

  typedef struct { int bar;  float baz; } foo;
  int  init      (foo *this);
  void cleanup   (foo *this);
  int  frobnicate(foo *this, int frobnicator);

   x = [1,2,3,4,5,6,7,8]
   even = [i for i in x if x%2 == 0]
   

  s = max(x) + min(x)
  res = reduce(lambda acc, y: acc + y, x, 0) 

   gg = (x) => x * x * x

   y = 1
   a = (x) => x + 1
   b = (x) => x * 2
   c = (x) => x * x
   d = (x) => x - 4
   f = a . b . c . d
   
   result = f(y)

   class Domain1
      constructor(n: int)
          this.x = n

      def gg()
         this.x *= this.x * this.x      

      def getX() -> int
         return this.x

   class Domain2:
      constructor(n: int)
          this.x = n
      
      def a:
          this.x += 1

      def b:
          this.x *= 2

      def c:
          this.x *= this.x

      def d:
          this.x -= 4

      def f:
         this.a()
         this.b()
         this.c()
         this.d()

      def getX() -> int
         return this.x

  state = Domain(1)
  state.f()
  result = state.getX()   

         

      domain3 = gg . d . a


      #Note I use the fucntion composition operator which means: a . b = (x) => b(a(x)) or a . b . c = (x) => c(b(a(x)))

    ModulaA.funcA
    ModuleB.funcB

    In this post I use the word “OOP” to mean programming in statically-typed language with:
    
    - Classes, that combine state and methods that can modify the state.
    - Inheritance, which allows classes to reuse state and methods of other classes.
    - Subtyping, where if a type B implements the public interface of type A, values of type B can be passed as A.
    - Virtual calls, where receiver class of a method call is not determined by the static type of the receiver but it’s runtime type.