nadako

NOTE: This gist was added to the official building manual and will be updated there from now on: https://haxe.org/documentation/introduction/building-haxe.html

Preparation

• Uninstall OCaml, MinGW, Cygwin
• Remove leftover environment vars, cleanup PATH

Installation

• Download 32-bit installer from the fdopen's fork: https://fdopen.github.io/opam-repository-mingw/installation/
• Install it, in Cygwin package selection also check mingw64-i686-zlib (used by Haxe). You might need to switch "View" in top-right corner to "Not Installed" to see it in the list.

back2dos

#if macro
  import haxe.macro.Expr;
  import haxe.macro.Type;
  import haxe.macro.Context.*;
#else
  @:genericBuild(AnonEnum.build())
#end

class AnonEnum<Const> {
  macro static function build():Type {

domenic

Auto-deploying built products to gh-pages with GitHub Actions

This is a set up for projects which want to check in only their source files, but have their gh-pages branch automatically updated with some compiled output every time they push.

A file below this one contains the steps for doing this with Travis CI. However, these days I recommend GitHub Actions, for the following reasons:

• It is much easier and requires less steps, because you are already authenticated with GitHub, so you don't need to share secret keys across services like you do when coordinate Travis CI and GitHub.
• It is free, with no quotas.
• Anecdotally, builds are much faster with GitHub Actions than with Travis CI, especially in terms of time spent waiting for a builder.

nadako

/**
 * Simple wrapper for anonymous structures that are meant to be used as a
 * keyed collection of objects of the same type (i.e. json object).
 *
 * Wraps Reflect calls with nice syntax and static typing without any
 * runtime overhead.
 */
abstract DynamicMap<V>(Dynamic<V>) from Dynamic<V>
{
    /**

dpeek

import haxe.macro.Expr;

class FTW
{
	public static function build()
	{
		return haxe.macro.Context.getBuildFields().map(transformField);
	}

	static function transformField(field:Field)

alehandrof

comment
comment punctuation
comment.block.documentation
comment.block.preprocessor
comment.documentation
constant
constant.character
constant.character punctuation
constant.character.entity
constant.character.escape

back2dos

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

class Build {
	static public function types() {
		var pos = Context.currentPos();
		function mkPath(name:String):TypePath {
			var parts = name.split('.');
			return {
				sub: null,

andyli

import haxe.macro.Context;
import haxe.macro.Expr;
import haxe.macro.Type;
using Lambda;

/**
	Old school abstract class.
	Classes that implements it, and their sub-classes, will be able to declare abstract methods (methods that without body).
	There will be a check in compile-time such that no public constructor is allowed without all abstract methods implemented.
*/

Yaffle

/*jslint regexp: true, maxerr: 50, indent: 2 */
 
(function (global) {
  "use strict";
  
  function URLUtils(url, baseURL) {
    var m = String(url).replace(/^\s+|\s+$/g, "").match(/^([^:\/?#]+:)?(?:\/\/(?:([^:@\/?#]*)(?::([^:@\/?#]*))?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
    if (!m) {
      throw new RangeError();
    }