create apply metaprocedure

Author: s-kybound

src/createContext.ts

@@ -38,7 +38,7 @@ import { makeWrapper } from './utils/makeWrapper'
 import * as operators from './utils/operators'
 import { stringify } from './utils/stringify'
 import { schemeVisualise } from './alt-langs/scheme/scheme-mapper'
-import { cset_eval } from './cse-machine/scheme-macros'
+import { cset_apply, cset_eval } from './cse-machine/scheme-macros'
 import { Transformers } from './cse-machine/interpreter'
 
 export class LazyBuiltIn {
@@ -619,11 +619,16 @@ export const importBuiltins = (context: Context, externalBuiltIns: CustomBuiltIn
         defineBuiltin(context, 'list$45$$62$string(xs)', scheme_libs.list$45$$62$string)
 
         // Scheme apply is needed here to help in the definition of the Scheme Prelude.
-        defineBuiltin(context, 'apply(f, ...args)', scheme_libs.apply, 2)
+        defineBuiltin(context, 'apply(f, ...args)', cset_apply, 2)
 
       case Chapter.SCHEME_1:
         // Display
-        defineBuiltin(context, 'display(val)', (val: any) => display(schemeVisualise(val)))
+        defineBuiltin(
+          context,
+          'display(val, prepend = undefined)',
+          (val: any, ...str: string[]) => display(schemeVisualise(val), ...str),
+          1
+        )
         defineBuiltin(context, 'newline()', () => display(''))
 
         // I/O

src/cse-machine/interpreter.ts

@@ -79,9 +79,10 @@ import {
   setVariable,
   valueProducing
 } from './utils'
-import { isEval, schemeEval } from './scheme-macros'
+import { isApply, isEval, schemeEval } from './scheme-macros'
 import { Transformer } from './patterns'
 import { isSchemeLanguage } from '../alt-langs/mapper'
+import { flattenList, isList } from './macro-utils'
 
 type CmdEvaluator = (
   command: ControlItem,
@@ -998,6 +999,37 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       handleRuntimeError(context, new errors.CallingNonFunctionValue(func, command.srcNode))
     }
 
+    if (isApply(func)) {
+      // Check for number of arguments mismatch error
+      checkNumberOfArguments(context, func, args, command.srcNode)
+
+      // get the procedure from the arguments
+      const proc = args[0]
+      // get the last list from the arguments
+      // (and it should be a list)
+      const last = args[args.length - 1]
+      if (!isList(last)) {
+        handleRuntimeError(
+          context,
+          new errors.ExceptionError(new Error('Last argument of apply must be a list'))
+        )
+      }
+      // get the rest of the arguments between the procedure and the last list
+      const rest = args.slice(1, args.length - 1)
+      // convert the last list to an array
+      const lastAsArray = flattenList(last)
+      // combine the rest and the last list
+      const combined = [...rest, ...lastAsArray]
+
+      // push the items back onto the stash
+      stash.push(proc)
+      stash.push(...combined)
+
+      // prepare a function call for the procedure
+      control.push(instr.appInstr(combined.length, command.srcNode))
+      return
+    }
+
     if (isEval(func)) {
       // Check for number of arguments mismatch error
       checkNumberOfArguments(context, func, args, command.srcNode)
@@ -1057,17 +1089,6 @@ const cmdEvaluators: { [type: string]: CmdEvaluator } = {
       // Check for number of arguments mismatch error
       checkNumberOfArguments(context, func, args, command.srcNode)
 
-      // const dummyContCallExpression = makeDummyContCallExpression('f', 'cont')
-
-      // // Restore the state of the stash,
-      // // but replace the function application instruction with
-      // // a resume continuation instruction
-      // stash.push(func)
-      // // we need to push the arguments back onto the stash
-      // // as well
-      // stash.push(...args)
-      // control.push(instr.resumeContInstr(command.numOfArgs, dummyContCallExpression))
-
       // get the C, S, E from the continuation
       const contControl = func.getControl()
       const contStash = func.getStash()

src/cse-machine/scheme-macros.ts

@@ -21,9 +21,38 @@ import { flattenList, isList } from './macro-utils'
 // this needs to be better but for now it's fine
 export type SchemeControlItems = List | _Symbol | SchemeNumber | boolean | string
 
+/**
+ * A metaprocedure used to detect for the apply function object.
+ * If the interpreter sees this specific function,
+ * it will take all of the operands, and apply the second to second last operands as well as the last operand (must be a list)
+ * to the first operand (which must be a function).
+ */
+export class Apply extends Function {
+  private static instance: Apply = new Apply()
+
+  private constructor() {
+    super()
+  }
+
+  public static get(): Apply {
+    return Apply.instance
+  }
+
+  public toString(): string {
+    return 'apply'
+  }
+}
+
+export const cset_apply = Apply.get()
+
+export function isApply(value: any): boolean {
+  return value === cset_apply
+}
+
 /**
  * A metaprocedure used to detect for the eval function object.
  * If the interpreter sees this specific function,
+ * it will transfer its operand to the control component.
  */
 export class Eval extends Function {
   private static instance: Eval = new Eval()
@@ -508,28 +537,6 @@ export function makeDummyIdentifierNode(name: string): es.Identifier {
   }
 }
 
-/**
- * Provides an adequate representation of what calling
- * eval looks like, to give to the
- * APPLICATION instruction.
- */
-export function makeDummyEvalExpression(callee: string, argument: string): es.CallExpression {
-  return {
-    type: 'CallExpression',
-    optional: false,
-    callee: {
-      type: 'Identifier',
-      name: callee
-    },
-    arguments: [
-      {
-        type: 'Identifier',
-        name: argument
-      }
-    ]
-  }
-}
-
 /**
  * Convert a scheme expression (that is meant to be evaluated)
  * into an estree expression, using eval.

src/cse-machine/utils.ts

@@ -21,7 +21,7 @@ import {
 } from './types'
 import Closure from './closure'
 import { Continuation, isCallWithCurrentContinuation } from './continuations'
-import { isEval } from './scheme-macros'
+import { isApply, isEval } from './scheme-macros'
 import { _Symbol } from '../alt-langs/scheme/scm-slang/src/stdlib/base'
 import { is_number } from '../alt-langs/scheme/scm-slang/src/stdlib/core-math'
 
@@ -581,6 +581,15 @@ export const checkNumberOfArguments = (
       )
     }
     return undefined
+  } else if (isApply(callee)) {
+    // apply should have at least two arguments
+    if (args.length < 2) {
+      return handleRuntimeError(
+        context,
+        new errors.InvalidNumberOfArguments(exp, 2, args.length, false)
+      )
+    }
+    return undefined
   } else if (callee instanceof Continuation) {
     // Continuations have variadic arguments,
     // and so we can let it pass