@ironm00n/pyret-lang 0.0.1 → 0.0.2

package/src/js/trove/charts-lib.js

@@ -11,6 +11,7 @@
     values: {
       'pie-chart': "tany",
       'dot-chart': "tany",
+      'categorical-dot-chart': "tany",
       'bar-chart': "tany",
       'multi-bar-chart': "tany",
       'histogram': "tany",
@@ -174,14 +175,15 @@
       const hAxis = options.hAxis ??= {};
       const vAxis = options.vAxis ??= {};
 
-      const gridlineColor = getColorOrDefault(globalOptions['gridlineColor'], "#aaa");
+      const showGridlines = isTrue(globalOptions['show-grid-lines']);
+      const gridlineColor = getColorOrDefault(globalOptions['gridlineColor'], undefined);
 
-      const minorGridlineColor = getColorOrDefault(globalOptions['minorGridlineColor'], "#ddd");
+      const minorGridlineColor = getColorOrDefault(globalOptions['minorGridlineColor'], undefined);
 
       const minorGridlineMinspacing = toFixnum(globalOptions['minorGridlineMinspacing'])
 
-      hAxis.gridlines = {color: gridlineColor};
-      vAxis.gridlines = {color: gridlineColor};
+      hAxis.gridlines = {show: showGridlines, color: gridlineColor};
+      vAxis.gridlines = {show: showGridlines, color: gridlineColor};
 
       cases(RUNTIME.ffi.isOption, 'Option', globalOptions['gridlineMinspacing'], {
         none: function () {
@@ -680,6 +682,7 @@
             [axesConfig.secondary.dir + '2']: { scale: 'secondary', field: 'value1' },
             fill: [
               { test: 'isValid(datum.image)', value: 'transparent' },
+              { test: 'isValid(datum.color)', field: 'color' },
               { scale: 'color', field: 'series' }
             ],
             tooltip,
@@ -1756,6 +1759,7 @@
       const color = getColorOrDefault(get(rawData, 'color'), defaultColor);
       const legend = get(rawData, 'legend') || '';
       const pointSize = toFixnum(get(rawData, 'point-size'));
+      const autosizeImage = isTrue(get(rawData, 'useImageSizes'));
 
       const points = RUNTIME.ffi.toArray(get(rawData, 'ps'));
 
@@ -1790,7 +1794,7 @@
           ]
         },
         {
-          name: 'binnedTable',
+          name: 'binnedRawTable',
           source: 'rawTable',
           transform: [
             { type: 'formula', as: 'binNum', expr: 'floor((datum.value - dataRange[0]) / binSize)' },
@@ -1798,7 +1802,17 @@
             { type: 'formula', as: 'bin1', expr: 'datum.bin0 + binSize' },
             { type: 'stack', groupby: ['binNum'], offset: 'zero', as: ['y0', 'y1'] }
           ]
-        }
+        },
+        {
+          name: `binnedTable`,
+          source: `binnedRawTable`,
+          transform: [ { type: 'filter', expr: '!isValid(datum.image)' } ]
+        },
+        {
+          name: `binnedImages`,
+          source: `binnedRawTable`,
+          transform: [ { type: 'filter', expr: 'isValid(datum.image)' } ]
+        },
       ];
       const signals = [
         { name: 'dotSize', value: pointSize },
@@ -1853,13 +1867,32 @@
               fill: { value: color },
               stroke: { value: 'white' },
               strokeWidth: { value: 0.25 },
-              tooltip: '{ title: datum.Label, Value: datum.value, BinNum: datum.binNum, Bin0: datum.bin0, Bin1: datum.bin1 }'
+              tooltip: { signal: '{ title: datum.label, Value: datum.value }' }
             },
             update: {
               xc: { scale: 'binScale', field: 'value' },
               yc: { signal: 'scale("dotScale", 0) - actualDotSize * (0.5 + datum.y0 % wrapMaxY)' }
             }
           }
+        },
+        {
+          type: 'image',
+          from: { data: `binnedImages` },
+          name: `ImageMarks`,
+          encode: {
+            enter: {
+              width: autosizeImage ? undefined : { value: pointSize },
+              height: autosizeImage ? undefined : { value: pointSize },
+              image: { field: 'image' },
+              tooltip: { signal: '{ title: datum.label, Value: datum.value }' }
+            },
+            update: {
+              xc: { scale: 'binScale', field: 'value' },
+              yc: { signal: 'scale("dotScale", 0) - actualDotSize * (0.5 + datum.y0 % wrapMaxY)' },
+              align: { value: 'center' },
+              baseline: { value: 'middle' }
+            },
+          }
         }
       ];
 
@@ -1879,7 +1912,124 @@
         marks,
         onExit: defaultImageReturn,
       };
-    } 
+    }
+
+    function categoricalDotChart(globalOptions, rawData) {
+      const defaultColor = default_colors[0];
+      const color = getColorOrDefault(get(rawData, 'color'), defaultColor);
+      const legend = get(rawData, 'legend') || '';
+
+      const points = RUNTIME.ffi.toArray(get(rawData, 'ps'));
+
+      const title = globalOptions['title'];
+      const width = globalOptions['width'];
+      const height = globalOptions['height'];
+      const xAxisLabel = globalOptions['x-axis'];
+      const yAxisLabel = globalOptions['y-axis'];
+      const background = getColorOrDefault(globalOptions['backgroundColor'], 'transparent');
+
+
+
+      const fixedPoints = points.map((p) => ({
+        label: get(p, 'label'),
+        count: toFixnum(get(p, 'count'))
+      }));
+      const data = [
+        {
+          name: 'bars',
+          values: fixedPoints
+        },
+        {
+          name: 'dotsData',
+          values: fixedPoints.flatMap((p) =>
+            Array.from({length: p.count}).map((_, i) => ({ label: p.label, value: i }))
+          )
+        },
+      ];
+      const signals = [
+        { name: 'dotSize', update: "scale('secondary', 1) - scale('secondary', 0)" },
+      ];
+      const scales = [
+        {
+          name: 'primary',
+          type: 'band',
+          range: 'width',
+          domain: { data: 'bars', field: 'label' }
+        },
+        {
+          name: 'secondary',
+          type: 'linear',
+          range: 'height',
+          nice: true, zero: true,
+          domain: { data: 'bars', field: 'count' }
+        }
+      ];
+      const axes = [
+        { orient: 'bottom', scale: 'primary', zindex: 1, title: xAxisLabel },
+        { orient: 'bottom', scale: 'primary', zindex: 0, grid: true, ticks: false, labels: false },
+        { orient: 'left', scale: 'secondary', grid: true, ticks: true, labels: true, title: yAxisLabel, zindex: 1 }
+      ];
+      const marks = [
+        {
+          type: 'symbol',
+          name: 'dots',
+          from: { data: 'dotsData' },
+          encode: {
+            enter: {
+              shape: { value: 'circle' },
+              fillOpacity: { value: 0.5 },
+              fill: { value: color },
+              stroke: { value: 'white' },
+              strokeWidth: { value: 0.25 },
+              tooltip: { signal: '{ title: datum.label, Value: datum.value }' },
+              xc: { scale: 'primary', field: 'label', offset: { scale: 'primary', band: 0.5 } },
+              yc: { scale: 'secondary', field: 'value', offset: { signal: '0.5 * dotSize' } },
+              size: { signal: '0.8 * 0.8 * dotSize * dotSize' },
+            }
+          }
+        },
+        {
+          type: 'rect',
+          name: 'blocks',
+          from: { data: 'bars' },
+          encode: {
+            enter: {
+              x: { scale: 'primary', field: 'label', offset: { scale: 'primary', band: 0.25 } },
+              x2: { scale: 'primary', field: 'label', offset: { scale: 'primary', band: 0.75 } },
+              y: { scale: 'secondary', value: 0 },
+              y2: { scale: 'secondary', field: 'count' },
+              tooltip: { signal: `{ title: datum.label, Count: datum.count }`},
+              stroke: { value: 'gray' },
+              strokeWidth: { value: 2 },
+              fill: { value: 'transparent' },
+            },
+            update: {
+              opacity: { value: 0 },
+            },
+            hover: {
+              opacity: { value: 1 }
+            }
+          }
+        },
+      ];
+
+      return {
+        "$schema": "https://vega.github.io/schema/vega/v6.json",
+        description: title,
+        title: title ? { text: title } : '',
+        width,
+        height,
+        padding: 0,
+        autosize: 'fit',
+        background,
+        data,
+        signals,
+        scales,
+        axes,
+        marks,
+        onExit: defaultImageReturn,
+      };
+    }
 
     function computeDomain(domainValues) {
       const domainMin = Math.min(...domainValues);
@@ -1962,6 +2112,7 @@
       const color = getColorOrDefault(get(rawData, 'color'), defaultColor);
       const legend = get(rawData, 'legend') || config.legend;
       const pointSize = toFixnum(get(rawData, 'point-size'));
+      const autosizeImage = isTrue(get(rawData, 'useImageSizes'));
       const pointshapeType = get(rawData, 'pointshapeType');
       const pointshapeSides = toFixnum(get(rawData, 'pointshapeSides'));
       const pointshapeDent = toFixnum(get(rawData, 'pointshapeDent'));
@@ -1989,6 +2140,14 @@
               none: () => undefined,
               some: (opaqueImg) => imageToCanvas(opaqueImg.val)
             }),
+            imageWidth: cases(RUNTIME.ffi.isOption, 'Option', get(p, 'image'), {
+              none: () => undefined,
+              some: (opaqueImg) => opaqueImg.val.getWidth()
+            }),
+            imageHeight: cases(RUNTIME.ffi.isOption, 'Option', get(p, 'image'), {
+              none: () => undefined,
+              some: (opaqueImg) => opaqueImg.val.getHeight()
+            }),
             imageOffsetX: cases(RUNTIME.ffi.isOption, 'Option', get(p, 'image'), {
               none: () => undefined,
               some: (opaqueImg) => opaqueImg.val.getPinholeX() / opaqueImg.val.getWidth()
@@ -2131,20 +2290,22 @@
           signal: `{ title: "${legend}", Label: datum.label, x: datum.x, y: datum.y }` },
         { signal: `{ title: "${legend}", x: datum.x, y: datum.y }` },
       ];
+      const imageScaleFactorX = autosizeImage ? '-datum.imageWidth' : -pointSize;
+      const imageScaleFactorY = autosizeImage ? '-datum.imageHeight' : -pointSize;
       marks.push({
         type: 'image',
         from: { data: `${prefix}images` },
         name: `${prefix}ImageMarks`,
         encode: {
           enter: {
-            width: { value: pointSize },
-            height: { value: pointSize },
+            width: autosizeImage ? undefined : { value: pointSize },
+            height: autosizeImage ? undefined : { value: pointSize },
             image: { field: 'image' },
             tooltip: tooltips
           },
           update: {
-            x: { scale: `xscale`, field: 'x', offset: { signal: `${-pointSize} * datum.imageOffsetX` } },
-            y: { scale: `yscale`, field: 'y', offset: { signal: `${-pointSize} * datum.imageOffsetY` } },
+            x: { scale: `xscale`, field: 'x', offset: { signal: `${imageScaleFactorX} * datum.imageOffsetX` } },
+            y: { scale: `yscale`, field: 'y', offset: { signal: `${imageScaleFactorY} * datum.imageOffsetY` } },
             stroke: { signal: `hoveredLegend === '${prefix}' ? 'white' : '${color}'` },
             strokeWidth: { signal: `(hoveredLegend === '${prefix}' ? 1 : 0)` },
             zindex: { signal: `hoveredLegend === '${prefix}' ? 1 : null` }
@@ -2643,6 +2804,9 @@
       // NOTE: For the axes, we're going to want to put the bar lines at the zeros
       // of the domains, rather than the edges of the chart
       const axes = [
+        { orient: 'bottom', scale: `xscale`, zindex: 0,
+          grid: gridlines.hAxis.gridlines.show, gridColor: gridlines.hAxis.gridlines.color,
+          domain: false, tickOpacity: 0, labelOpacity: 0 },
         { orient: 'bottom', scale: `xscale`, zindex: 1, title: xAxisLabel,
           domain: false, tickOpacity: 0, labelOpacity: 0 },
         { orient: 'bottom', scale: `xscale`, zindex: 1, 
@@ -2651,6 +2815,9 @@
                     signal: `clamp(0, domain('yscale')[0], domain('yscale')[1])`,
                     offset: { signal: 'height', mult: -1 } }
         },
+        { orient: 'left', scale: `yscale`, zindex: 0,
+          grid: gridlines.vAxis.gridlines.show, gridColor: gridlines.vAxis.gridlines.color,
+          domain: false, tickOpacity: 0, labelOpacity: 0 },
         { orient: 'left', scale: `yscale`, zindex: 1, title: yAxisLabel,
           domain: false, tickOpacity: 0, labelOpacity: 0 },
         { orient: 'left', scale: `yscale`, zindex: 1, 
@@ -3105,6 +3272,7 @@
         'histogram': makeFunction(histogram),
         'box-plot': makeFunction(boxPlot),
         'dot-chart': makeFunction(dotChart),
+        'categorical-dot-chart': makeFunction(categoricalDotChart),
         'plot': makeFunction(plot),
       }, 
       {

package/src/js/trove/csv-lib.js

@@ -13,10 +13,17 @@
             runtime.checkArgsInternal2("csv-lib", "parse-string", str, runtime.String, opts, runtime.Object);
             return runtime.pauseStack((restarter) => {
                 const results = [];
-                const asStream = csv.parseString(str, opts.dict);
-                asStream
-                    .on('data', (data) => { results.push(data); })
-                    .on('end', () => { restarter.resume(results); })
+                try {
+                    const asStream = csv.parseString(str, opts.dict);
+                    let errored = false;
+                    asStream
+                        .on('error', (error) => { restarter.error(runtime.ffi.makeMessageException("Error reading CSV: " + String(error))); })
+                        .on('data', (data) => { results.push(data); })
+                        .on('end', () => { restarter.resume(results); })
+                }
+                catch(e) {
+                    restarter.error(runtime.ffi.makeMessageException("Error reading CSV: " + String(error))); 
+                }
             })
         }
         return runtime.makeModuleReturn({

package/src/js/trove/ffi.js

@@ -371,6 +371,11 @@
       raise(err("arity-mismatch")(funLoc, arity, args, isMethod));
     }
 
+    function throwHeaderRowMismatch(colnames, origHeaders, providedVals) {
+      runtime.checkArray(providedVals);
+      raise(err("header-row-mismatch")(colnames, origHeaders, providedVals));
+    }
+
     function throwRowLengthMismatch(colnames, providedVals) {
       runtime.checkArray(providedVals);
       raise(err("row-length-mismatch")(colnames, providedVals));
@@ -634,6 +639,7 @@
       throwUninitializedIdMkLoc: throwUninitializedIdMkLoc,
       throwArityError: throwArityError,
       throwArityErrorC: throwArityErrorC,
+      throwHeaderRowMismatch: throwHeaderRowMismatch,
       throwRowLengthMismatch: throwRowLengthMismatch,
       throwColLengthMismatch: throwColLengthMismatch,
       throwConstructorArityErrorC: throwConstructorArityErrorC,

package/src/js/trove/filelib.js

@@ -1,5 +1,7 @@
 ({
-  requires: [],
+  requires: [
+    { "import-type": "builtin", name: "string-dict" },
+  ],
   provides: {
     values: {
       "open-input-file": "tany",
@@ -16,11 +18,12 @@
       "close-output-file": "tany",
       "close-input-file": "tany",
       "create-dir": "tany",
+      "create-dir-tree": "tany",
       "list-files": "tany"
     }
   },
   nativeRequires: ["fs"],
-  theModule: function(RUNTIME, NAMESPACE, uri, fs) {
+  theModule: function(RUNTIME, NAMESPACE, uri, SD, fs) {
     function InputFile(name) {
       this.name = name;
       this.fd = fs.openSync(name, "r");
@@ -30,6 +33,17 @@
       this.name = name;
       this.fd = fs.openSync(name, (append ? "a" : "w"));
     }
+    var checkISD = RUNTIME.getField(SD, "internal").checkISD;
+    var isISD = RUNTIME.getField(SD, "internal").isISD;
+    function makeDirs(baseDir, tree) {
+      if (!fs.existsSync(baseDir)) fs.mkdirSync(baseDir);
+      if (isISD(tree)) {
+        RUNTIME.ffi.toArray(RUNTIME.getField(tree, "keys-list").app()).forEach(function(sub) {
+          var kid = RUNTIME.getColonField(tree, "get-value").full_meth(tree, sub);
+          makeDirs(baseDir + "/" + sub, kid);
+        });
+      }
+    }
 
     var vals = {
       "open-input-file": RUNTIME.makeFunction(function(filename) {
@@ -67,7 +81,7 @@
           return RUNTIME.pauseStack(async restarter => {
             fs.readFile(path, 'utf8', (err, data) => {
               if (err) {
-                restarter.error(RUNTIME.ffi.throwMessageException(String(err)));
+                restarter.error(RUNTIME.ffi.makeMessageException(String(err)));
               } else {
                 restarter.resume(data);
               }
@@ -206,6 +220,13 @@
         fs.mkdirSync(directory);
         return true;
       }, "create-dir"),
+      "create-dir-tree": RUNTIME.makeFunction(function(baseDir, subtree) {
+        RUNTIME.ffi.checkArity(2, arguments, "create-dir-tree", false);
+        RUNTIME.checkString(baseDir);
+        checkISD(subtree);
+        makeDirs(baseDir, subtree);
+        return true;
+      }, "create-dir-tree"),
       "list-files": RUNTIME.makeFunction(function(directory) {
           RUNTIME.ffi.checkArity(1, arguments, "list-files", false);
           RUNTIME.checkString(directory);

package/src/js/trove/make-image.js

@@ -818,7 +818,7 @@
         var color = unwrapColor(maybeC);
         var img   = unwrapImage(maybeImg);
         var line  = image.makeLineImage(x2 - x1, y2 - y1, color);
-        return makeImage(image.makeOverlayImage(line, "left", "top", 0, 0, img, "left", "top"));
+        return makeImage(image.makeOverlayImage(line, "left", "top", -Math.min(x1,x2), -Math.min(y1,y2), img, "left", "top"));
       });
 
       f("scene-line", function(maybeImg, maybeX1, maybeY1, maybeX2, maybeY2, maybeC) {

package/src/js/trove/string-dict.js

@@ -1414,7 +1414,9 @@
     };
     var internal = {
       checkISD: jsCheckISD,
-      checkMSD: jsCheckMSD
+      checkMSD: jsCheckMSD,
+      isISD:    isImmutableStringDict,
+      isMSD:    isMutableStringDict
     };
     return runtime.makeModuleReturn(vals, types, internal);
   }

package/src/js/trove/table.js

@@ -165,14 +165,20 @@
 
     function openTable(info) {
       runtime.checkTuple(info);
-      if (info.vals.length != 2) {
-        runtime.ffi.throwMessageException("Expected to find {header; contents} pair, "
+      const vals = [...info.vals];
+      if (info.vals.length === 2) {
+        vals.push(runtime.ffi.makeNone());
+      }
+      else if (info.vals.length !== 3) {
+        runtime.ffi.throwMessageException("Expected to find {header; contents; orig-headers} or {header; contensts} tuple, "
                                           + "but found a tuple of length "
                                           + info.vals.length);
       }
-      var headers = info.vals[0];
-      var contents = info.vals[1];
+      var headers = vals[0];
+      var contents = vals[1];
+      var origHeaders = vals[2];
       runtime.checkArray(headers);
+      // runtime.checkPyretVal(origHeaders); // Can we do better?
       runtime.checkArray(contents);
       var names = [];
       var sanitizers = [];
@@ -194,7 +200,7 @@
           runtime.checkArray(contents[i]);
           if (contents[i].length !== headers.length) {
             if (i === 0) {
-              throw runtime.ffi.throwRowLengthMismatch(names, contents[i]);
+              throw runtime.ffi.throwHeaderRowMismatch(names, origHeaders, contents[i]);
             } else {
               throw runtime.ffi.throwMessageException("Contents must be rectangular");
             }

package/.github/workflows/build-and-test.yml

@@ -1,29 +0,0 @@
-name: Makefile CI
-
-on:
-  push:
-    branches: [ "horizon" ]
-  pull_request:
-    branches: [ "horizon" ]
-  workflow_dispatch:
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-node@v3.9.1
-      with:
-        node-version: 24
-
-    - name: install
-      run:
-        make install
-
-    - name: build
-      run: make
-
-    - name: run tests
-      run: make all-pyret-test

package/examples/ahoy-right-back.arr

@@ -1,7 +0,0 @@
-#lang pyret
-
-import iolib as IO
-
-var user_input = IO.prompt("Arggghhh, what's your name matey? ")
-print("Ahoy " + user_input + "!\n")
-

package/examples/ahoy-world.arr

@@ -1,3 +0,0 @@
-#lang pyret
-
-print("Ahoy world!\n")

package/examples/call-flat-local.arr

@@ -1,37 +0,0 @@
-#lang pyret
-
-fun get-x(o):
- o.x
-end
-
-fun use-get-x():
-  a = get-x({x: 15})
-  b = get-x({x: a})
-  c = get-x({x: b})
-  c
-end
-
-# Has depth 2 so it's not considered flat (yet)
-fun use-use-get-x():
-  use-get-x()
-end
-
-fun use-get-x-then-non-flat():
-  a = get-x({x: 1234})
-  # Call a "non-flat" function like use-use-get-x
-  use-use-get-x()
-end
-
-# This should test the "base" case of compile-flat-apt when the body is none
-fun flat-app-as-last-expr():
-  get-x({x:4567})
-end
-
-fun dont-use-get-x():
-  f = get-x
-  3
-end
-
-use-get-x()
-use-get-x-then-non-flat()
-flat-app-as-last-expr()

package/examples/concat-strings.arr

@@ -1,7 +0,0 @@
-#lang pyret
-
-if not(false):
-  print(string-append("Ahoy world!", "test"))
-else:
-  print("another thing")
-end

package/examples/exit-code/failure.arr

@@ -1,19 +0,0 @@
-import system as SYS
-
-# By convention, an exit code not equal to 0 indicates that
-# the program failed to run successfully.
-exit-code = 1
-
-# check blocks are processed after the program finishes running
-# because we will call `system.exit`, no checks will be run
-check "this block gets skipped":
-  "x" is "y"
-end
-
-# This will print "Exited with code 1" and terminate execution
-# To terminate execution without such a message, use the `system.exit-quiet`
-# function instead
-SYS.exit(exit-code)
-# SYS.exit-quiet(exit-code)
-
-print("This is after the exit, and hence will not print\n")

package/examples/exit-code/success.arr

@@ -1,19 +0,0 @@
-import system as SYS
-
-# By convention, an exit code of 0 indicates that
-# the program ran successfully.
-exit-code = 0
-
-# check blocks are processed after the program finishes running
-# because we will call `system.exit`, no checks will be run
-check "this block gets skipped":
-  "x" is "y"
-end
-
-# This will print "Exited with code 0" and terminate execution
-# To terminate execution without such a message, use the `system.exit-quiet`
-# function instead
-SYS.exit(exit-code)
-# SYS.exit-quiet(exit-code)
-
-print("This is after the exit, and hence will not print\n")