Bu sefer aşağıdakileri karaladık.

Ali

/*

  DDili sohbet - 15 Mayıs 2022

  - SumTypes

  - ImportC (artık D derleyicisi preprocessorlık da yapıyor)

  - ImportC sayesinde bitfields D'ye de geldi (betterC'ye geldi)

  - DConf
  Ali'nin fikirleri:
  -- ImportC kullanım örnekleri

  -- Back to Basics (lvalue vs. rvalue VEYA kullanım kolaylıkları (lowerings --> for döngüsü yerine foreach yerine aralıklar))

  -- Andrei'nin önerisi: Phobos'ta perde arkası + Ali'nin .cached algoritması

  - Popüler değil

  - async/await

  Future!int yarinHava = async_foo("havadurumu.com");
//   Promise!int yarinHava = async_foo("havadurumu.com");
  // ...
  // ...
  // ...
  try/catch -> Masraflı
  mutex -> Masraflı
  synchronized -> Masraflı
  vs.

  writeln(yarinHava.await);  // Ya hazır ya da bekleyecek

*/

/+
import std;

union U {
  int i;
  string s;
  double d;
}

struct ___SSSSS {
  size_t length;
  char* ptr;
}


void main() {
  auto u = U(42);
  u.d = 1.5;
  writeln(u.s.length);
}
+/





/+
import std.variant;
import std.stdio;


void main() {
  Variant a; // Must assign before use, otherwise exception ensues
  // Initialize with an integer; make the type int
  Variant b = 42;
  writeln(b.type); // typeid (int)
  // Peek at the value
  assert(b.peek!(int) !is null && *b.peek!(int) == 42);
  // Automatically convert per language rules
  auto x = b.get!(real);

  // Assign any other type, including other variants
  a = b;
  a = 3.14;
  writeln(a.type); // typeid (double)
  // Implicit conversions work just as with built-in types
  assert(a < b);
  // Check for convertibility
  assert(!a.convertsTo!(int)); // double not convertible to int
  // Strings and all other arrays are supported
  a = "now I'm a string";
  writeln(a); // "now I'm a string"

  auto l = (int i) => i * 2;
  a = l;
  writeln((*a.peek!(typeof(l)))(42));
}
+/





/+
import std.variant;

struct S {
  int i;
  string isim;
}

void main() {
  auto v = Algebraic!(int, double, string, S)(5);
  assert(v.peek!(int));
  v = 3.14;
  assert(v.peek!(double));

  import std.stdio;
  writeln(v);
  // auto x = v.peek!(long); // won't compile, type long not allowed
  // v = '1'; // won't compile, type char not allowed

  v = S(42, "ali");
  writeln(v);
}
+/












/+ SumType is a generic discriminated union implementation
that uses design-by-introspection to generate safe and
efficient code. Its features include:

    Pattern matching.
    Support for self-referential types.
    Full attribute correctness (pure, @safe, @nogc, and nothrow are inferred whenever possible).
    A type-safe and memory-safe API compatible with DIP 1000 (scope).
    No dependency on runtime type information (TypeInfo).
    Compatibility with BetterC.
+/

/+
import std.math.operations : isClose;

import std.sumtype;

void main() {
  struct Fahrenheit { double degrees; }
  struct Celsius { double degrees; }
  struct Kelvin { double degrees; }

  alias Temperature = SumType!(Fahrenheit, Celsius, Kelvin);

  // Construct from any of the member types.
  Temperature t1 = Fahrenheit(98.6);
  Temperature t2 = Celsius(100);
  Temperature t3 = Kelvin(273);

  // Use pattern matching to access the value.
  Fahrenheit toFahrenheit(Temperature t)
  {
    return Fahrenheit(
      t.match!(
        (Fahrenheit f) => f.degrees,
        (Celsius c) => c.degrees * 9.0/5 + 32,
        (Kelvin k) => k.degrees * 9.0/5 - 459.4
               )
                      );
  }

  const hassasiyet = 0.5;

  assert(toFahrenheit(t1).degrees.isClose(98.6, hassasiyet));
  assert(toFahrenheit(t2).degrees.isClose(212));
  assert(toFahrenheit(t3).degrees.isClose(32));

  // Use ref to modify the value in place.
  void freeze(ref Temperature t)
  {
    t.match!(
      (ref Fahrenheit f) => f.degrees = 32,
      (ref Celsius c) => c.degrees = 0,
      (ref Kelvin k) => k.degrees = 273
             );
  }

  freeze(t1);
  assert(toFahrenheit(t1).degrees.isClose(32));

  // Use a catch-all handler to give a default result.
  bool isFahrenheit(Temperature t)
  {
    return t.match!(
      (Fahrenheit f) => true,
      _ => false
                    );
  }

  assert(isFahrenheit(t1));
  assert(!isFahrenheit(t2));
  assert(!isFahrenheit(t3));

  import std.stdio;
  writeln(t2);
  writeln(t3);
}
+/





/+

// https://dconf.org/2016/talks/clugston.html

/*

"to scale"

   +     +─────────+─────────+   ...   +   ...   +─────────+─────────+     +
   │   -max       -1         │         0         │         1        max    │
   │                         │                   │     │
-infinity               -min_normal          min_normal infinity

*/

import std.stdio;

void main() {
  long i = long.max - 1;
  writeln(i);

  double d = i;  // !!!!!!!!!!!!!!!!!!!
  // i = d;
  d *= 100;

  double d2 = d + 200000;
  writefln!"%f"(d);
  writefln!"%f"(d2);
  writeln(d2 - d);
  writeln(ulong(2) ^^ 18);

  writeln("merhaba\377dunya");
  // float
  //   double
  //   real
  //   char.init
  //   wchar
  //   dchar
}
+/








/+
import std.sumtype;
import std.stdio;
import std.functional : partial;
import std.traits : EnumMembers;
import std.typecons : Tuple;

void main() {
  enum Op : string
    {
      Plus  = "+",
      Minus = "-",
      Times = "*",
      Div   = "/"
    }

  /*
struct İşlem {
  Op op;
  İşlem* lhs;
  İşlem* rhs;
}
  */

  // An expression is either
  //  - a number,
  //  - a variable, or
  //  - a binary operation combining two sub-expressions.
  alias Expr = SumType!(
    double, // 0
    string, // 1
    Tuple!(Op, "op", This*, "lhs", This*, "rhs") // 2
                        );

  // Shorthand for Tuple!(Op, "op", Expr*, "lhs", Expr*, "rhs"),
  // the Tuple type above with Expr substituted for This.
  alias BinOp = Expr.Types[2];

  // Factory function for number expressions
  Expr* num(double value)
  {
    return new Expr(value);
  }

  // Factory function for variable expressions
  Expr* var(string name)
  {
    return new Expr(name);
  }

  // Factory function for binary operation expressions
  Expr* binOp(Op op, Expr* lhs, Expr* rhs)
  {
    return new Expr(BinOp(op, lhs, rhs));
  }

  // Convenience wrappers for creating BinOp expressions
  alias sum  = partial!(binOp, Op.Plus);
  alias diff = partial!(binOp, Op.Minus);
  alias prod = partial!(binOp, Op.Times);
  alias quot = partial!(binOp, Op.Div);

  /*
   // partial şurada: https://dlang.org/library/std/functional.html

   // Ali'nin farklı yazımı:

  Expr* sum(Expr* lhs, Expr* rhs) {
    return new binOp(Op.Plus, lhs, rhs);
  }
*/

  // Evaluate expr, looking up variables in env
  double eval(Expr expr, double[string] env)
  {
    return expr.match!(
      (double num) => num,
      (string var) => env[var],
      (BinOp bop)
      {
        double lhs = eval(*bop.lhs, env);
        double rhs = eval(*bop.rhs, env);
        final switch (bop.op)
        {
          // Thank you, Timon Gehr!
          static foreach (op; EnumMembers!Op)
          {
          case op:
            return mixin("lhs" ~ op ~ "rhs");
          }
        }
      }
    );
  }

  // Return a "pretty-printed" representation of expr
  string pprint(Expr expr)
  {
    import std.format : format;

    return expr.match!(
      (double num) => "%g".format(num),
      (string var) => var,
      (BinOp bop) => "(%s %s %s)".format(
        pprint(*bop.lhs),
        cast(string) bop.op,
        pprint(*bop.rhs)
       )
     );
  }

  Expr* myExpr = sum(var("a"), prod(num(2), var("b")));
  double[string] myEnv = ["a":3, "b":4, "c":7];

  writeln(eval(*myExpr, myEnv)); // 11
  writeln(pprint(*myExpr)); // "(a + (2 * b))"
}
+/





/+
import std;

void main() {
  auto a = tuple(42, "merhaba");

  static foreach (i, T; typeof(a).expand) {
    writefln!"%s %s"(typeof(T).stringof, a[i]);
  }
}
+/








import std;

void main() {
  // Design by Introspection
  // static if (isRandomAccessRange!R) {
  //   ...
  // }
  writeln(iota(0, 10_000_000, 42).map!(i => i * i).take(3)[2]);
}