language: haxe

filename: LearnHaxe3.hx

contributors:

- ["Justin Donaldson", "https://github.com/jdonaldson/"]

- ["Dan Korostelev", "https://github.com/nadako/"]

[Haxe](https://haxe.org/) is a general-purpose language that provides platform support for C++, C#,

Swf/ActionScript, JavaScript, Java, PHP, Python, Lua, HashLink, and Neko bytecode

(the latter two being also written by the Haxe author). Note that this guide is for

Haxe version 3. Some of the guide may be applicable to older versions, but it is

recommended to use other references.

```csharp

package; // empty package, no namespace.

import haxe.ds.ArraySort;

import haxe.ds.*;

import Lambda.array;

import Math.*;

using StringTools;

typedef FooString = String;

typedef FooObject = { foo: String };

class LearnHaxe3 {

/*

static function main() {

/*

trace("Hello World, with trace()!");

// Trace can handle any type of value or object. It will try to print

// a representation of the expression as best it can. You can also

// concatenate strings with the "+" operator:

trace("Integer: " + 10 + " Float: " + 3.14 + " Boolean: " + true);

// In Haxe, it's required to separate expressions in the same block with

// semicolons. But, you can put two expressions on one line:

trace('two expressions..'); trace('one line');

//////////////////////////////////////////////////////////////////

// Types & Variables

//////////////////////////////////////////////////////////////////

trace("***Types & Variables***");

// You can save values and references to data structures using the

// "var" keyword:

var an_integer:Int = 1;

trace(an_integer + " is the value for an_integer");

/*

var another_integer = 2;

trace(another_integer + " is the value for another_integer");

// The $type() method prints the type that the compiler assigns:

$type(another_integer);

// You can also represent integers with hexadecimal:

var hex_integer = 0xffffff;

/*

// Strings can have double or single quotes.

var a_string = "some" + 'string';

trace(a_string + " is the value for a_string");

// Strings can be "interpolated" by inserting variables into specific

// positions. The string must be single quoted, and the variable must

// be preceded with "$". Expressions can be enclosed in ${...}.

var x = 1;

var an_interpolated_string = 'the value of x is $x';

var another_interpolated_string = 'the value of x + 1 is ${x + 1}';

// Strings are immutable, instance methods will return a copy of

// parts or all of the string. (See also the StringBuf class).

var a_sub_string = a_string.substr(0,4);

trace(a_sub_string + " is the value for a_sub_string");

// Regexes are also supported, but there's not enough space here to go

// into much detail.

var re = ~/foobar/;

trace(re.match('foo') + " is the value for (~/foobar/.match('foo')))");

// Arrays are zero-indexed, dynamic, and mutable. Missing values are

// defined as null.

var a = new Array<String>(); // an array that contains Strings

a[0] = 'foo';

trace(a.length + " is the value for a.length");

a[9] = 'bar';

trace(a.length + " is the value for a.length (after modification)");

trace(a[3] + " is the value for a[3]"); //null

// Arrays are *generic*, so you can indicate which values they contain

// with a type parameter:

var a2 = new Array<Int>(); // an array of Ints

var a3 = new Array<Array<String>>(); // an Array of Arrays (of Strings).

// Maps are simple key/value data structures. The key and the value

// can be of any type.

// Here, the keys are strings, and the values are Ints:

var m = new Map<String, Int>();

m.set('foo', 4);

// You can also use array notation:

m['bar'] = 5;

trace(m.exists('bar') + " is the value for m.exists('bar')");

trace(m.get('bar') + " is the value for m.get('bar')");

trace(m['bar'] + " is the value for m['bar']");

var m2 = ['foo' => 4, 'baz' => 6]; // Alternative map syntax

trace(m2 + " is the value for m2");

// Remember, you can use type inference. The Haxe compiler will

// decide the type of the variable the first time you pass an

// argument that sets a type parameter.

var m3 = new Map();

m3.set(6, 'baz'); // m3 is now a Map<Int,String>

trace(m3 + " is the value for m3");

// Haxe has some more common datastructures in the haxe.ds module, such

// as List, Stack, and BalancedTree.

//////////////////////////////////////////////////////////////////

// Operators

//////////////////////////////////////////////////////////////////

trace("***OPERATORS***");

// basic arithmetic

trace((4 + 3) + " is the value for (4 + 3)");

trace((5 - 1) + " is the value for (5 - 1)");

trace((2 * 4) + " is the value for (2 * 4)");

// Division always produces Floats.

trace((8 / 3) + " is the value for (8 / 3) (a Float)");

trace((12 % 4) + " is the value for (12 % 4)");

// basic comparison

trace((3 == 2) + " is the value for 3 == 2");

trace((3 != 2) + " is the value for 3 != 2");

trace((3 > 2) + " is the value for 3 > 2");

trace((3 < 2) + " is the value for 3 < 2");

trace((3 >= 2) + " is the value for 3 >= 2");

trace((3 <= 2) + " is the value for 3 <= 2");

// standard bitwise operators

/*

var i = 0;

trace("Pre-/Post- Increments and Decrements");

trace(i++); // i = 1. Post-Increment

trace(++i); // i = 2. Pre-Increment

trace(i--); // i = 1. Post-Decrement

trace(--i); // i = 0. Pre-Decrement

//////////////////////////////////////////////////////////////////

// Control Structures

//////////////////////////////////////////////////////////////////

trace("***CONTROL STRUCTURES***");

// if statements

var j = 10;

if (j == 10) {

trace("this is printed");

} else if (j > 10) {

trace("not greater than 10, so not printed");

} else {

trace("also not printed.");

}

// there is also a "ternary" if:

(j == 10) ? trace("equals 10") : trace("not equals 10");

// Finally, there is another form of control structure that operates

// at compile time: conditional compilation.

#if neko

trace('hello from neko');

#elseif js

trace('hello from js');

#else

trace('hello from another platform!');

#end

// The compiled code will change depending on the platform target.

// Since we're compiling for neko (-x or -neko), we only get the neko

// greeting.

trace("Looping and Iteration");

// while loop

var k = 0;

while (k < 100) {

// trace(counter); // will print out numbers 0-99

k++;

}

// do-while loop

var l = 0;

do {

trace("do statement always runs at least once");

} while (l > 0);

// for loop

// There is no c-style for loop in Haxe, because they are prone

// to error, and not necessary. Instead, Haxe has a much simpler

// and safer version that uses Iterators (more on those later).

var m = [1, 2, 3];

for (val in m) {

trace(val + " is the value for val in the m array");

}

// Note that you can iterate on an index using a range

// (more on ranges later as well)

var n = ['foo', 'bar', 'baz'];

for (val in 0...n.length) {

trace(val + " is the value for val (an index for n)");

}

trace("Array Comprehensions");

// Array comprehensions give you the ability to iterate over arrays

// while also creating filters and modifications.

var filtered_n = [for (val in n) if (val != "foo") val];

trace(filtered_n + " is the value for filtered_n");

var modified_n = [for (val in n) val += '!'];

trace(modified_n + " is the value for modified_n");

var filtered_and_modified_n

= [for (val in n) if (val != "foo") val += "!"];

trace(filtered_and_modified_n

+ " is the value for filtered_and_modified_n");

//////////////////////////////////////////////////////////////////

// Switch Statements (Value Type)

//////////////////////////////////////////////////////////////////

trace("***SWITCH STATEMENTS (VALUE TYPES)***");

/*

var my_dog_name = "fido";

var favorite_thing = "";

switch (my_dog_name) {

case "fido" : favorite_thing = "bone";

case "rex" : favorite_thing = "shoe";

case "spot" : favorite_thing = "tennis ball";

default : favorite_thing = "some unknown treat";

// same as default:

// case _ : favorite_thing = "some unknown treat";

}

// The "_" case above is a "wildcard" value that will match anything.

trace("My dog's name is " + my_dog_name

+ ", and his favorite thing is a: "

+ favorite_thing);

//////////////////////////////////////////////////////////////////

// Expression Statements

//////////////////////////////////////////////////////////////////

trace("***EXPRESSION STATEMENTS***");

// Haxe control statements are very powerful because every statement

// is also an expression, consider:

// if statements

var k = if (true) 10 else 20;

trace("k equals ", k); // outputs 10

var other_favorite_thing = switch (my_dog_name) {

case "fido" : "teddy";

case "rex" : "stick";

case "spot" : "football";

default : "some unknown treat";

}

trace("My dog's name is " + my_dog_name

+ ", and his other favorite thing is a: "

+ other_favorite_thing);

//////////////////////////////////////////////////////////////////

// Converting Value Types

//////////////////////////////////////////////////////////////////

trace("***CONVERTING VALUE TYPES***");

// You can convert strings to ints fairly easily.

// string to integer

Std.parseInt("0"); // returns 0

Std.parseFloat("0.4"); // returns 0.4

// integer to string

Std.string(0); // returns "0"

// concatenation with strings will auto-convert to string.

0 + ""; // returns "0"

true + ""; // returns "true"

// See documentation for parsing in Std for more details.

//////////////////////////////////////////////////////////////////

// Dealing with Types

//////////////////////////////////////////////////////////////////

/*

var dyn: Dynamic = "any type of variable, such as this string";

/*

untyped {

var x:Int = 'foo'; // This can't be right!

var y:String = 4; // Madness!

}

/*

//////////////////////////////////////////////////////////////////

// Basic Object Oriented Programming

//////////////////////////////////////////////////////////////////

trace("***BASIC OBJECT ORIENTED PROGRAMMING***");

// Create an instance of FooClass. The classes for this are at the

// end of the file.

var foo_instance = new FooClass(3);

// read the public variable normally

trace(foo_instance.public_any

+ " is the value for foo_instance.public_any");

// we can read this variable

trace(foo_instance.public_read

+ " is the value for foo_instance.public_read");

// but not write it; this will throw an error if uncommented:

// foo_instance.public_read = 4;

// trace(foo_instance.public_write); // as will this.

// Calls the toString method:

trace(foo_instance + " is the value for foo_instance");

// same thing:

trace(foo_instance.toString()

+ " is the value for foo_instance.toString()");

// The foo_instance has the "FooClass" type, while acceptBarInstance

// has the BarClass type. However, since FooClass extends BarClass, it

// is accepted.

BarClass.acceptBarInstance(foo_instance);

// The classes below have some more advanced examples, the "example()"

// method will just run them here.

SimpleEnumTest.example();

ComplexEnumTest.example();

TypedefsAndStructuralTypes.example();

UsingExample.example();

}

}

class FooClass extends BarClass implements BarInterface {

public var public_any:Int; // public variables are accessible anywhere

public var public_read (default, null): Int; // enable only public read

public var public_write (null, default): Int; // or only public write

// Use this style to enable getters/setters:

public var property (get, set): Int;

// private variables are not available outside the class.

// see @:allow for ways around this.

var _private:Int; // variables are private if they are not marked public

// a public constructor

public function new(arg:Int) {

// call the constructor of the parent object, since we extended BarClass:

super();

this.public_any = 0;

this._private = arg;

}

// getter for _private

function get_property() : Int {

return _private;

}

// setter for _private

function set_property(val:Int) : Int {

_private = val;

return val;

}

// Special function that is called whenever an instance is cast to a string.

public function toString() {

return _private + " with toString() method!";

}

// this class needs to have this function defined, since it implements

// the BarInterface interface.

public function baseFunction(x: Int) : String {

// convert the int to string automatically

return x + " was passed into baseFunction!";

}

}

class BarClass {

var base_variable:Int;

public function new() {

base_variable = 4;

}

public static function acceptBarInstance(b:BarClass) {}

}

interface BarInterface {

public function baseFunction(x:Int):String;

}

enum SimpleEnum {

Foo;

Bar;

Baz;

}

class SimpleEnumTest {

public static function example() {

// You can specify the "full" name,

var e_explicit:SimpleEnum = SimpleEnum.Foo;

var e = Foo; // but inference will work as well.

switch (e) {

case Foo: trace("e was Foo");

case Bar: trace("e was Bar");

case Baz: trace("e was Baz"); // comment this line to throw an error.

}

/*

switch (e) {

case Foo: trace("e was Foo again");

default : trace("default works here too");

}

}

}

enum ComplexEnum {

IntEnum(i:Int);

MultiEnum(i:Int, j:String, k:Float);

SimpleEnumEnum(s:SimpleEnum);

ComplexEnumEnum(c:ComplexEnum);

}

class ComplexEnumTest {

public static function example() {

var e1:ComplexEnum = IntEnum(4); // specifying the enum parameter

// Now we can switch on the enum, as well as extract any parameters

// it might have had.

switch (e1) {

case IntEnum(x) : trace('$x was the parameter passed to e1');

default: trace("Shouldn't be printed");

}

// another parameter here that is itself an enum... an enum enum?

var e2 = SimpleEnumEnum(Foo);

switch (e2){

case SimpleEnumEnum(s): trace('$s was the parameter passed to e2');

default: trace("Shouldn't be printed");

}

// enums all the way down

var e3 = ComplexEnumEnum(ComplexEnumEnum(MultiEnum(4, 'hi', 4.3)));

switch (e3) {

// You can look for certain nested enums by specifying them

// explicitly:

case ComplexEnumEnum(ComplexEnumEnum(MultiEnum(i,j,k))) : {

trace('$i, $j, and $k were passed into this nested monster');

}

default: trace("Shouldn't be printed");

}

// Check out "generalized algebraic data types" (GADT) for more details

// on why these are so great.

}

}

class TypedefsAndStructuralTypes {

public static function example() {

// Here we're going to use typedef types, instead of base types.

// At the top we've declared the type "FooString" to mean a "String" type.

var t1:FooString = "some string";

// We can use typedefs for "structural types" as well. These types are

// defined by their field structure, not by class inheritance. Here's

// an anonymous object with a String field named "foo":

var anon_obj = { foo: 'hi' };

/*

var f = function(fo:FooObject) {

trace('$fo was passed in to this function');

}

f(anon_obj); // call the FooObject signature function with anon_obj.

/*

}

}

class UsingExample {

public static function example() {

/*

trace(StringTools.endsWith("foobar", "bar") + " should be true!");

/*

trace("foobar".endsWith("bar") + " should be true!");

/*

}

}

```

We're still only scratching the surface here of what Haxe can do. For a formal

overview of all Haxe features, see the [manual](https://haxe.org/manual) and

the [API docs](https://api.haxe.org/). For a comprehensive directory of available

third-party Haxe libraries, see [Haxelib](https://lib.haxe.org/).

For more advanced topics, consider checking out:

* [Abstract types](https://haxe.org/manual/types-abstract.html)

* [Macros](https://haxe.org/manual/macro.html)

* [Compiler Features](https://haxe.org/manual/cr-features.html)

Finally, please join us on [the Haxe forum](https://community.haxe.org/),

on IRC [#haxe on

freenode](http://webchat.freenode.net/), or on the

[Haxe Gitter chat](https://gitter.im/HaxeFoundation/haxe).