Change Details

If I understand the #create coallescing strategy... A brilliant idea crossed my mind how to facilitate `#create` ctor argument chaining, in a way that is respectful of typical OOP patterns. Rather than apply a single `_this` ubiquitously over the `#constList` `ARRAY`, allow each of the methods to transform the current `_this` for the next parent call in succession. Prototype SQF might look like this: ``` // Assuming in derivation order, from most recent to parent private _ctors = [...] { [_self call [_x, _this]] params ["_next", []]; _this = _next; } forEach _ctors; ``` Allowing the current ctor `_x` to return a `_next` or may return nothing at all, defaults to `[]` for the next ctor in succession. Thoughts, concerns, questions? What do y'all think? Maybe this could be got into the next dev branch, and assuming it isn't too disruptive of early HMO adopters.

If I understand the #create coallescing strategy... A brilliant idea crossed my mind how to facilitate `#create` ctor argument chaining, in a way that is respectful of typical OOP patterns. Rather than apply a single `_this` ubiquitously over the `#constList` `ARRAY`, allow each of the methods to transform the current `_this` for the next parent call in succession. Prototype SQF might look like this: ``` // Assuming in derivation order, from most recent to parent private _ctors = _self getOrDefault ["#constrList", []]; { [_self call [_x, _this]] params ["_next", []]; _this = _next; } forEach _ctors; ``` Allowing the current ctor `_x` to return a `_next` or may return nothing at all, defaults to `[]` for the next ctor in succession. Thoughts, concerns, questions? What do y'all think? Maybe this could be got into the next dev branch, and assuming it isn't too disruptive of early HMO adopters.

If I understand the #create coallescing strategy... A brilliant idea crossed my mind how to facilitate `#create` ctor argument chaining, in a way that is respectful of typical OOP patterns. Rather than apply a single `_this` ubiquitously over the `#constList` `ARRAY`, allow each of the methods to transform the current `_this` for the next parent call in succession. Prototype SQF might look like this: ``` // Assuming in derivation order, from most recent to parent private _ctors = [...]_self getOrDefault ["#constrList", []]; { [_self call [_x, _this]] params ["_next", []]; _this = _next; } forEach _ctors; ``` Allowing the current ctor `_x` to return a `_next` or may return nothing at all, defaults to `[]` for the next ctor in succession. Thoughts, concerns, questions? What do y'all think? Maybe this could be got into the next dev branch, and assuming it isn't too disruptive of early HMO adopters.