Simon Richardson SimonRichardson

## invariant-issue.hx
package ;

using Main.ListTypes;
using Main.Tuple2Types;

enum ListType<T> {
    Nil;
    Cons(head : T, tail : List<T>);
}

## CaseClass.hx
package ;

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

@:remove @:autoBuild(CaseClassImpl.build())
extern interface CaseClass {}

class CaseClassImpl {

## Lens.hx
class Test {
    static function main(){
        var a = Cons(1, Nil);
        trace(a);
        trace(ListLens.mutate(a, 2));
        trace(a);

        /*
        Output from the above traces - this is dangerous ;-)


## Isolates.hx
package ;

@:remove
@:autoBuild(IsolateTypes.build())
extern interface Isolate {}

class Isolates {

    private static var _isolates : Array<Class<Isolate>> = [];

## Test.hx
class Test {
    static function main(){
        var val0 : A<Int> = a(1); // This is fine.
        trace(val0);
        var val1 : A<A<Int>> = a(a(1)); // This fails.
        trace(val1);
    }
}
enum AType<T> {
    a(v : T);

## throwing-enums.hx
class Test {
  static function main(){
    try {
      //throw a(1);
        throw b('1');
    } catch (e : A) {
        trace(e);
    } catch (e : B) {
        trace(e);
    }

## do-if.hx
// I think this should be valid syntax
do remove() if (once());

// which is similar to
do remove() while(once());


## Promise.js
var Promise = require('fantasy-promises');

/**
   ## isPromise(a)

   Returns `true` if `a` is `Promise`.
**/
var isPromise = isInstanceOf(Promise);

bilby = bilby

## Istanbul.js
// I've got quite a convoluted example, but it boils down to this, sort of.
(function(global){

  function functionName(f) {
    return f._name || f.name; // In istanbul this actually comes back as being not tested, even though it is.
  }

  global.functionName = functionName;
})(this);

## squishy-pants-gadt.js
var a = _.List(_.Some(_.Right(1)), _.Some(_.Left('Error')));
var result = a.match({
  Some: {
      Right: partial(
          function(a) {
              return a == 1;
          },
          _.identity
      ),
      Right: _.constant(-1),
	package ;

	using Main.ListTypes;
	using Main.Tuple2Types;

	enum ListType<T> {
	Nil;
	Cons(head : T, tail : List<T>);
	}
	package ;

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

	@:remove @:autoBuild(CaseClassImpl.build())
	extern interface CaseClass {}

	class CaseClassImpl {
	class Test {
	static function main(){
	var a = Cons(1, Nil);
	trace(a);
	trace(ListLens.mutate(a, 2));
	trace(a);

	/*
	Output from the above traces - this is dangerous ;-)
	package ;

	@:remove
	@:autoBuild(IsolateTypes.build())
	extern interface Isolate {}

	class Isolates {

	private static var _isolates : Array<Class<Isolate>> = [];
	class Test {
	static function main(){
	var val0 : A<Int> = a(1); // This is fine.
	trace(val0);
	var val1 : A<A<Int>> = a(a(1)); // This fails.
	trace(val1);
	}
	}
	enum AType<T> {
	a(v : T);
	class Test {
	static function main(){
	try {
	//throw a(1);
	throw b('1');
	} catch (e : A) {
	trace(e);
	} catch (e : B) {
	trace(e);
	}
	// I think this should be valid syntax
	do remove() if (once());

	// which is similar to
	do remove() while(once());
	var Promise = require('fantasy-promises');

	/**
	## isPromise(a)

	Returns `true` if `a` is `Promise`.
	**/
	var isPromise = isInstanceOf(Promise);

	bilby = bilby
	// I've got quite a convoluted example, but it boils down to this, sort of.
	(function(global){

	function functionName(f) {
	return f._name \|\| f.name; // In istanbul this actually comes back as being not tested, even though it is.
	}

	global.functionName = functionName;
	})(this);
	var a = _.List(_.Some(_.Right(1)), _.Some(_.Left('Error')));
	var result = a.match({
	Some: {
	Right: partial(
	function(a) {
	return a == 1;
	},
	_.identity
	),
	Right: _.constant(-1),