• Introduction
  • 1. Introduction
    • 1.1. What is Haxe?
    • 1.2. About this Document
    • 1.3. Authors and contributions
    • 1.4. License
    • 1.5. Hello World
    • 1.6. History
  • 2. Types
    • 2.1. Basic Types
    • 2.2. Numeric types
    • 2.3. Overflow
    • 2.4. Numeric Operators
    • 2.5. Bool
    • 2.6. Void
    • 2.7. Nullability
    • 2.8. Optional Arguments and Nullability
    • 2.9. Class Instance
    • 2.10. Class constructor
    • 2.11. Inheritance
    • 2.12. Interfaces
    • 2.13. Enum Instance
    • 2.14. Enum Constructor
    • 2.15. Using enums
    • 2.16. Anonymous Structure
    • 2.17. JSON for Structure Values
    • 2.18. Class Notation for Structure Types
    • 2.19. Optional Fields
    • 2.20. Impact on Performance
    • 2.21. Function Type
    • 2.22. Optional Arguments
    • 2.23. Default values
    • 2.24. Dynamic
    • 2.25. Dynamic with Type Parameter
    • 2.26. Implementing Dynamic
    • 2.27. Abstract
    • 2.28. Implicit Casts
    • 2.29. Operator Overloading
    • 2.30. Array Access
    • 2.31. Selective Functions
    • 2.32. Enum abstracts
    • 2.33. Forwarding abstract fields
    • 2.34. Core-type abstracts
    • 2.35. Monomorph
  • 3. Type System
    • 3.1. Typedef
    • 3.2. Extensions
    • 3.3. Type Parameters
    • 3.4. Constraints
    • 3.5. Generic
    • 3.6. Construction of generic type parameters
    • 3.7. Variance
    • 3.8. Unification
    • 3.9. Between Class/Interface
    • 3.10. Structural Subtyping
    • 3.11. Monomorphs
    • 3.12. Function Return
    • 3.13. Common Base Type
    • 3.14. Type Inference
    • 3.15. Top-down Inference
    • 3.16. Limitations
    • 3.17. Modules and Paths
    • 3.18. Module Sub-Types
    • 3.19. Import
    • 3.20. Resolution Order
  • 4. Class Fields
    • 4.1. Variable
    • 4.2. Property
    • 4.3. Common accessor identifier combinations
    • 4.4. Impact on the type system
    • 4.5. Rules for getter and setter
    • 4.6. Method
    • 4.7. Overriding Methods
    • 4.8. Effects of variance and access modifiers
    • 4.9. Access Modifier
    • 4.10. Visibility
    • 4.11. Inline
    • 4.12. Dynamic
    • 4.13. Override
    • 4.14. Static
  • 5. Expressions
    • 5.1. Blocks
    • 5.2. Constants
    • 5.3. Binary Operators
    • 5.4. Unary Operators
    • 5.5. Array Declaration
    • 5.6. Object Declaration
    • 5.7. Field Access
    • 5.8. Array Access
    • 5.9. Function Call
    • 5.10. var
    • 5.11. Local functions
    • 5.12. new
    • 5.13. for
    • 5.14. while
    • 5.15. do-while
    • 5.16. if
    • 5.17. switch
    • 5.18. try/catch
    • 5.19. return
    • 5.20. break
    • 5.21. continue
    • 5.22. throw
    • 5.23. cast
    • 5.24. unsafe cast
    • 5.25. safe cast
    • 5.26. type check
  • 6. Language Features
    • 6.1. Conditional Compilation
    • 6.2. Externs
    • 6.3. Static Extension
    • 6.4. In the Haxe Standard Library
    • 6.5. Pattern Matching
    • 6.6. Introduction
    • 6.7. Enum matching
    • 6.8. Variable capture
    • 6.9. Structure matching
    • 6.10. Array matching
    • 6.11. Or patterns
    • 6.12. Guards
    • 6.13. Match on multiple values
    • 6.14. Extractors
    • 6.15. Exhaustiveness checks
    • 6.16. Useless pattern checks
    • 6.17. String Interpolation
    • 6.18. Array Comprehension
    • 6.19. Iterators
    • 6.20. Function Bindings
    • 6.21. Metadata
    • 6.22. Access Control
    • 6.23. Inline constructors
  • 7. Compiler Usage
    • 7.1. Global Compiler Flags
  • 8. Compiler Features
    • 8.1. Built-in Compiler Metadata
    • 8.2. Dead Code Elimination
    • 8.3. Compiler Services
    • 8.4. Overview
    • 8.5. Field access completion
    • 8.6. Call argument completion
    • 8.7. Type path completion
    • 8.8. Usage completion
    • 8.9. Position completion
    • 8.10. Top-level completion
    • 8.11. Completion server
    • 8.12. Resources
    • 8.13. Embedding resources
    • 8.14. Retrieving text resources
    • 8.15. Retrieving binary resources
    • 8.16. Implementation details
    • 8.17. Runtime Type Information
    • 8.18. RTTI structure
    • 8.19. Static analyzer
  • 9. Macros
    • 9.1. Macro Context
    • 9.2. Arguments
    • 9.3. ExprOf
    • 9.4. Constant Expressions
    • 9.5. Rest Argument
    • 9.6. Reification
    • 9.7. Expression Reification
    • 9.8. Type Reification
    • 9.9. Class Reification
    • 9.10. Tools
    • 9.11. Type Building
    • 9.12. Enum building
    • 9.13. @:autoBuild
    • 9.14. @:genericBuild
    • 9.15. Limitations
    • 9.16. Macro-in-Macro
    • 9.17. Static extension
    • 9.18. Build Order
    • 9.19. Type Parameters
    • 9.20. Initialization macros
  • 10. Standard Library
    • 10.1. String
    • 10.2. Data Structures
    • 10.3. Array
    • 10.4. Vector
    • 10.5. List
    • 10.6. GenericStack
    • 10.7. Map
    • 10.8. Option
    • 10.9. Regular Expressions
    • 10.10. Matching
    • 10.11. Groups
    • 10.12. Replace
    • 10.13. Split
    • 10.14. Map
    • 10.15. Implementation Details
    • 10.16. Math
    • 10.17. Special Numbers
    • 10.18. Mathematical Errors
    • 10.19. Integer Math
    • 10.20. Extensions
    • 10.21. Lambda
    • 10.22. Template
    • 10.23. Reflection
    • 10.24. Serialization
    • 10.25. Serialization format
    • 10.26. Xml
    • 10.27. Getting started with Xml
    • 10.28. Parsing Xml
    • 10.29. Encoding Xml
    • 10.30. Json
    • 10.31. Parsing JSON
    • 10.32. Encoding JSON
    • 10.33. Implementation details
    • 10.34. Input/Output
    • 10.35. Sys/sys
    • 10.36. Remoting
    • 10.37. Remoting Connection
    • 10.38. Implementation details
    • 10.39. Unit testing
  • 11. Haxelib
    • 11.1. Using a Haxe library with the Haxe Compiler
    • 11.2. haxelib.json
    • 11.3. Versioning
    • 11.4. Dependencies
    • 11.5. extraParams.hxml
    • 11.6. Using Haxelib
  • 12. Target Details
    • 12.1. JavaScript
    • 12.2. Getting started with Haxe/JavaScript
    • 12.3. Using external JavaScript libraries
    • 12.4. Inject raw JavaScript
    • 12.5. JavaScript untyped functions
    • 12.6. Debugging JavaScript
    • 12.7. JavaScript target Metadata
    • 12.8. Exposing Haxe classes for JavaScript
    • 12.9. Loading extern classes using "require" function
    • 12.10. Flash
    • 12.11. Getting started with Haxe/Flash
    • 12.12. Embedding resources
    • 12.13. Using external Flash libraries
    • 12.14. Flash target Metadata
    • 12.15. Neko
    • 12.16. PHP
    • 12.17. Getting started with Haxe/PHP
    • 12.18. PHP untyped functions
    • 12.19. C++
    • 12.20. Using C++ Defines
    • 12.21. Using C++ Pointers
    • 12.22. Java
    • 12.23. C#
    • 12.24. Python
  • 13. Dictionary
  • Published with GitBook

12.2 Flash

12.2.1: Getting started with Haxe/Flash

12.2.2: Embedding resources

12.2.3: Using external Flash libraries

12.2.4: Flash target Metadata