Ali Çehreli
Posted in reply to Salih Dincer
| 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]);
}
|