nadako

@:remove
@:autoBuild(SkipSerializeMacro.build())
interface ISkipSerialize {}

nadako

class Main {
    static function main() {
        var event:MapChangeEvent<Map<String,Int>>;
        $type(event.key); // String
        $type(event.value); // Int
    }
}

nadako

   /**
        Хеширование строки
    **/
    public static function hash(key:String):Int {
        // простейший алгоритм djb2

        inline function cca(s:String, i:Int):Int {
            // наиболее быстрое и небезопасное получение кода символа
            #if js
            return (untyped s).charCodeAt(i);

nadako

import StructHelper.make;

typedef A = {
    a:Int,
    b:String,
    c:Float,
    d:Bool,
    e:Array<Int>,
    f:{
        g:Array<Bool>,

nadako

@:dce
@:genericBuild(EitherMacro.build())
class Either<Rest> {}

nadako

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

class EnumComparisonMacro {
    static function build() {
        // get ComplexType for the abstract we're building
        var t = switch(Context.getLocalType()) {
            case TInst(_.get() => {kind: KAbstractImpl(_.get() => ab)}, _): TPath({pack: ab.pack, name: ab.name});
            case _: throw false;
        }

nadako

class Main {
    static function main() {
        var a = getValue();
    }

    static function getValue():Tuple<Bool,Int> {
        return new Tuple(true, 10);
    }
}

nadako

class Main {
	static function main() {
		var signal = new Signal<Int,String>();
		var conn = signal.connect(function(a, b) {
			trace('Well done $a $b');
		});
		signal.dispatch(10, "lol");
	}
}

nadako

import haxe.macro.Context;
import haxe.macro.Type;

using haxe.macro.Tools;

class CheckMutating {
    static var metaToRemove:Array<MetaAccess>;

    static function use() {
        Context.onGenerate(function(types) {

nadako

#if macro
import haxe.macro.Context;
import haxe.macro.Expr;
using haxe.macro.Tools;
#end

@:enum abstract MyEnum<T>(T) {}
typedef A = MyEnum<Float>;
typedef B = Array<{a:Int, ?b:Array<{?a:String}>}>;
typedef C = Dynamic<Int>;