feat: add logic for eager evaluation in REPL

lib/node_modules/@stdlib/repl/lib/defaults.js

@@ -106,7 +106,10 @@ function defaults() {
 			'syntaxHighlighting': void 0,
 
 			// Theme for syntax highlighting:
-			'theme': 'stdlib-ansi-basic'
+			'theme': 'stdlib-ansi-basic',
+
+			// Flag indicating whether to enable eager Evaluation (note: default depends on whether TTY):
+			'eagerEvaluation': void 0
 		}
 	};
 }

lib/node_modules/@stdlib/repl/lib/eager_evaluation.js

@@ -0,0 +1,267 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable no-underscore-dangle, no-restricted-syntax, no-invalid-this */
+
+'use strict';
+
+// MODULES //
+
+var readline = require( 'readline' );
+var inspect = require( 'util' ).inspect;
+var logger = require( 'debug' );
+var parse = require( 'acorn' ).parse;
+var replace = require( '@stdlib/string/replace' );
+var setNonEnumerableReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var processCommand = require( './process_command.js' );
+var compileCommand = require( './compile_command.js' );
+
+
+// VARIABLES //
+
+var debug = logger( 'repl:EE' );
+var AOPTS = {
+	'ecmaVersion': 'latest'
+};
+var tempDB = {
+	'base_sin': {
+		'isPure': true
+	}
+};
+
+
+// MAIN //
+
+/**
+* Constructor for creating a multi-line handler.
+*
+* @private
+* @param {REPL} repl - repl instance
+* @param {Object} rli - readline instance
+* @param {Boolean} enabled - boolean indicating whether the syntax-highlighter should be initially enabled
+* @returns {EagerEvaluator} eager-evaluator instance
+*/
+function EagerEvaluator( repl, rli, enabled ) {
+	this._repl = repl;
+	this._rli = rli;
+	this._cmd = repl._cmd;
+	this._enabled = enabled;
+	this._isPreview = false;
+
+	return this;
+}
+
+/**
+* Callback for handling a "keypress" event.
+*
+* @name onKeyPress
+* @memberof EagerEvaluator.prototype
+* @type {Function}
+* @param {string} data - input data
+* @param {(Object|void)} key - key object
+* @returns {void}
+*
+*/
+setNonEnumerableReadOnly(EagerEvaluator.prototype, 'onKeypress', function onKeyPress(data, key) {
+	var cursorPosition;
+	var executable;
+	var nlInd;
+	var code;
+	var opts;
+	var pre;
+	var res;
+	var tmp;
+
+	if (!this._enabled || this._rli.line === '' || key.name === 'paste-start' || (key.name === 'o' && key.ctrl) || key.name === 'return') {
+		return;
+	}
+
+	code = this._cmd.join('\n') + this._rli.line;
+	opts = {
+		'timeout': this._repl._timeout,
+		'displayErrors': false,
+		'breakOnSigint': true // Node.js >=6.3.0
+	};
+	if (!this.isSideEffectFree(code)) {
+		debug('code have side effect');
+		return;
+	}
+	debug('try to process command');
+	tmp = processCommand(code);
+	if (tmp instanceof Error) {
+		debug( 'getting error %s', tmp.message );
+		return;
+	}
+	debug('try to compile command');
+	executable = compileCommand(tmp);
+	if (executable instanceof Error) {
+		debug( 'getting error %s', executable.message );
+		return;
+	}
+	try {
+		if ( this._repl._sandbox ) {
+			res = executable.compiled.runInContext( this._repl._context, opts );
+		} else {
+			res = executable.compiled.runInThisContext( opts );
+		}
+	} catch (err) {
+		debug( 'getting error when executing the command %s', err.message );
+		return;
+	}
+
+	res = inspect(res);
+	nlInd = res.indexOf('\n');
+	if ( nlInd !== -1 ) {
+		res = res.slice(0, nlInd ) + '...';
+	}
+	cursorPosition = this._rli.cursor;
+	pre = replace( this._repl._outputPrompt, '%d', (this._repl._count+1).toString() );
+	this._repl._ostream.write( '\n\u001b[90m' + pre + res + '\u001b[0m' );
+	readline.moveCursor(this._repl._ostream, 0, -1);
+	readline.cursorTo(this._repl._ostream, cursorPosition + this._repl.promptLength() );
+	this._isPreview = true;
+	executable.raw = code;
+	this._repl._isEagerEvaluated = true;
+	this._repl._eagerEvaluatedExecutable = executable;
+	debug( 'sucess' );
+});
+
+/**
+* Callback which should be invoked**before** a "keypress" event.
+*
+* @name beforeKeyPress
+* @memberof EagerEvaluator.prototype
+* @type {Function}
+* @param {string} data - input data
+* @param {(Object|void)} key - key object
+* @returns {void}
+*
+*/
+setNonEnumerableReadOnly(EagerEvaluator.prototype, 'beforeKeypress', function beforeKeyPress(data, key) {
+	var cursorPosition;
+
+	if (!this._isPreview || key.name === 'return' || (key.name === 'o' && key.ctrl) ) {
+		return;
+	}
+	if ( this._isPreview ) {
+		cursorPosition = this._rli.cursor;
+		readline.moveCursor( this._repl._ostream, 0, 1 );
+		readline.clearLine( this._repl._ostream, 0 );
+		readline.moveCursor( this._repl._ostream, 0, -1 );
+		readline.cursorTo( this._repl._ostream, cursorPosition + this._repl.promptLength() );
+		this._isPreview = false;
+	}
+	this._repl._isEagerEvaluated = false;
+	this._repl._eagerEvaluatedExecutable = void 0;
+});
+
+/**
+* Tells weather code is side effect free or not.
+*
+* @name isSideEffectFree
+* @memberof EagerEvaluator.prototype
+* @type {Function}
+* @param {string} code - input code
+* @returns {boolean} - boolean indicate weather code is side effect free or not.
+*
+*/
+setNonEnumerableReadOnly( EagerEvaluator.prototype, 'isSideEffectFree', function isSideEffectFree( code ) {
+	var ast;
+	var i;
+
+	try {
+		ast = parse( code, AOPTS );
+	}
+	catch (err) {
+		debug( 'getting error when generating AST %S ', err );
+		return false;
+	}
+	// Iterate from each node in body
+	for ( i = 0; i < ast.body.length; i++ ) {
+		if ( !traverse( ast.body[ i ] ) ) {
+			return false;
+		}
+	}
+	return true;
+
+	/**
+	* Function which recursivly traverse from the node and tells weather node is side effect free or not.
+	*
+	* @private
+	* @param {JSON} node - ast node.
+	* @returns {Boolean} - Boolean indicate weather node is side effect free or not.
+	*/
+	function traverse(node) {
+		var fname;
+		var i;
+		if ( !node ) {
+			return false;
+		}
+		if ( node.type === 'Literal' || node.type === 'Identifier' || node.type === 'MemberExpression' ) {
+			return true;
+		}
+		if ( node.type === 'BinaryExpression' ) {
+			if ( traverse( node.left ) && traverse( node.right ) ) {
+				return true;
+			}
+		}
+		else if ( node.type === 'ExpressionStatement' ) {
+			if ( traverse( node.expression ) ) {
+				return true;
+			}
+		}
+		else if ( node.type === 'CallExpression' ) {
+			fname = getFunctionName( node.callee );
+			if ( tempDB[fname] && tempDB[fname].isPure ) {
+				// Iterating through arguments
+				for ( i = 0; i < node.arguments.length; i++ ) {
+					if ( !traverse( node.arguments[ i ] ) ) {
+						return false;
+					}
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	* Get the underscore seprate function name for the member function call.
+	*
+	* @private
+	* @param {JSON} node - ast node
+	* @returns {string} - underscore seprated function name for the member function call
+	*/
+	function getFunctionName( node ) {
+		if ( !node ) {
+			return '';
+		}
+		if ( node.type === 'MemberExpression' ) {
+			return getFunctionName(node.object) + '_' + node.property.name;
+		}
+		if ( node.type === 'Identifier' ) {
+			return node.name;
+		}
+		return '';
+	}
+} );
+
+
+// EXPORTS //
+
+module.exports = EagerEvaluator;

lib/node_modules/@stdlib/repl/lib/main.js

@@ -68,6 +68,7 @@
 var PreviewCompleter = require( './completer_preview.js' );
 var AutoCloser = require( './auto_close_pairs.js' );
 var SyntaxHighlighter = require( './syntax_highlighter.js' );
+var EagerEvaluator = require( './eager_evaluation.js' );
 var ALIAS_OVERRIDES = require( './alias_overrides.js' );
 var SETTINGS = require( './settings.js' );
 var SETTINGS_VALIDATORS = require( './settings_validators.js' );
@@ -130,7 +131,7 @@
 * // Close the REPL:
 * repl.close();
 */
 function REPL( options ) {
 	var ostream;
 	var themes;
 	var opts;
@@ -160,6 +161,14 @@
 	opts.settings.autoDisableBracketedPasteOnExit = ( opts.settings.autoDisableBracketedPasteOnExit === void 0 ) ? opts.isTTY : opts.settings.autoDisableBracketedPasteOnExit; // eslint-disable-line max-len
 	opts.settings.syntaxHighlighting = ( opts.settings.syntaxHighlighting === void 0 ) ? opts.isTTY : opts.settings.syntaxHighlighting; // eslint-disable-line max-len
 
+	// This is temparary because eager evaluation conflicting with the some tests.
+	if ( options && options.settings && options.settings.eagerEvaluation !== void 0 ) {
+		opts.settings.eagerEvaluation = options.settings.eagerEvaluation;
+	}
+	else {
+		opts.settings.eagerEvaluation = ( opts.settings.eagerEvaluation === void 0 ) ? opts.isTTY : opts.settings.eagerEvaluation; // eslint-disable-line max-len
+	}
+
 	debug( 'Options: %s', JSON.stringify({
 		'input': '<readable_stream>',
 		'output': '<writable_stream>',
@@ -254,6 +263,12 @@
 	// Initialize an internal flag indicating whether we've received a `SIGINT` signal:
 	setNonEnumerable( this, '_SIGINT', false );
 
+	// Initialize an internal flag indicating whether command is eagerlyEvaluated:
+	setNonEnumerable( this, '_isEagerEvaluated', false );
+
+	// Initialize as internal variable for caching the compiled object from eagerEvaluation
+	setNonEnumerable( this, '_eagerEvaluatedExecutable', void 0 );
+
 	// Initialize an internal variable for caching the result of the last successfully evaluated command:
 	setNonEnumerable( this, '_ans', void 0 );
 
@@ -293,11 +308,14 @@
 	// Initialize a syntax-highlighter:
 	setNonEnumerableReadOnly( this, '_syntaxHighlighter', new SyntaxHighlighter( this, this._ostream, this._settings.syntaxHighlighting ) );
 
+	// Initialize a eagerEvaluator:
+	setNonEnumerableReadOnly( this, '_eagerEvaluator', new EagerEvaluator( this, this._rli, this._settings.eagerEvaluation ) );
+
 	// Cache a reference to the private readline interface `ttyWrite` to allow calling the method when wanting default behavior:
 	setNonEnumerableReadOnly( this, '_ttyWrite', this._rli._ttyWrite );
 
 	// Overwrite the private `ttyWrite` method to allow processing input before a "keypress" event is triggered:
 	this._rli._ttyWrite = beforeKeypress; // WARNING: overwriting a private property
 
 	// Add event listeners:
 	this._rli.on( 'close', onClose );
@@ -317,9 +335,9 @@
 	// Write a welcome message:
 	this._wstream.write( opts.welcome );
 
 	// TODO: check whether to synchronously initialize a REPL history file
 
 	// TODO: check whether to synchronously initialize a REPL log file
 
 	// Add any provided user-defined themes...
 	if ( opts.themes ) {
@@ -363,6 +381,8 @@
 		completed = self._previewCompleter.beforeKeypress( data, key );
 		FLG = self._editorActions.beforeKeypress( data, key );
 
+		self._eagerEvaluator.beforeKeypress( data, key );
+
 		// If ENTER keypress is encountered or if a preview was completed while navigating, gracefully close the completer...
 		if ( completed || ( key && key.name === 'return' ) ) {
 			self._completerEngine.closeCompleter();
@@ -398,6 +418,7 @@
 			self._previewCompleter.clear();
 		}
 		self._completerEngine.onKeypress( data, key );
+		self._eagerEvaluator.onKeypress( data, key );
 		self._multilineHandler.onKeypress( data, key );
 		self._syntaxHighlighter.onKeypress();
 		self._previewCompleter.onKeypress( data, key );
@@ -509,9 +530,9 @@
 		// Update the internal command history buffer: [..., <id>, <cmd>, <success>, ...]
 		self._history.push( self._count, cmd, success );
 
 		// TODO: if successful and if necessary, (asynchronously?) write the command to a history file (question: do we only want to write successful commands to the history file? maybe we need to option for limiting to successful commands?)
 
 		// TODO: if necessary, (asynchronously?) write the command and result to a log file (JSON serialization?)
 	}
 }
 
@@ -750,7 +771,7 @@
 
 	// Before creating a new execution context in a non-sandboxed environment, remove current workspace variables in order to allow garbage collection and avoid memory leaks (e.g., variables/functions declared during a REPL session which might remain bound to the environment `global` after clearing a REPL):
 	if ( this._sandbox === false ) {
 		// WARNING: in a non-sandboxed environment, if a global variable is externally introduced during a REPL session (i.e., introduced via a mechanism outside of the REPL environment), we will delete that global variable, which means the following logic may introduce unintended side-effects for this particular edge case (e.g., application code may expect the presence of the subsequently deleted global variable). While not ideal, (a) user applications should not be introducing globals to begin with and (b) the probability of a user running a REPL session, a user clearing that REPL session, AND a global variable being introduced between starting a REPL and clearing the REPL should be negligible.
 		tmp = this._context.vars();
 		for ( i = 0; i < tmp.length; i++ ) {
 			if ( isConfigurableProperty( this._context, tmp[ i ] ) ) {
@@ -1449,7 +1470,7 @@
 	}
 	nargs = arguments.length;
 	if ( nargs === 0 ) {
-		return assign( {}, this._settings );
+		return assign({}, this._settings );
 	}
 	name = arguments[ 0 ];
 	if ( !isString( name ) ) {

lib/node_modules/@stdlib/repl/lib/multiline_handler.js

@@ -621,6 +621,14 @@ setNonEnumerableReadOnly( MultilineHandler.prototype, 'processLine', function pr
 		return;
 	}
 	this._multiline.active = false; // false until proven otherwise
+	if ( this._repl._isEagerEvaluated ) {
+		this.resetInput();
+		this._queue.push( this._repl._eagerEvaluatedExecutable );
+		drain( this._repl );
+		this._repl_isEagerEvaluated = false;
+		this._repl._eagerEvaluatedExecutable = void 0;
+		return;
+	}
 	cmd = this._cmd.join( '\n' );
 	if ( RE_WHITESPACE.test( cmd ) ) {
 		this.resetInput();

lib/node_modules/@stdlib/repl/test/integration/test.auto_close_pairs.js

@@ -145,7 +145,9 @@ function defaultSettings() {
 		'autoDeletePairs': false,
 		'autoPage': false,
 		'completionPreviews': false,
-		'syntaxHighlighting': false
+		'syntaxHighlighting': false,
+		'eagerEvaluation': false
+
 	};
 }
 

lib/node_modules/@stdlib/repl/test/integration/test.completer_engine.js

@@ -48,6 +48,7 @@ function defaultSettings() {
 		'autoDisableBracketedPasteOnExit': false,
 		'completionPreviews': false,
 		'syntaxHighlighting': false,
+		'eagerEvaluation': false,
 		'autoPage': false
 	};
 }