added log as a primitive function

.eslintrc

@@ -4,6 +4,7 @@
  "node": true,
  "es6": true,
  "jest": true,
+ "jasmine": true,
  },
  "ecmaFeatures": {
  "generators": true,

src/Closure.js

@@ -1,7 +1,7 @@
 import invariant from 'fbjs/lib/invariant';
 
 import { batchExtendEnv, extendEnv } from './Environment';
-const CLOSURE_TYPE_FLAG = Symbol('CLOSURE_TYPE_FLAG');
+import { CLOSURE_TYPE_FLAG } from './typeFlags';
 
 /*
  * As we've said,

src/Environment.js

@@ -23,7 +23,7 @@ const emptyEnv = iMap({
 const lookupEnv = (name, env) => {
  if (!env.has(name)) {
  throw new Error(
- `* Uncaught ReferenceError: ${name} is not defined. env snapshot: ${env.toString()}`,
+ `Uncaught ReferenceError: ${name} is not defined. env snapshot: ${env.toString()}`,
  );
  }
 

src/Interp/ExpressionInterp.js

@@ -12,6 +12,10 @@ import {
  applyClosure,
 } from '../Closure';
 
+import { CLOSURE_TYPE_FLAG, NATIVE_FUNC_FLAG } from '../typeFlags';
+
+import Prims from '../Prims';
+
 import Options from '../Options';
 
 import { interp as statementInterp } from './StatementInterp';
@@ -33,6 +37,12 @@ const interp = (exp, env) => {
 
  case 'Identifier': {
  const { name } = exp;
+
+ // @TODO document this
+ if (Object.keys(Prims).includes(name)) {
+ return Prims[name];
+ }
+
  return lookupEnv(name, env);
  }
 
@@ -51,10 +61,21 @@ const interp = (exp, env) => {
  case 'CallExpression': {
  const { callee, arguments: rawArgs } = exp;
  // here we recur on both sides
- const closure = interp(callee, env);
  const vals = rawArgs.map((obj) => interp(obj, env));
+ const closureOrFunc = interp(callee, env);
 
- return applyClosure(interp, closure, vals, env, Options.isLexical);
+ // @TODO document this
+ switch (closureOrFunc.type) {
+ case CLOSURE_TYPE_FLAG: {
+ return applyClosure(interp, closureOrFunc, vals, env, Options.isLexical);
+ }
+ case NATIVE_FUNC_FLAG: {
+ return closureOrFunc.func.apply(null, vals);
+ }
+ default: {
+ throw new Error(`unsupported ~closure type ${closureOrFunc.type}`);
+ }
+ }
  }
 
  case 'UnaryExpression': {

src/Interp/__tests__/ExpressionInterp-test.js

@@ -10,11 +10,13 @@ import { makeClosure } from '../../Closure';
 import Options from '../../Options';
 
 jest.unmock('../index')
+ .unmock('../../typeFlags')
  .unmock('../../Parser')
  .unmock('../ExpressionInterp')
  .unmock('../StatementInterp')
  .unmock('../../Environment')
  .unmock('../../Closure')
+ .unmock('../../Prims')
  .unmock('../../Options');
 
 const parseAndgetExp = (code) => parse(code).body[0].expression;
@@ -209,6 +211,18 @@ describe('Interp', () => {
  })());
  });
 
+ it('should return undefined when there\'s no return', () => {
+ expect(interpExp(`(() => {
+ const fact = (x) => (x < 2 ? 1 : x * fact(x - 1));
+ const bar = 140;
+ bar;
+ })()`)).toBe((() => {
+ const fact = (x) => (x < 2 ? 1 : x * fact(x - 1));
+ const bar = 140;
+ bar; // eslint-disable-line no-unused-expressions
+ })());
+ });
+
  it('should support dynamic scope', () => {
  Options.isLexical = false;
 
@@ -236,4 +250,27 @@ describe('Interp', () => {
 
  Options.isLexical = true;
  });
+
+ it('should support `log` as a native func call', () => {
+ spyOn(console, 'log');
+
+ expect(interpExp(`(() => {
+ const fact = (x) => (x < 2 ? 1 : x * fact(x - 1));
+ log(fact(5));
+ log(256);
+ const foo = 12;
+ const bar = 140;
+ log(bar);
+ return foo + bar;
+ })()`)).toBe((() => {
+ const foo = 12;
+ const bar = 140;
+ return foo + bar;
+ })());
+
+ expect(console.log.calls.count()).toEqual(3); // eslint-disable-line no-console
+ expect(console.log.calls.argsFor(0)).toEqual([ 120 ]); // eslint-disable-line no-console
+ expect(console.log.calls.argsFor(1)).toEqual([ 256 ]); // eslint-disable-line no-console
+ expect(console.log.calls.argsFor(2)).toEqual([ 140 ]); // eslint-disable-line no-console
+ });
 });

src/Prims.js

@@ -1,19 +1,18 @@
-import { makeClosure } from './Closure';
-import { log } from './Writer';
-import { emptyEnv } from './Environment';
+import { NATIVE_FUNC_FLAG } from './typeFlags';
 
-const LogClosure = makeClosure(
- [ 'x' ], {
- type: 'NativeFuncCall',
- value: log,
- },
- emptyEnv,
+const wrapNativeFunc = (params, func) => ({
+ type: NATIVE_FUNC_FLAG,
+ params,
+ func,
+});
+
+const logFunc = wrapNativeFunc(
+ [ 'x' ],
+ (x) => { console.log(x); }, // eslint-disable-line no-console
 );
 
 const Prims = {
- log: LogClosure,
+ log: logFunc,
 };
 
-export {
- Prims,
-};
+export default Prims;

src/typeFlags.js

@@ -0,0 +1,2 @@
+export const CLOSURE_TYPE_FLAG = Symbol('CLOSURE_TYPE_FLAG');
+export const NATIVE_FUNC_FLAG = Symbol('NATIVE_FUNC_FLAG');