@ironm00n/pyret-lang 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironm00n/pyret-lang",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "The Pyret programming language",
   "main": "build/phase0/main-wrapper.js",
   "directories": {
@@ -8,9 +8,6 @@
     "example": "examples",
     "test": "tests"
   },
-  "bundleDependencies": [
-    "browserify"
-  ],
   "dependencies": {
     "ascii-table": "^0.0.9",
     "benchmark": "^2.1.4",
@@ -49,7 +46,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git://github.com/brownplt/pyret-lang"
+    "url": "git://github.com/ironm00n/pyret-lang"
   },
   "keywords": [
     "programming",
@@ -61,9 +58,9 @@
   "author": "Joe Gibbs Politz",
   "license": "Apache-2.0",
   "bugs": {
-    "url": "https://github.com/brownplt/pyret-lang/issues"
+    "url": "https://github.com/ironm00n/pyret-lang/issues"
   },
-  "homepage": "https://github.com/brownplt/pyret-lang",
+  "homepage": "https://github.com/ironm00n/pyret-lang",
   "devDependencies": {
     "http-server": "^14.1.1",
     "jest": "^30.0.4"

package/src/arr/trove/charts.arr

@@ -511,8 +511,12 @@ show-minor-grid-lines-method = method(self, is-showing :: Boolean):
   self.constr()(self.obj.{show-minor-grid-lines: is-showing})
 end
 
+show-grid-lines-method = method(self, is-showing :: Boolean):
+  self.constr()(self.obj.{show-grid-lines: is-showing})
+end
+
 gridlines-color-method = method(self, color ::  I.Color):
-  self.constr()(self.obj.{gridlineColor: some(color)})
+  self.constr()(self.obj.{show-grid-lines: true, gridlineColor: some(color)})
 end
 
 minor-gridlines-color-method = method(self, color ::  I.Color):
@@ -1150,7 +1154,8 @@ type LinePlotSeries = {
   trendlineDegree :: NumInteger, 
   dashedLine :: Boolean, 
   dashlineStyle :: RawArray<NumInteger>, 
-  point-size :: Number, 
+  point-size :: Number,
+  useImageSizes :: Boolean,
   pointshapeType :: String, 
   pointshapeSides :: NumInteger, 
   pointshapeDent :: Number, 
@@ -1170,7 +1175,8 @@ default-line-plot-series = {
   trendlineDegree: 3,  
   dashedLine: false,
   dashlineStyle: [raw-array: 2, 2],
-  point-size: 0, 
+  point-size: 0,
+  useImageSizes: true,
   pointshapeType: 'circle', 
   pointshapeSides: 5,
   pointshapeDent: 0.5,
@@ -1190,6 +1196,7 @@ type ScatterPlotSeries = {
   color :: Option<I.Color>,
   legend :: String,
   point-size :: Number,
+  useImageSizes :: Boolean,
   trendlineType :: Option<String>,
   trendlineColor :: Option<I.Color>,
   trendlineWidth :: Number, 
@@ -1206,6 +1213,7 @@ default-scatter-plot-series = {
   color: none,
   legend: '',
   point-size: 7,
+  useImageSizes: true,
   pointshapeType: 'circle', 
   pointshapeSides: 5,
   pointshapeDent: 0.5,
@@ -1229,12 +1237,30 @@ type DotPlotSeries = {
   color :: Option<I.Color>,
   legend :: String,
   point-size :: Number,
+  useImageSizes :: Boolean,
 }
 
 default-dot-plot-series = {
   color: none,
   legend: '',
-  point-size: 8
+  point-size: 8,
+  useImageSizes: true,
+}
+
+type CategoricalDotPoint ={
+  label :: String,
+  count :: Number
+}
+
+type CategoricalDotPlotSeries = {
+  ps :: List<CategoricalDotPoint>,
+  color :: Option<I.Color>,
+  legend :: String
+}
+
+default-categorical-dot-plot-series = {
+  color: none,
+  legend: '',
 }
 
 type IntervalPoint = {
@@ -1453,6 +1479,8 @@ type PlotChartWindowObject = {
   borderSize :: Number, 
   borderColor :: Option<I.Color>, 
   render :: ( -> IM.Image),
+  show-grid-lines :: Boolean,
+  show-minor-grid-lines :: Boolean,
   gridlineColor :: Option<I.Color>, 
   gridlineMinspacing :: Option<Number>, 
   minorGridlineColor :: Option<I.Color>, 
@@ -1470,6 +1498,7 @@ type PlotChartWindowObject = {
 default-plot-chart-window-object :: PlotChartWindowObject = default-chart-window-object.{
   x-axis: '',
   y-axis: '',
+  show-grid-lines: true,
   show-minor-grid-lines: false,
   x-min: none,
   x-max: none,
@@ -1510,6 +1539,9 @@ data DataSeries:
       end
       self.constr()(self.obj.{point-size: point-size})
     end,
+    method use-image-sizes(self, use-image-sizes :: Boolean):
+      self.constr()(self.obj.{useImageSizes: use-image-sizes})
+    end,
     horizontal: horizontal-method,
   | scatter-plot-series(obj :: ScatterPlotSeries) with:
     trendline-type: trendline-type-method,
@@ -1524,17 +1556,21 @@ data DataSeries:
     image-labels: image-labels-method,
     point-shape: pointshape-method, 
     method point-size(self, point-size :: Number) block:
-      when point-size < 0: 
-        raise("point-size: Point Size must be non-negative")
+      when point-size <= 0: 
+        raise("point-size: Point Size must be positive")
       end
       self.constr()(self.obj.{point-size: point-size})
     end,
+    method use-image-sizes(self, use-image-sizes :: Boolean):
+      self.constr()(self.obj.{useImageSizes: use-image-sizes})
+    end,
     horizontal: horizontal-method,
   | dot-plot-series(obj :: DotPlotSeries) with:
     is-single: true,
     constr: {(): dot-plot-series},
     color: color-method,
     legend: legend-method,
+    image-labels: image-labels-method,
     labels: labels-method,
     method point-size(self, point-size :: Number) block:
       when point-size < 0: 
@@ -1542,6 +1578,14 @@ data DataSeries:
       end
       self.constr()(self.obj.{point-size: point-size})
     end,
+    method use-image-sizes(self, use-image-sizes :: Boolean):
+      self.constr()(self.obj.{useImageSizes: use-image-sizes})
+    end,
+  | categorical-dot-plot-series(obj :: CategoricalDotPlotSeries) with:
+    is-single: true,
+    constr: {(): categorical-dot-plot-series},
+    color: color-method,
+    legend: legend-method,
   | function-plot-series(obj :: FunctionPlotSeries) with:
     is-single: false,
     constr: {(): function-plot-series},
@@ -1706,11 +1750,12 @@ data ChartWindow:
     y-max: y-max-method,
   | plot-chart-window(obj :: PlotChartWindowObject) with:
     constr: {(): plot-chart-window},
-    show-minor-gridlines: show-minor-grid-lines-method,
+    show-gridlines: show-grid-lines-method,
     gridlines-color: gridlines-color-method, 
-    gridlines-minspacing: gridlines-min-spacing-method, 
-    minor-gridlines-color: minor-gridlines-color-method, 
-    minor-gridlines-minspacing: minor-gridlines-min-spacing-method, 
+    # gridlines-minspacing: gridlines-min-spacing-method, 
+    # show-minor-gridlines: show-minor-grid-lines-method,
+    # minor-gridlines-color: minor-gridlines-color-method, 
+    # minor-gridlines-minspacing: minor-gridlines-min-spacing-method, 
     x-axis: x-axis-method,
     y-axis: y-axis-method,
     x-min: x-min-method,
@@ -2030,6 +2075,24 @@ fun num-dot-chart-from-list(x-values :: CL.LoN) -> DataSeries block:
   } ^ dot-plot-series
 end
 
+fun image-num-dot-chart-from-list(images :: CL.LoI, x-values :: CL.LoN) -> DataSeries block:
+  doc: ```
+       Consume unordered, possibly-repeating lists of image-labels and numbers, 
+       and construct a dot chart
+       ```
+  x-values.each(check-num)
+  when x-values.length() == 0:
+    raise("num-dot-chart: can't have empty data")
+  end
+  images.each(check-image)
+  when images.length() <> x-values.length():
+    raise("num-dot-chart: the lists of numbers and images must have the same length")
+  end
+  default-dot-plot-series.{
+    ps: map3(get-dot-point, x-values, x-values.map({(_): ''}), images.map(some)),
+  } ^ dot-plot-series
+end
+
 fun labeled-num-dot-chart-from-list(labels :: CL.LoS, x-values :: CL.LoN) -> DataSeries block:
   doc: ```
        Consume unordered, possibly-repeating lists of labels and numbers, 
@@ -2062,36 +2125,15 @@ fun dot-chart-from-list(input-labels :: CL.LoS) -> DataSeries block:
   input-labels.each(check-string)
 
   # Walk through the (sorted) values, creating lists of labels and counts
-  unique-counts = foldl(
-    lam(acc, elt):
-      labels = acc.{0}
-      counts = acc.{1}
-      if labels.member(elt):
-        {labels; counts.set(0, counts.get(0) + 1)}
-      else:
-        {link(elt, labels); link(1, counts)}
-      end
-    end,
-    {[list: ]; [list: ]},
-    input-labels.sort())
-
-  labels = unique-counts.{0}
-  values = unique-counts.{1}
-  rational-values = map(num-to-rational, values)
-
-  # set the vAxis values, and create the data series
-  {max-positive-height; max-negative-height} = prep-axis(rational-values)
-
-  data-series = default-bar-chart-series.{
-    tab: to-table2-n(labels, rational-values),
-    dot-chart: true,
-    axis-top: max-positive-height,
-    axis-bottom: max-negative-height,
-    annotations: values.map({(_): [list: none]}) ^ list-to-table2,
-    intervals: values.map({(_): [list: [raw-array: ]]}) ^ list-to-table2,
-  } ^ bar-chart-series
+  unique-counts = for fold(acc from [SD.mutable-string-dict: ], label from input-labels) block:
+    acc.set-now(label, acc.get-now(label).or-else(0) + 1)
+    acc
+  end
 
-  data-series.make-axis(max-positive-height, max-negative-height)
+  labels = unique-counts.keys-list-now().sort()
+  default-categorical-dot-plot-series.{
+    ps: labels.map({(l): { label: l, count: unique-counts.get-value-now(l) }})
+  } ^ categorical-dot-plot-series
 end
 
 fun grouped-bar-chart-from-list(
@@ -2393,6 +2435,12 @@ fun render-chart(s :: DataSeries) -> ChartWindow:
           CL.dot-chart(self, obj) 
         end
       } ^ dot-chart-window
+    | categorical-dot-plot-series(obj) =>
+      default-dot-chart-window-object.{
+        method render(self) block:
+          CL.categorical-dot-chart(self, obj) 
+        end
+      } ^ dot-chart-window
     | pie-chart-series(obj) =>
       default-pie-chart-window-object.{
         method render(self): CL.pie-chart(self, obj) end
@@ -2831,6 +2879,7 @@ from-list = {
   bar-chart: bar-chart-from-list,
   dot-chart: dot-chart-from-list,
   num-dot-chart: num-dot-chart-from-list,
+  image-num-dot-chart: image-num-dot-chart-from-list,
   labeled-num-dot-chart: labeled-num-dot-chart-from-list,
   image-bar-chart: image-bar-chart-from-list,
   grouped-bar-chart: grouped-bar-chart-from-list,

package/src/arr/trove/csv.arr

@@ -1,4 +1,5 @@
 import file as F
+import filesystem as FS
 import csv-lib as csv-lib
 import option as O
 import fetch as Fetch
@@ -25,12 +26,14 @@ import string-dict as SD
 
 type CSVOptions = {
   header-row :: Boolean,
-  infer-content :: Boolean
+  infer-content :: Boolean,
+  orig-headers :: O.Option<RawArray<String>>
 }
 
 default-options = {
   header-row: true,
-  infer-content: false
+  infer-content: false,
+  orig-headers: O.none
 }
 
 fun to-str-content(csv :: RawArray<RawArray<String>>):
@@ -76,7 +79,7 @@ fun csv-table-opt(csv :: RawArray<RawArray<String>>, opts :: CSVOptions):
           result
         end
 
-        { headers; contents }
+        { headers; contents; opts.orig-headers }
       end
   }
 end
@@ -88,19 +91,43 @@ end
 fun csv-table-str(csv :: String, opts):
   shadow opts = builtins.record-concat(default-options, opts)
   skip-rows = if opts.header-row: 1 else: 0 end
-  rows = csv-lib.parse-string(csv, { skipRows: skip-rows })
-  csv-table-opt(rows, opts)
+  rows = csv-lib.parse-string(csv, {})
+  contents = if opts.header-row:
+    raw-array-from-list(raw-array-to-list(rows).drop(1))
+  else:
+    rows
+  end
+  headers = if opts.header-row and (raw-array-length(rows) > 0) and O.is-none(opts.orig-headers):
+    O.some(raw-array-get(rows, 0))
+  else:
+    O.none
+  end
+  csv-table-opt(contents, opts.{ orig-headers: headers })
 end
 
 fun csv-table-file(path :: String, opts):
-  contents = F.file-to-string(path)
-  csv-table-str(contents, opts)
+  if FS.exists(path):
+    contents = F.file-to-string(path)
+    csv-table-str(contents, opts)
+  else:
+    if string-contains(path, "://"):
+      raise("csv-table-file should be given the path to a file, not a url. Did you mean to use csv-table-url instead?")
+    else:
+      raise("csv-table-file given path to a file that doesn't exist: " + path)
+    end
+  end
+  
 end
 
 fun csv-table-url(url :: String, opts):
   contents = Fetch.fetch(url)
   cases(E.Either) contents:
     | left(str) => csv-table-str(str, opts)
-    | right(err) => raise(err)
+    | right(err) => 
+      if not(string-contains(url, "://")):
+        raise("csv-table-url should be given a url, including the part at the beginning with ://. Did you mean to use csv-table-file instead? The following error occurred: " + err)
+      else:
+        raise(err)
+      end
   end
 end

package/src/arr/trove/error.arr

@@ -18,6 +18,9 @@ end
 fun horz-list-values(vals):
   [ED.para: ED.h-sequence(vals.map(lam(val): ED.embed(val) end), ",") ]
 end
+fun horz-list-str-ids(vals):
+  [ED.para: ED.h-sequence(vals.map(lam(val): ED.text(val) end), ",") ]
+end
 
 fun ed-simple-intro(name, loc):
   ed-simple-intro-a-an(name, loc, "a")
@@ -1925,6 +1928,47 @@ data RuntimeError:
           vert-list-values(self.fun-app-args)])
     end
 
+    | header-row-mismatch(expected-headers, orig-headers, provided-row) with:
+    method render-fancy-reason(self, maybe-stack-loc, src-available, maybe-ast):
+      cases(O.Option) maybe-stack-loc(0, true):
+        | some(l) =>
+          [ED.error:
+            ed-intro("table construction", l, -1, true),
+            [ED.para: ED.text("The table could not be constructed because the number of expected headers didn't match the number found in the data.")],
+            [ED.para: ED.text("Expected to have " + num-to-string(raw-array-length(self.expected-headers)) + " columns:")],
+            horz-list-str-ids(raw-array-to-list(self.expected-headers)),
+            cases(O.Option) self.orig-headers:
+              | some(oh) =>
+                [ED.para: [ED.para: ED.text("Instead, found header with " + num-to-string(raw-array-length(oh)) + " columns:"),
+                                    horz-list-str-ids(raw-array-to-list(oh))],
+                          [ED.para: ED.text("And data with " + num-to-string(raw-array-length(self.provided-row)) + " columns:"),
+                                    horz-list-values(raw-array-to-list(self.provided-row))]]
+              | none =>
+                [ED.para: ED.text("But found data with " + num-to-string(raw-array-length(self.provided-row)) + " columns:"),
+                                   horz-list-values(raw-array-to-list(self.provided-row))]
+            end,
+            ]
+        | none => self.render-reason()
+      end
+    end,
+    method render-reason(self):
+      [ED.error:
+        [ED.para: ED.text("The row could not be constructed because the number of columns didn't match the number of provided values.")],
+        [ED.para: ED.text("Expected " + num-to-string(raw-array-length(self.expected-headers)) + " columns:")],
+        horz-list-str-ids(raw-array-to-list(self.expected-headers)),
+        cases(O.Option) self.orig-headers:
+          | some(oh) =>
+            [ED.para: [ED.para: ED.text("Instead, found header with " + num-to-string(raw-array-length(oh)) + " columns:"),
+                                horz-list-str-ids(raw-array-to-list(oh))],
+                      [ED.para: ED.text("And data with " + num-to-string(raw-array-length(self.provided-row)) + " columns:"),
+                                horz-list-values(raw-array-to-list(self.provided-row))]]
+          | none =>
+            [ED.para: ED.text("But found data with " + num-to-string(raw-array-length(self.provided-row)) + " columns:"),
+                                horz-list-values(raw-array-to-list(self.provided-row))]
+        end]
+    end
+
+
   | row-length-mismatch(colnames, provided-vals) with:
     method render-fancy-reason(self, maybe-stack-loc, src-available, maybe-ast):
       cases(O.Option) maybe-stack-loc(0, true):