skial

Bluesky's age assurance sucks, here's how to work around it.

Bluesky has implemented age verification measures in response to regional laws that restrict access, prompting users to verify their age through Epic Games' Kids Web Services before they can access adult content.

This sucks, but thankfully there are ways to work around it.

Before diving in: I encourage you to read this entire document, including the

Haxe People on the Fediverse

With the recent rise of alternative social media platforms, the Haxe community will get splintered. This is a compilation of users of the Haxe language who has a presence on these platforms.

Let's do some cppia

Note! Created a repo to replace this gist: https://github.com/cambiata/Haxe-Cppia-Basics Easier to testrun, fork and pr! Thanks, @PDeveloper!

This is a simple testproject created for the single purpose of learning how to use cppia, the scripable "cpp subtarget" for Haxe, created by Hugh Sanderson.

Info about cppia can be found in Hugh's WWX2015 talk (cppia part starts around 15:45).

Please note that this is WORK IN PROGRESS, and that I haven't yet found out to create a working cppia host..! Please step in with discussion and contributions!

	/**
	* ObjectPool is a type building macro to create array-of-structure or structure-of-array pools.
	* With the intention being to improve access performance, both in CPU cache coherence and by avoiding the GC
	*
	* This implementation is a minimal working proof of concept
	*
	* Improvements you may want to make
	* - Support deallocation of instances and space reclaiming
	* - Replace haxe.io.Bytes because field access has overhead
	*

	Mute these words in your settings here: https://twitter.com/settings/muted_keywords

	ActivityTweet
	generic_activity_highlights
	generic_activity_momentsbreaking
	RankedOrganicTweet
	suggest_activity
	suggest_activity_feed
	suggest_activity_highlights
	suggest_activity_tweet


	https://github.com/HaxeFoundation/hashlink/tree/master/other/benchs

	[Benchmark]
	└─ [target] [buildtime] : [runtime]

	---

	OS: Arch Linux x86_64
	Kernel: 4.17.2-1-ARCH

	import haxe.macro.Context;
	import haxe.macro.Expr;
	import haxe.macro.TypeTools;

	#if !macro
	@:genericBuild(PartialMacro.build())
	#end
	class Partial<T> {}

	class PartialMacro {

	import haxe.macro.Context;
	import haxe.macro.Expr;

	class Macros {

	macro public static function autoInt():Array<Field> {
	var fields = Context.getBuildFields();

	var t = switch(Context.getLocalClass().get().kind) {
	case KAbstractImpl(c):

	// In a build system, I like to pass typed compile-time constants to my code
	// via compiler defines. For example, a host String and a port Int. The
	// following macros provide functionality to either parse or eval a compiler
	// define as Haxe code. Since they operate at compile time and inject the
	// resulting expressions into your code, this retains all type features --
	// from type inference to type checking.
	//
	// Note that $type prints the type at compile time, while trace prints
	// the value at runtime. Neko is called simply to demonstrate the latter.
	import haxe.macro.Context;

	import haxe.ds.Either;

	abstract OneOf<A, B>(Either<A, B>) from Either<A, B> to Either<A, B> {
	@:from inline static function fromA<A, B>(a:A) : OneOf<A, B> return Left(a);
	@:from inline static function fromB<A, B>(b:B) : OneOf<A, B> return Right(b);

	@:to inline function toA():Null<A> return switch(this) {case Left(a): a; default: null;}
	@:to inline function toB():Null<B> return switch(this) {case Right(b): b; default: null;}
	}