Demonstrate how to guard targeted functions invocations using a `super` version of try-catch: The guard will report exceptions (with stack traces) via the logger function. If the target function returns a promise, then a rejection handler is attached; which will also report rejections and possible stack traces.

makeTryCatch.as

    /**
     * @param notifyFn      Function used to log.debug exception information
     * @param scope         Object Receiver for the notifyFn invocation
     *
     * @return Function used to guard and invoke the targeted actionFn
     */
    public function makeTryCatch( receiver:Object, notifyFn:Function = null ) : Function
    {
        // Lookup a default logger function if not specified
        notifyFn ||= receiver[ "debug" ] as Function;

            /**
             * Report error (with stack trace if possible) to the logger function
             */
            function reportError( reason : * ) : *
            {
                if ( notifyFn != null)
                {
                    var message : String = String( reason );

                    var error   : Error  = reason as Error;
                    if ( error != null )
                    {
                        message = error.message + "\n" + error.getStackTrace();
                    }

                    notifyFn.apply( receiver, [ message ] );
                }

                return reason;
            }

                /**
                 * Publish the tryCatch() guard 'n report function
                 */
        return function tryCatch( actionFn : Function, scope:Object=null ) : *
               {
                   try
                   {
                       // Invoke the targeted `actionFn`
                       var result  : *       = actionFn.apply( scope );
                       var promise : Promise = result as Promise;

                       if ( promise != null )
                       {
                           // Catch and report any promise rejection reason...
                           promise.otherwise( reportError );
                       }

                       actionFn = null;
                       return result;

                   }  catch ( e:Error ) {

                       actionFn = null;
                       reportError( e );

                       throw e;
                   }
               };
    }

var logger   = new Logger( "MyAsyncMusicService" );
var tryCatch = makeTryCatch( logger );

tryCatch( function( ):*
{
    return musicPlayer
            .play()
            .then( announceState( PlayStateEnum.PLAYING ) );
},this);

Please note, the above code presumes use of the AS3 Promises library