crazymonkyyy

tranactional api

adr said sometin about db trasactions not thinking it was possible

I thought this was the goal:

with(db.transaction){
  foo(1);//transaction.foo(1) but doesnt do it yet
  bar(3);//transaction.bar(3) but does it cause spooky
}

Theory

This is a document for producing a "one shot" project from a SPEC. While there should exist some other md document detailing WHAT to produce, this shall be a document detailing HOW.

The HOW is made up of 3 thoerys:

aggressive Test Driven Development
Distrust of AI output
Compilers, type theory and APIs are king

TTD

Humans can debate if its worthwhile to write a line of tests for every line of code, maybe human time is more valuable then that and you can trust them some. You are an AI AGENT, your time is NOT valuable. Your production to test ratio can be 100:1 if not more. GET CLANKING CLANKER. Never complain about testing being enough. Never be confident how something works without a code sample that the compiler verifying your correct about.

	#!opend -mixin=mix -unittest -main -run app.d
	import std;
	auto toiter(R)(/ref/R r) if (isInputRange!R){
	return (int delegate(ref ElementType!R) dg){
	int ret;
	while( ! r.empty){
	ret=dg(r.front);
	r.popFront;
	if(ret){return ret;}
	}

	import std;
	import core.vararg;

	struct Foo{
	bool b;
	int[4] bar;
	float f;
	string s;
	}
	auto ref hardcast(T, S)(auto ref S s) => (cast(T)(&s));

	import std;
	import core.stdc.stdlib;
	import core.sys.posix.dlfcn;
	version(D_OpenD){
	enum compiler="opend -shared -of=";
	} else {
	version(DigitalMars) enum compiler="dmd -shared -of=";
	version(LDC) enum compiler="ldc -shared -of=";
	}
	//unittest{

	--- meta.d
	import std;
	alias seq(T...)=T;
	template appendable(discrim...){
	enum ptr_=cast(immutable(void)*)[0].ptr;
	auto poke()=>((cast(int)ptr_))++;
	auto count()=>((cast(int)ptr_));
	template store(int i){
	template store(T=void,T[] data=null){
	alias store=typeof(data[0]);

	/*
	run dlang.io like gists

	the `--- foo.d` thing
	*/

	import std;
	enum tempfolder=".__gist/";
	auto dropmap(alias F,R)(R r,int i){
	foreach(j;0..i){

	--- bar.d
	enum hotload; @hotload:
	void foo(){}
	float bar(){return 3.14;}

	enum hotloadstop; @hotloadstop:
	void foobar(){}

	--- foo.d
	import std;

	/*
	lazy hotload: hot reload a single function file, depends on opend imports

	kinda dumb, dont expect templates, changing headers or anything to work

	pass relivtivepath filename without the `.d`
	*/

	import core.stdc.stdlib;
	import core.sys.posix.dlfcn;

	template mkytemp(T,T[] fakedata=null){//my favorate bug
	alias mkytemp=typeof(fakedata[0]);
	}
	unittest{ //verifing the bug still exists
	static assert(is(mkytemp!int==int));
	static assert(is(mkytemp!float==int));// <- spooky
	}
	/*the ast is modified live, so the T[] is defined and doesnt get properly "unset",
	null and typeof just glue to make it work nicely; the effect is in the header at the callsite
	DO NOT REPORT