Actionscript Language Ideas

[marchbold]

Just starting a thread for people to discuss ideas for the Actionscript Language.

Please follow the following to keep these ideas clean and easy to read and discuss:

• create a new thread for each idea,
• keep your idea concise,
• only one idea per thread,
• explain your idea with an example and any references,
• reply in thread to comment on a particular idea.

[2jfw]

Keeping suggestions/ideas in a separate comment for each one [EDIT: Thanks @marchbold for having added some general guidelines now..], first one from my side would be:

Enums

Benefits: type-safety, readability, maintainability

[hydroper]

This is my proposal for an enumeration:

An enumeration is a final class defining a series of static constants that are instances of that class.

An instance of an enumeration maps to a String and a Number.

Enum1("memberName")
Enum1(0)

Enum1.MEMBER_NAME.toString() // "memberName"
Enum1.MEMBER_NAME.valueOf() // 0

An enumeration is not allowed to define a constructor.

An enumeration defines an arbitrary set of properties, both static, and at the class prototype.

Attributeless const definitions containing optional ASDoc comments, found within the enum block, define members of the enumeration. The initializer of a member is optional, and may be in one of the following forms.

StringLiteral
numberConstant
[StringLiteral, numberConstant]
[numberConstant, StringLiteral]

If the StringLiteral is omitted, it is deduced as a conversion of the screaming-snake-case form of the constant name (SCREAMING_SNAKE_CASE) to a camel-case form (camelCase).

If the numberConstant is omitted, it is deduced as the valueOf() of the previously defined member + 1, or 0.

It is a verify error if either the StringLiteral or numberConstant are duplicate across the members.

enum Enum1 {
    const M1
        , M2 = 1
        , M3 = "m3"
        , M4 = [12, "m4"]
        , M5 = ["m5", 28],
}

Enum1.M1 returns an Enum1 object where toString() == "m1" and valueOf() == 0.

Type inference occurs when a context expects exactly an enumeration and the expression is a StringLiteral, whose value is limited to match the String of an enumeration member.

var k : Enum1 = "memberName";
var k = Enum1("memberName");

[hydroper]

ES4 proposed destructuring patterns and switch type:

switch type (v) {
    case (d:Date) {
    }
    case ({x}:C) {
    }
    default {
    }
}

[2jfw]

Abstract Classes

In principle the same as the Java equivalent (https://www.w3schools.com/java/java_abstract.asp) with the same goal to create an additional layer of abstraction

[Harbs]

Royale implementation:
apache/royale-compiler@6a85bc1

[hydroper]

Something important for iteration proxies are generators (yield), like ES4.

// f1: function():Iterator.<Number>
function f1():Number {
    yield 10;
}

And related: support the Iterator interface.

[hydroper]

Context keyword type for aliasing (annotatable directive):

type N1 = N2;

[marchbold]

Arrow Functions

An arrow function expression is a compact alternative to a traditional function expression, but is limited and can't be used in all situations.

function (a:String):Number 
{
  return 1;
}

Equivalent Arrow functions would be:

(a:String):Number => {
  return 1;
} 

(a:String):Number => 1;

[jaycverg]

An important reason to use arrow function in ES is to retain the contextual this especially when passing callbacks.
I presume that the contextual this will be retained also when arrow function gets supported in AS.

This example is what we have in the our legacy code base (I just changed the class names).

// without arrow functions
class SomeClass extends SomeBaseClass {

  private function doSomething():void {
    var _this:* = this; // need to keep a reference of "this" because it will be passed inside the function callback
    someWebServiceCall(parameters, ..., function(result:TheType):void {
      // do something with the result
      someUtilityThatNeedsTheThisReference(_this, anotherParamter);
    });
  }

}



// with arrow functions (if implemented like the ES behavior)
class SomeClass extends SomeBaseClass {

  private function doSomething():void {
    someWebServiceCall(parameters, ..., (result:TheType):void => {
      // do something with the result
      someUtilityThatNeedsTheThisReference(this, anotherParamter); // this here refers to the current SomeClass instance
    });
  }

}

[ajwfrost]

@jaycverg for this second part, I am guessing that the scope information that's captured along with the method closure would be missing the "this" element... and am wondering how easy it might be to get that back. The callback function would be called by something else, and normally the "this" would be set to whatever scope is in place at the time. I have a bit of concern about changing this behaviour as it may impact existing apps that rely on the current mechanism .. although I'm struggling to see how you could use "this" in that callback mechanism with the actual knowledge of what "this" might be referring to...

Anyway -> yes this would all be good!

[jaycverg]

@ajwfrost - for ES, I think the implementation of capturing the this scope is that they treat the arrow function declaration as if it implicitly called the bind method, function(...) { ...}.bind(this), which preserves whatever this context you set.

function testFn(callback) {
	console.log('running test fn...');
	callback();
}

/// example with arrow function callback in ES
class SomeClass {

  name = 'hello world';

  someFn() {
        // arrow function captures the "this" from SomeClass instance
	testFn(() => console.log('SomeClass.name:', this.name));
  }

}

/// example with function callback using bind in ES
class SomeClass {

  name = 'hello world';

  someFn() {
	testFn(function() {
		console.log('SomeClass.name:', this.name)
	}.bind(this));
  }

}

[jaycverg]

Maybe it would be best to first introduce the bind method to Function and just make the arrow function implementation as a syntactic sugar of function(....){ ....}.bind(this) to preserve the this context where it was initially declared.

[ylazy]

+1 vote. Easier to read. No "function" everywhere.

() => expression

=

function () :* { expression }

---

param => expression

=

function(param :*) :* { expression }

---

(param) => expression

=

function(param :*) :* { expression }

---

(param1, param2) => expression

=

function (param1:*, param2:*) :* { expression }

---

(...params) => expression

=

function (...params) :* { expression }

---

() => {
  statements
}

=

function () :* {
  statements
}

---

param => {
  statements
}

=

function (param :*)  :* {
  statements
}

---

(param1:String, param2:Number = 0, ...rest):String {
  statements
}

=

function (param1 :String, param2 :Number = 0, ...rest):String {
  statements
}

more

[marchbold]

Structural Function Type

A way to define the parameters and return value of a function passed as a parameter. This is a common issue in our development of libraries and often the reason we avoid the "callback" function approach and stick with traditional events.

For example if we look at a simple function foo that takes a callback function as a parameter. It expects this function to have a particular params and return value:

function foo( callback:Function ):Number {
  // callback has no type or return information defined so hard to enforce rules
  var number:Number = callback( 'some string' );

  return number;
}

Then when you go to use it,

foo( function( p:String ):Number {
    return 1;
});

however in actionscript the following would compile but fail at runtime:

foo( function():void {
  // doesn't return a Number or accept the string parameter
} );

So basically would be nice to be able to define the parameters and return value of the callback:Function.

[hydroper]

I've nothing against (...) => R versus Function.<...>. Also, optional parameters should be covered with ? (like (a?:P) => R).

[marchbold]

Optional parameters sound like a separate idea?

[hydroper]

I don't think so. The type (a?:P)=>R covers: function f(a:P = someDefaultValue):R;.

[joshtynjala]

AS3 is typically strict about matching the exact same default values in function signatures when implementing an interface or overriding a method. Using ? in place of a specific default value doesn't feel the same to me at all.

[hydroper]

When I implemented a symbol solver for my own, I limited optional parameters to constant expressions. But I never came to bytecode and runtime implementation, so not sure how hard these optional parameters would be in structural function types. PS.: I understand what you mean by override, but I think the function type isn't a problem here (at least it won't break compatibility supporting them).

[hydroper]

Asynchronous functions and Promise. No need for async modifier; make it work like ES4 generators. For example, once a function has await operator, it's asynchronous.

Like yield, await would be a strictly reserved word, which breaks compatibility; thus should require version number >= 4.

[pnico]

If yield were available, along with parameterized iterators/generators (if full generic support isn't realistic), just yield and an event loop implementation in AS3 could give many of the same benefits. Then later if an event loop / Promise implementation became standardized to be included in the runtime (maybe even hooking into the native event loop), functions with await (and async if desired) could resolve to that?

[Adolio]

Being able to create Threads on the fly with few locking mechanisms (such as lock scopes) would be already a real plus for the language. Personally creating Workers with dedicated SWF is a pain.

The icing on the cake would be to have async/await with Task similar to C#. The asynchronous code becomes so easy to follow & maintain when using this kind of mechanism.

[ajwfrost]

So we had investigated this sort of thing a while ago. There are some limitations in the avmplus code e.g. around memory management that are caused by the use of thread-local storage but the model used by JavaScript is something that we could potentially adopt, i.e. asynchronous activities with Promise and await or yield etc. But under the hood these would then still use a single thread and be queued/processed with the runtime providing the asynchronicity support.

"Proper" multithreading in JavaScript/browsers is done with WebWorkers which are very similar to the AS3 Worker concept. However when we set up a Worker, there is lot of stuff being set up behind the scenes, including the full SWF parser etc .. so I'm wondering whether this could be optimised a little. For example maybe we could pass a worker just a particular Class definition and have it run that.. will have to see if we can then strip out things to make it simpler (although I'm not yet sure about the sharing of class definitions between different instances of the avm core..)

Can I get some real-world example of what you would use this sort of thing for? Is it just for ease of programming and coding/design, or are there specific operations that take time that you would want to push onto other threads?

[pnico]

We do tons of web requests and file loading/saving operations all the time, calling into an ANE that returns later with an Event, Loaders that load a little swf art asset as a bytearray, load and play a sound file... lots of these things need to be chained, done in parallel, if success do this if error do that, etc... we have a 'Future' class that's basically like Promise from way before Promise existed in JS, it works ok, we have onSuccess and onError that's like then and catch, we pass an anonymous function to each and there's some support for chaining, parallel etc. I guess it would be like what they used to call "callback hell" in Node.js. I think "hell" is kind of a strong word because it does work and there are ways to make it more convenient, but anyone who has gone from using callbacks to using await can attest to the fact that it's very much nicer and the code is way cleaner.

I work in Python and before asyncio was standardized there or async/await existed, they introduced generators which allowed many frameworks to do pretty much exactly the same thing as await, with just generators, still can if you don't/can't use asyncio and it still works well. I'm pretty sure this would work in AS3 too without any native 'microtask queue' like ES has, just a simple task queue all in AS3. I've been meaning to do a little toy generator demo that would just rewrite code Babel-style, when I get some time...

I'm not interested in anything with real threads, I like single-threaded 👍 what I want is more like 'coroutines'

[Harbs]

FYI, I don't like Promises or even the await/async sugar built on top. Promises are their very own type of hell and I believe await/catch to be an anti-pattern.

I developed an alternate OOP pattern which I call tasks. It includes conversion back and forth between Promises to enable interop with code that's built with Promises. It has parallel and chained requests where you can handle some or all of the results and deal with errors in a sane manner.

The code is in Royale here: https://github.com/apache/royale-asjs/tree/develop/frameworks/projects/Core/src/main/royale/org/apache/royale/utils/async

I use this pattern in my TypeScript code which has async/await and it cleaned up my code tremendously even there.

Take it for what it's worth.

[hydroper]

[2jfw]

Not 100% sure but I would have thought that this functionality is already available in as3.

Have a look at:
A Complete Guide to Using Namespaces In AS3
https://blog.gskinner.com/archives/2010/01/a_complete_guid.html

[hydroper]

@2jfw Yeah, the only issue is that these namespaces use :: and a different lookup mechanism. What I'm suggesting is Math, Intl (TC39) or Temporal (TC39) like namespaces, which you can access as objects using .. For example, Math.max instead of Math::max.

[2jfw]

Ok, I see - thanks for elaboration :)

[joshtynjala]

It could also be equivalent to a static class that can't be constructed (aka. illegal constructor).

I could see that use-case being more straightforward if they added private constructors to classes. Are there any other benefits to these namespaces?

[hydroper]

Are there any other benefits to these namespaces?

An ordinary class can't have nested class. Namespaces such as Intl and Temporal (from an ongoing TC39 proposal) contain nested classes. I'm not sure ActionScript will implement these in the future, but they're turning into standard.

[hydroper]

UPDATE: I guess the following idea isn't good after all, so just ignore it.

String code points

Way to deal with Strings code points (Unicode Scalar Value). Either provide alternative Python-like-composition String methods using a special namespace (like s.ScalarValue::charCodeAt(...)) or API for iterating code points.

Currently Strings consist of UTF-16 code units, which cover only U+00 to U+FFFF characters. Python supports U+00 to U+10FFFF (maximum Unicode code point).

[ajwfrost]

String.fromCharCode(...) can only receive from U+00 to U+FFFF.

Sorry, my mistake - I thought it could take a higher value! Just looked at the code and it literally just casts it to a 16-bit value :-(

The challenge with doing:

var s:String = '\u{10ffff}';
s.length == 1;

and having length as 1 rather than 2 is that it would make it slower -> length is just returning the amount of storage that's needed i.e. number of 16-bit codes. See also https://flexiple.com/javascript/javascript-string-length/ which says:

So whenever the .length property is involved, JavaScript looks up and returns the number of code units occupied by the string. This is why JavaScript returns 2 when the length property is called upon by certain characters such as emojis, etc

Given how the AS3 and C++ APIs are intermingled and how much depends on this, I would almost prefer to have a separate class for this, or just new AS3 APIs, so e.g.

var s:String = '\u{10ffff}';
s.lengthUTF32 == 1; // new property to give an accurate number of characters rather than of code points
s.charCodeAt(0, true) = 0x10ffff; // adding an optional parameter to request a response in UTF-32 format
s.slice(0, 1, true) == '\u{10ffff}'; // likewise, UTF-32 as an option..

Or alternatively, we give a per-string (or per-application?) option to switch all string operations into UTF-32 mode? I just have some concerns about behavioural changes if we were to update how this works now....

[hydroper]

I've updated my comment talking about Python's case. Is it not viable? The string doesn't need to be represented as UTF-32. It can demand depending on characters contained as I said... And I believe AVM is already doing some Python-like representation, the issue is that it limits range to U+FFFF.

Also, instead of these parameters you can use namespaces like s.ScalarValues::length. But I still think it's fine to change the default range from UTF-16 code units to Unicode code points (aka. Scalar Values).

package {
    public namespace ScalarValues;

    public final class String {
        ScalarValues function get length():Number { ... }
    }
}

Then:

{
    use namespace ScalarValues;
    s.length == 1;
}
{
    s.ScalarValues::length == 1;
}

[ajwfrost]

Ah okay..

Python uses a string representation that allows random memory access by not using UTF-8 or UTF-16... instead it uses the representation that satisfies which code points are present.

Yes that would also be a possibility I guess but again a little less efficient, and with the risk of existing functionality changing (if we updated the runtime, and someone's SWF file was expecting a length of two when they were using surrogate pairs for an emoji..). Perhaps the behaviour should only switch if there has been a value set explicitly via a value e.g.:

var s1:String = '\u{10ffff}';
s1.length == 1; // because it was set with a value that didn't fit as a single code point, we now measure length as characters rather than code points..
var s2:String = '\ud83c' + '\udf09';
s2.length == 2; // because it was just set with two 16-bit values..

Hmm.. I think this is confusing. But then, everything is confusing, e.g. https://stackoverflow.com/a/54922477

The namespace suggestion I hadn't fully understood earlier, but that sounds like a good way of doing it. FYI I hadn't been suggesting to change the storage of anything internally - we'd still have UTF-16 for that - but just the way in which we processed and returns characters could be governed by this. So then we could have:

var s1:String = '\u{10ffff}';
s1.ScalarValues::length == 1;
s1.ScalarValues::charCodeAt(0) = 0x10ffff;

etc -> although I am not sure 'ScalarValues' has quite the right name.. wouldn't 'UCS4' or 'UTF32' would be more descriptive?

[hydroper]

Honestly you're right... changing representation may not only break entry-point projects, but also dependency SWCs. What about introducing another primitive String sibling class, like you said, which implicitly converts to String? And also allow String to implicitly convert to it?

// SVString is value-based (aka. value-passed and value-compared)
[Value]
public final class SVString {
    // ...
}

var svStr:SVString = ...;
var str:String = svString; // implicit conversion to String
var svStr2:SVString = str; // implicit conversion to SVString

About Scalar Value, code points and code units:

• The difference from code points to Scalar Value is that Scalar Values cannot be U+D800 to U+DFFF. Scalar values go from U+00 to U+D7FF and U+E000 to U+10FFFF. Code points go from U+00 to U+10FFFF.
• The difference from code points to UTF-16 code units is that code points go from U+00 to U+10FFFF, while the latter goes from U+00 to U+FFFF.

Motivation:

• A motivation to this is that it makes easier to make first character uppercase. There are characters > U+FFFF that are letter (at last the Lo Unicode General Category)... Not sure if Lo characters have a Lu or Ll equivalent.
• Another motivation is that it facilitates similiarity comparison.

[ajwfrost]

Slight aside but I just checked that you can embed unicode characters into a string literal and the AS3 compiler properly embeds them into a SWF as UTF-8, and the avmplus will correctly cope with these and convert from UTF-8 to UTF-16 with them taking two code points.. which means that if we did introduce a new class to handle these characters properly, then at least we wouldn't need to adjust the compiler or ABC format, and it would just be an AS3 API change...

Which is preferable then .. having a new class, or new methods (or accessing the standard method names via a namespace)?

[jaycverg]

Type inference for me. This will save us a lot of keystrokes on large code base.

In our more than a decade old desktop AIR code base, we have something like this:

var ex:ThreeSixtyExceptionVO = VOUtility.makeException(faultEvent);
// having type inference like this will save a lot of keystrokes
var ex = VOUtility.makeException(faultEvent);

Although modern IDEs do type inference in the IDE level but compiling the code produces a lot of warnings when you don't declare the types.

[hydroper]

Yeah, though this will break compatibility since var v; is equivalent to var v:*;. So it'll require version number >= 4.

[hydroper]

ReservedWord as IdentifierName

Follow Royale compiler on IdentifierName for function definitions, variable bindings, destructuring patterns and property operators.

[joshtynjala]

In ECMAScript 5, they made it possible to use reserved words in certain specific places that was not allowed in ES3/ES4. At the very least, it would be good to match that behavior. The Royale compiler supports this for better compatibility with JS (and it has an option to restore the stricter behavior).

[hydroper]

Allow reserved word after dot and ?., like ECMAScript 5+ does. For example:

o.for(...);
// instead of
o['for'](...);

[toysonlocation]

I think one of the worst and most universal things is lack of block-scope. Variable hoisting is trash and forces all sorts of "this" shenanigans.

[teotigraphix]

YES! declaring variables in random places to get around this was horrible. :)

[hydroper]

So the suggestion is either:

• Support let and let const reserved words?
• Change var and const declarations to be block-based and support shadowing?

Any of these will be breaking changes, so it'll require version number >= 4.

[toysonlocation]

add let
change const
keep var

[hydroper]

• arrayOrVector.first (writable) first array element or undefined if empty
• arrayOrVector.last (writable) last array element or undefined if empty

[ajwfrost]

This is an API change which is relatively simple (just compatibility to think about), so a change a bit like when they added insertAt etc. Good suggestion.. but to check, if you had an array with elements ["one", "two", three"], what would you expect the result to be if you wrote arr.first = "four";? Presumably it would be ["four", "two", "three"]?

[Adolio]

arrayOrVector.any would be very welcome too in order to prevent to do arrayOrVector.length > 0.

[hydroper]

Explicit Property Disambiguation

Dictionary has only one issue:

const dictionary: Dictionary = new Dictionary();
dictionary.toString = 10;
dictionary.valueOf = '';
trace(dictionary.constructor);

Solve it by explicitly disambiguation between fixed and dynamic properties by reserving two certain non-parenthesized E4X qualifiers, such as fixed and dynamic.

dictionary.fixed::valueOf // refers to a "valueOf" property of the Dictionary prototype
dictionary.dynamic::valueOf // refers to a "valueOf" property of the dictionary

[hydroper]

Update: use two special E4X qualifiers

[B-Interactive]

I think it's good to consider the ECMA standard (as many have), as ActionScript 3.0's origins began there, so it makes sense to revisit current standards. Also, as Haxe is something of a spiritual successor to ActionScript 3.0, with a community that I suspect has many roots in ActionScript 3.0, I'd be looking to see what's working well there too, when considering like-features for an official ActionScript 3.0 successor.

It features a number of things already raised here.

• Type inference (@jaycverg).
• Conditional compilation similar to @Adolio's suggesiton.
• Enums (which I really appreciate) as per @2jfw's suggestion.
• Abstract classes, also mentioned by @2jfw.

I expect this would look quite approachable to an ActionScript 3.0 dev.

class Game {
  // Haxe applications have a static entry point called main
  static function main() {
    // Anonymous structures.
    var playerA = { name: "Simon", move: Paper }
    var playerB = { name: "Nicolas", move: Rock }
        
    // Array pattern matching. A switch can return a value.
    var result = switch [playerA.move, playerB.move] {
      case [Rock, Scissors] | 
           [Paper, Rock] |
           [Scissors, Paper]: Winner(playerA);
            
      case [Rock, Paper] |
           [Paper, Scissors] |
           [Scissors, Rock]: Winner(playerB);
            
      case _: Draw;
    }
    // Paper vs Rock, who wins?
    trace('result: $result');
  }
}
            
// Allow anonymous structure named as type.
typedef Player = { name: String, move: Move }

// Define multiple enum values.
enum Move { Rock; Paper; Scissors; }

// Enums in Haxe are algebraic data type (ADT), so they can hold data.
enum Result { 
  Winner(player:Player); 
  Draw; 
}

[hydroper]

[hydroper]

Source: https://github.com/violetscript/violetc

[2jfw]

Maybe you should apply for a job @ Harman to work on AS3 language 😉

[ylazy]

The TLF TextField is deprecated. What's next?

TLF TextField is deprecated. TextField is out of date. A modern text displaying framework is needed.

[ajwfrost]

I think the TLF TextField was only ever available briefly as a separate component library? This may not be supported any more, but it used the underlying FTE mechanism, and that is definitely still supported and the best thing to use when trying to display complex fonts, RTL languages etc.

Ultimately, the FTE classes boil down to creating a TextLine which is a display object so is what you actually add to the stage.

[balaedit]

I still use TLF textfield in Adobe Animate using below swc files :
tlf_SWC.zip

by copying two files of zip in common folder I still able to used TLF and I used for Arabic/Urdu font.

Is there any alternative or embed classes in Adobe AIR?

[ylazy]

is not and not in operators

if (instance is not SomeClass)
if (key not in Object)

instead of

if (!(instance is SomeClass))
if (!(key in Object))

[joshtynjala]

Related JS proposal (which includes examples from other languages, for comparison): https://github.com/tc39/proposal-negated-in-instanceof

[hydroper]

Package alias

This syntax allows to alias the public and internal namespaces of a package into a lexical name and open the specified package's public at a certain scope.

package com.ea.n4s {
    public class N4S {}
}
// 1. Alias `com.ea.n4s` (public) and (internal) into a `n4s` NamespaceSet here
// 2. Open `com.ea.n4s` (public) here
import n4s = com.ea.n4s.*;
new n4s::N4S;

[shaucky]

I recently found a specification in C # very interesting. In C#, the basic data type has corresponding keywords, compiler replaces the keyword with The actual basic types of .NET Framework. This to some extent ensures the coupling between language and runtime.

For example, keyword string will compile as type System.String, keyword object will compile as type System.Object. At the same time, I think that introducing such a design can solve the problem of inconsistent naming conventions between int and uint types and other types in ActionScript.

[hydroper]

To me UnsignedInt and Int look good definition names for uint and int.

https://hydroper-jet.github.io/lang/spec/1.0/live/types.html#number-types

I don't think ActionScript 3 itself is able to alias them properly without breaking compatibility when using dynamic reflection?

[shaucky]

Not sure. In C# these are keywords, not alias (Not like identifiers in top-level scopes, although there seems to be no difference in usage). These keywords in codes are compiled to runtime specific types.

[shaucky]

Dynamic compiling:

Compile ActionScript code to bytecode on runtime.

Using like the CSharpCodeProvider in C#(.NET) or eval() in JavaScript(Browser).

[ajwfrost]

EvalError comes from if you tried to do new Function(function_body) i.e. to pass in a string to a Function constructor. ECMA script (well, the version on which AS3 is based) says that if the implementation doesn't support this/eval, it needs to throw an EvalError.

Potentially of course, you could manually craft some ActionScript Byte Code, wrap it in a basic SWF, and pass this to a Worker to run... so the security side of things is already a little interesting. But to just allow AIR to compile the ActionScript would need a bit of configuration:
https://github.com/adobe/avmplus/blob/858d034a3bd3a54d9b70909386435cf4aec81d21/core/AvmCore.cpp#L1236
... and we'd need to compile and link in a lot more code, and it doesn't look necessarily complete:
https://github.com/adobe/avmplus/blob/master/eval/documentation.txt

I believe that the "redshell" build of avmshell has got support for 'eval':
https://github.com/Corsaair/redtamarin
and it's something we talked about providing within the AIR SDK as well i.e. a way to run ActionScript code as a script file like you would with Python or bash/zsh etc.

But I'm really not sure about adding that capability in to the main AIR runtimes...

[Townado]

Is zwetan still around maintaining redtamarin?

[marchbold]

@Townado Haven't heard from him in many years, unfortunately I believe he passed away. (https://forum.starling-framework.org/d/22914-httpsdiscussas3langorg-is-the-website-closed/11)

[shaucky]

Some opinions here:

What are your thoughts on the warning at the top of that Mozilla page?

A bad actor can execute malicious code not only through dynamic compiling. Whether it's decompiling a SWF file and modifying it, intercepting and redirecting requests, or inspecting and modifying an app's runtime behavior through reflection, there are numerous ways to achieve malicious intents. Introducing dynamic compiling merely opens one more avenue.

Considering so many ways, I'm uncertain what to conclude from a security perspective. Like the example I gave, C # and JavaScript both provide similar capabilities.

I'm all ears what you would want to achieve by that and what your benefits were ...

For example, if i have a game or library built on Starling framework, and I want to offer different custom classes for different assets, I can build a tool utilizing dynamic compiling, compress 'em (the XML, sprite sheet, ActionScript bytecode/code) into one file. This seems similar to what Animate frame scripts do, right?

[johnou]

I wouldn't touch eval with a 10ft pole, security wise and iirc apple and google forbid dynamic compiling code.

[Townado]

@Townado Haven't heard from him in many years, unfortunately I believe he passed away. (https://forum.starling-framework.org/d/22914-httpsdiscussas3langorg-is-the-website-closed/11)

Oh no. That is very sad indeed. :(

[hydroper]

Options Classes

An options class is a class containing the [Options] meta-data. Such a class may be initialized from an object initializer through direct type inference.

Note: options classes are common for defining options that a method or constructor may receive.

A property is optional when it includes either null, undefined, or a default value (always the case in standard ActionScript 3.0).

A property would not be optional when it is of a non-nullable data type such as in the T! proposal, which excludes null from a reference.

[Options]
class MyC1 {
    var property: Number;
}
var o1 : MyC1 = {
    property: 10,
};
var o2 : * = MyC1({
    property: 10,
});

This proposal implies that the call operator T(...) for type conversions passes T as the context type of the conversion argument.

The call operator is required where a context accepts more than one type rather than only a specific [Options] class, such as Object or * typed variables.

[hydroper]

Package concatenation

Package concatenation is the ability to contribute a series of packages into one package, combining all their public namespaces and properties into one.

package foo.core {
    public += baz.util.*;
    public += qux.**;
    public += baz.x.action;
}

The syntax is defined as

public += PackageName . *
public += PackageName . **

Use the former for concatenating one package and the latter for recursive packages.

Edit: allow individual aliases too.

public += PackageName . IdentifierName

---

The efficient implementation for this is, the lookup in a package will have a secondary list of packages for lookup, where any name in any public namespace is looked for. Oopsie, it should be a little different from my explanation. Lookup doesn't happen in a package, but rather...

[hydroper]

@joshtynjala I think you've downvoted my proposal because it doesn't make sense. Somethings are true:

• It's difficulty for this to be implemented in the source tree model of the MXML compiler where the include-sources or doc-sources option is not used.
• Aliases and secondary lookup packages are only seen at compile-time and never at runtime (describeType() or getDefinitionByName() would not be able to see them) because AVM2 has no way of representing this.

I've been able to implement that feature with these limitations in my AOT verifier, but I've somethings in mind:

• In my compiler I want to combine both include-sources and source-path, so ActionScript 3 files will be able to define any number of definitions at the package blocks, and MXML would be found by include-sources and its package will be determined based in its source path and one of the source-path elements.
• In my compiler I want to incorporate package management, so the same compiler instance will be used for projects with different compiler options rather than compiling individual SWCs more commonly (which is nice for ASDoc).

I've also found it too hard to find a nice syntax for this. For example, use or something else just wouldn't make sense, so I decided to get near to default xml namespace = ns, just using += instead of =.

Also, I believe this feature will be nice when you want to mix a custom component set with several different packages from ActionScript 3 and use it in MXML.

[hydroper]

Configuration

The following configuration directive would have the same benefits from the NS::X { ... } and NS::X AnnotatableDirective forms. It'd support a Boolean constant directly at ActionScript 3 code as the condition for if which may refer to these NS::X constants, and the consequent and alternative blocks are conditionally expanded out based on the former condition's value.

Note: indeed, if-else can be used already with inline constants. The purpose here is to allow annotatable directives taking the exact same parent scope.

In the present, this fails in AS3:

package {
    import flash.display.Sprite;

    public class Main extends Sprite {
        if (FOO::BAR) {
            protected var fooBar: Number; // ERROR
        } else {
            trace("Qux");
        }

        public function Main() {
        }
    }
}

This proposal would make it work:

package {
    import flash.display.Sprite;

    public class Main extends Sprite {
        configuration {
            if (FOO::BAR) {
                protected var fooBar: Number
            } else {
                trace("Qux");
            }
        }

        public function Main() {
        }
    }
}

The conditions can be a little more advanced, using relative and logical operations for example.

This would allow to define classes and properties conditionally at compile-time.

I've personally found that more AS3-ish or E4X-ish than using a hashword such as #ifdef, but it's definitely more verbose, but at least it solves the if-else problem and expressiveness.

[joshtynjala]

I'm not sure that you've explained with enough detail what the purpose of configuration is. Using conditional compilation constants in if/else conditions is already supported, so it seems as if wrapping in configuration must be for some other purpose that I am failing to understand from context. A more complete example may help.

[hydroper]

@joshtynjala Right, I've updated it to clarify the purpose.

[Fancy2209]

I would love for support of Range Iteration like this in for loops, like in Haxe

for (i in 0...10) {
  if (i == 2) continue; // skip 2
  if (i == 5) break; // stop at 5
  trace(i);
}

It's easier to do than

for (var i:int = 0; i < 10; i++) {
  if (i == 2) 
    {continue;} // skip 2
  if (i == 5)
    {break;} // stop at 5
  trace(i);
}

[PippoApps]

More of an AIR than pure AS idea.
Embedding a NodeJS instance into the SDK?
Would allow access to a plethora of npm libraries.
I use some JS libraries by embedding a hidden Distriqt NativeWebView, but a native NodeJS instance would be amazing.
It seems possible on iOS and Android:
https://nodejs-mobile.github.io/

It would add a lot of possibilities.
I.e. lately I was looking for solutions to manage OSC on an AIR app, but the few AS3 libraries out there are outdated and unmaintained.

Just a thought :)

[ajwfrost]

We'd wondered about this kind of idea. It would mean a massive bloat of the runtime libraries though, Node is not a small piece of software! Integrating it tightly wouldn't be feasible but it's the sort of thing that could work well as an ANE.

I'd be interested in the sort of interactions you're thinking of for the ActionScript to JavaScript worlds .. so e.g. any use cases in particular?

[PippoApps]

Yeah I can barely guess the complexity involved :)
Personally what I use is OSC libraries, waveform manipulation and tomefm or other JS based sythesizers.

[marchbold]

Very interesting, definitely something that would work well as an ANE.

[Fancy2209]

Could import flash.display.Stage as NativeStage be implemented?