Actionscript Language Ideas #2152

marchbold · 2022-09-19T12:06:23Z

marchbold
Sep 19, 2022
Maintainer

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 · 2022-09-19T12:09:57Z

2jfw
Sep 19, 2022

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

1 reply

hydroper Apr 21, 2024

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 · 2022-09-19T12:10:48Z

hydroper
Sep 19, 2022

ES4 proposed destructuring patterns and switch type:

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

0 replies

2jfw · 2022-09-19T12:10:51Z

2jfw
Sep 19, 2022

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

1 reply

Harbs Nov 22, 2022

Royale implementation:
apache/royale-compiler@6a85bc1

hydroper · 2022-09-19T12:10:59Z

hydroper
Sep 19, 2022

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.

0 replies

hydroper · 2022-09-19T12:11:10Z

hydroper
Sep 19, 2022

Context keyword type for aliasing (annotatable directive):

type N1 = N2;

0 replies

marchbold · 2022-09-19T12:12:42Z

marchbold
Sep 19, 2022
Maintainer Author

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;

6 replies

jaycverg Sep 20, 2022

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 Sep 20, 2022
Maintainer

@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 Sep 20, 2022

@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 Sep 20, 2022

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 Apr 7, 2023

+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 · 2022-09-19T12:27:30Z

marchbold
Sep 19, 2022
Maintainer Author

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.

12 replies

hydroper Sep 22, 2022

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

marchbold Sep 22, 2022
Maintainer Author

Optional parameters sound like a separate idea?

hydroper Sep 22, 2022

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

joshtynjala Sep 22, 2022

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 Sep 22, 2022

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 · 2022-09-19T12:31:24Z

hydroper
Sep 19, 2022

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.

5 replies

pnico Oct 29, 2022

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 Nov 24, 2022

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 Nov 24, 2022
Maintainer

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 Dec 5, 2022

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 Dec 15, 2022

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 · 2022-09-19T12:32:12Z

hydroper
Sep 19, 2022

5 replies

2jfw Sep 19, 2022

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 Sep 19, 2022

@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 Sep 19, 2022

Ok, I see - thanks for elaboration :)

joshtynjala Sep 20, 2022

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 Sep 20, 2022

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 · 2022-09-19T12:37:08Z

hydroper
Sep 19, 2022

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).

E8E3

7 replies

ajwfrost Sep 20, 2022
Maintainer

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 Sep 20, 2022

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 Sep 20, 2022
Maintainer

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 Sep 20, 2022

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 Sep 20, 2022
Maintainer

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 · 2022-09-19T12:44:37Z

jaycverg
Sep 19, 2022

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.

1 reply

hydroper Sep 19, 2022

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

hydroper · 2022-09-19T14:21:05Z

hydroper
Sep 19, 2022

ReservedWord as IdentifierName

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

1 reply

joshtynjala Sep 20, 2022

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 · 2022-09-19T14:23:38Z

hydroper
Sep 19, 2022

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

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

0 replies

toysonlocation · 2022-09-19T14:23:57Z

toysonlocation
Sep 19, 2022

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.

3 replies

teotigraphix Sep 19, 2022

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

hydroper Sep 19, 2022

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 Sep 20, 2022

add let
change const
keep var

hydroper · 2022-09-19T17:07:13Z

hydroper
Sep 19, 2022

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

2 replies

ajwfrost Sep 20, 2022
Maintainer

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 Sep 20, 2022

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

ylazy · 2023-07-21T09:41:31Z

ylazy
Jul 21, 2023

The TLF TextField is deprecated. What's next?

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

2 replies

ajwfrost Jul 22, 2023
Maintainer

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 Oct 3, 2023

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 · 2023-10-06T03:55:53Z

ylazy
Oct 6, 2023

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))

1 reply

joshtynjala Oct 6, 2023

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

hydroper · 2023-10-15T17:47:14Z

hydroper
Oct 15, 2023

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;

0 replies

shaucky · 2024-01-22T15:12:44Z

shaucky
Jan 22, 2024

I recently found a specification in C # very interesting. I AE85 n 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.

2 replies

hydroper Jan 22, 2024

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 Jan 22, 2024

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 · 2024-04-08T12:26:46Z

shaucky
Apr 8, 2024

Dynamic compiling:

Compile ActionScript code to bytecode on runtime.

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

10 replies

ajwfrost Apr 8, 2024
Maintainer

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 Apr 9, 2024

Is zwetan still around maintaining redtamarin?

marchbold Apr 9, 2024
Maintainer Author

@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 Apr 9, 2024

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 Apr 22, 2024

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

Townado · 2024-04-10T01:42:10Z

Townado
Apr 10, 2024

@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. :(

0 replies

hydroper · 2024-04-21T15:43:26Z

hydroper
Apr 21, 2024

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.

0 replies

hydroper · 2024-05-04T15:27:29Z

hydroper
May 4, 2024

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...

1 reply

hydroper May 9, 2024

@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.

joshtynjala · 2024-05-12T19:44:57Z

hydroper
May 12, 2024

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.

2 replies

joshtynjala May 13, 2024

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 May 13, 2024

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

Fancy2209 · 2024-07-01T23:25:31Z

Fancy2209
Jul 1, 2024

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);
}

0 replies

PippoApps · 2024-08-02T16:43:03Z

PippoApps
Aug 2, 2024

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 :)

3 replies

ajwfrost Aug 2, 2024
Maintainer

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 Aug 2, 2024

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 Aug 5, 2024
Maintainer Author

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

Fancy2209 · 2025-01-11T18:50:13Z

Fancy2209
Jan 11, 2025

Could import flash.display.Stage as NativeStage be implemented?
As in, beeing able to import a Class with a different name

0 replies

Fancy2209 · 2025-04-04T09:31:55Z

Fancy2209
Apr 4, 2025

I'd love Generics and Unions to be implemented in a future AS3 revision
AS3 is a typed language, but it is very annoying to be able to make a class that can be of many types (e.g. a Polygon class that could either be a Polygon<Number> or a Polygon<Point> depending on what the data used to make it is)
Having multiple static classes that create a class from another just doesn't feel great
Vector kinda has Generics, but this is not exposed to everything.
Unions are great for if a function needs to return or take multiple types
eg a function processInputEvent could go from processInputEvent(e:Event):void to processInputEvent(e:MouseEvent|KeyboardEvent|GameInputEvent):void, this woud make it's usage clearer

Unions I can see as something that could be useful for generics
eg class Polygon could turn into

public class Polygon<T extends Number | float | Point>
{
    private var _coordinates:Vector.<T>;
    public function Polygon(coords:Vector.<T>)
    {
        this._coordinates = coords
    }
}

and called like var poly:Polygon<float> = new Polygon<float>(new <float>[0,0, 0,1, 1,1, 1,0, 0,0])

0 replies

Molisson · 2025-05-21T21:18:42Z

Molisson
May 21, 2025

The exponentiation operator from JavaScript, roughly the equivalent to Math.pow() function

Consider this following example:

trace( Math.pow( 3, 4 ) ); // logs 81

this would be:

trace( 3 ** 4 ); // logs 81

This could help in making more readability for users.

See here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Exponentiation

0 replies

shaucky · 2025-08-02T15:01:06Z

shaucky
Aug 2, 2025

Bulk Assignment Operator ()=

The ()= operator allows developers to assign the same value to multiple properties or variables simultaneously in a compact and readable way.

For example:

(btn.upState, btn.overState, btn.downState, btn.hitTestState) = sprite;

This would be equivalent to the verbose form:

var temp:* = sprite;
btn.upState = temp;
btn.overState = temp;
btn.downState = temp;
btn.hitTestState = temp;

The left-expression is a parenthesized list of identifiers.
The right-expression is the value once.
All l-values in the list are assigned that result.

0 replies

Actionscript Language Ideas #2152

Uh oh!

Uh oh!

marchbold Sep 19, 2022 Maintainer

Replies: 79 comments · 168 replies

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

marchbold Sep 19, 2022 Maintainer Author

Uh oh!

Uh oh!

ajwfrost Sep 20, 2022 Maintainer

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

marchbold Sep 19, 2022 Maintainer Author

Uh oh!

Uh oh!

marchbold Sep 22, 2022 Maintainer Author

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

marchbold
Sep 19, 2022
Maintainer

Replies: 79 comments 168 replies

marchbold
Sep 19, 2022
Maintainer Author

ajwfrost Sep 20, 2022
Maintainer

marchbold
Sep 19, 2022
Maintainer Author

marchbold Sep 22, 2022
Maintainer Author