@grain/stdlib 0.5.2 → 0.5.4

package/regex.gr

@@ -121,10 +121,10 @@ let withConfig = (buf: RegExBuf, config: RegExParserConfig) => {
 
 let parseErr = (buf: RegExBuf, msg: String, posShift) => {
   "Invalid Regular Expression: " ++
-  msg ++
-  " (position " ++
-  toString(unbox(buf.cursor) + posShift) ++
-  ")"
+    msg ++
+    " (position " ++
+    toString(unbox(buf.cursor) + posShift) ++
+    ")"
 }
 
 let next = (buf: RegExBuf) => {
@@ -241,7 +241,8 @@ let rec rangeAdd = (rng: CharRange, v: CharRangeElt) => {
     _ when rangeContains(rng, v) => rng,
     _ => rangeUnion(rng, [(v, v)]),
   }
-}, rangeUnion = (rng1, rng2) => {
+},
+rangeUnion = (rng1, rng2) => {
   match ((rng1, rng2)) {
     ([], _) => rng2,
     (_, []) => rng1,
@@ -487,7 +488,7 @@ enum MergeMode {
 }
 
 let mergeAdjacent = lst => {
-  // see [TODO] below
+  // TODO: see below
   let readyForAccum = (l, mode) => {
     match (l) {
       [] => true,
@@ -512,7 +513,7 @@ let mergeAdjacent = lst => {
       // drop empty elements
       [REEmpty, ...tl] => loop(mode, accum, tl),
       [RELiteralString(""), ...tl] => loop(mode, accum, tl),
-      // [TODO] Clean up with or-patterns (grain-lang/grain#696)
+      // TODO(#696): Clean up with or-patterns
       _ when readyForAccum(l, mode) => {
         match (accum) {
           [] => [],
@@ -592,7 +593,7 @@ REGEX PARSING DEFINITIONS
 
 // Range parsing ("[a-z]")
 
-// [TODO] (#769) When byte-based regexes are supported, we'll need another limit of 255 for those.
+// TODO(#769): When byte-based regexes are supported, we'll need another limit of 255 for those.
 let rangeLimit = 0x10FFFF
 
 // These are snake-cased to avoid confusion with their capitalized counterparts
@@ -636,7 +637,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
       Ok(_) => parseRange(buf),
     }
   }
-}, parseRange = (buf: RegExBuf) => {
+},
+parseRange = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Missing closing `]`", 0))
   } else {
@@ -659,7 +661,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
       Ok(_) => parseRangeRest(buf, [], None, None),
     }
   }
-}, parseClass = (buf: RegExBuf) => {
+},
+parseClass = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(
       "no chars"
@@ -694,7 +697,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
       Ok(c) => Err("unknown class: " ++ toString(c)),
     }
   }
-}, parsePosixCharClass = (buf: RegExBuf) => {
+},
+parsePosixCharClass = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Missing POSIX character class after `[`", 0))
   } else {
@@ -810,7 +814,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
         ),
     }
   }
-}, parseRangeRest =
+},
+parseRangeRest =
   (
     buf: RegExBuf,
     rng: CharRange,
@@ -962,7 +967,8 @@ let rec parseRangeNot = (buf: RegExBuf) => {
       },
     }
   }
-}, parseRangeRestSpan =
+},
+parseRangeRestSpan =
   (
     buf: RegExBuf,
     c,
@@ -1213,7 +1219,8 @@ let rec parseAtom = (buf: RegExBuf) => {
         _ => parseLiteral(buf),
       },
   }
-}, parseLook = (buf: RegExBuf) => {
+},
+parseLook = (buf: RegExBuf) => {
   let preNumGroups = unbox(buf.config.groupNumber)
   let spanNumGroups = () => unbox(buf.config.groupNumber) - preNumGroups
   // (isMatch, isAhead)
@@ -1279,7 +1286,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       }
     },
   }
-}, parseTest = (buf: RegExBuf) => {
+},
+parseTest = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected test", 0))
   } else {
@@ -1316,7 +1324,8 @@ let rec parseAtom = (buf: RegExBuf) => {
         ),
     }
   }
-}, parseInteger = (buf: RegExBuf, n) => {
+},
+parseInteger = (buf: RegExBuf, n) => {
   if (!more(buf)) {
     Ok(n)
   } else {
@@ -1331,7 +1340,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       Ok(_) => Ok(n),
     }
   }
-}, parseMode = (buf: RegExBuf) => {
+},
+parseMode = (buf: RegExBuf) => {
   let processState = ((cs, ml)) => {
     let withCs = match (cs) {
       None => buf.config,
@@ -1390,7 +1400,8 @@ let rec parseAtom = (buf: RegExBuf) => {
     }
   }
   help((None, None))
-}, parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
+},
+parseUnicodeCategories = (buf: RegExBuf, pC: String) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected unicode category", 0))
   } else {
@@ -1558,7 +1569,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       Ok(_) => Err(parseErr(buf, "Expected `{` after `\\" ++ pC ++ "`", 0)),
     }
   }
-}, parseLiteral = (buf: RegExBuf) => {
+},
+parseLiteral = (buf: RegExBuf) => {
   if (!more(buf)) {
     Err(parseErr(buf, "Expected literal", 0))
   } else {
@@ -1578,7 +1590,7 @@ let rec parseAtom = (buf: RegExBuf) => {
         Err(
           parseErr(buf, "unmatched `" ++ Char.toString(c) ++ "` in pattern", 0)
         ),
-      // [TODO] case-insensitive (#691)
+      // TODO(#691): Enable case-insensitive regular expression matching
       Ok(c) when buf.config.caseSensitive => {
         ignore(next(buf))
         Ok(RELiteral(c))
@@ -1592,7 +1604,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       },
     }
   }
-}, parseBackslashLiteral = (buf: RegExBuf) => {
+},
+parseBackslashLiteral = (buf: RegExBuf) => {
   if (!more(buf)) {
     // Special case: EOS after backslash matches null
     Err(parseErr(buf, "Expected to find escaped value after backslash", 0))
@@ -1655,7 +1668,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       },
     }
   }
-}, parseNonGreedy = (buf: RegExBuf) => {
+},
+parseNonGreedy = (buf: RegExBuf) => {
   let checkNotNested = res => {
     if (!more(buf)) {
       res
@@ -1681,7 +1695,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       Ok(_) => checkNotNested(Ok(false)),
     }
   }
-}, parsePCE = (buf: RegExBuf) => {
+},
+parsePCE = (buf: RegExBuf) => {
   match (parseAtom(buf)) {
     Err(e) => Err(e),
     Ok(atom) => {
@@ -1775,7 +1790,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       }
     },
   }
-}, parsePCEs = (buf: RegExBuf, toplevel: Bool) => {
+},
+parsePCEs = (buf: RegExBuf, toplevel: Bool) => {
   if (!more(buf)) {
     Ok([])
   } else {
@@ -1801,7 +1817,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       },
     }
   }
-}, parseRegex = (buf: RegExBuf) => {
+},
+parseRegex = (buf: RegExBuf) => {
   if (!more(buf)) {
     Ok(REEmpty)
   } else {
@@ -1836,7 +1853,8 @@ let rec parseAtom = (buf: RegExBuf) => {
       },
     }
   }
-}, parseRegexNonEmpty = (buf: RegExBuf) => {
+},
+parseRegexNonEmpty = (buf: RegExBuf) => {
   match (parsePCEs(buf, false)) {
     Err(e) => Err(e),
     Ok(pces) => {
@@ -1922,7 +1940,7 @@ let rec isAnchored = (re: ParsedRegularExpression) => {
     REAlts(a, b) => isAnchored(a) && isAnchored(b),
     REConditional(_, rx1, rx2, _, _, _) =>
       isAnchored(rx1) &&
-      Option.mapWithDefault(isAnchored, false, rx2),
+        Option.mapWithDefault(isAnchored, false, rx2),
     REGroup(rx, _) => isAnchored(rx),
     RECut(rx, _, _, _) => isAnchored(rx),
     _ => false,
@@ -2305,10 +2323,10 @@ let charMatcher = (toMatch, next_m) =>
   if (
     {
       pos < limit &&
-      match (matchBufChar(buf, pos)) {
-        Err(_) => false,
-        Ok(c) => toMatch == c,
-      }
+        match (matchBufChar(buf, pos)) {
+          Err(_) => false,
+          Ok(c) => toMatch == c,
+        }
     }
   ) next_m(buf, pos + 1, start, limit, end, state, stack) else None
 }
@@ -2326,10 +2344,10 @@ let charTailMatcher = toMatch =>
   if (
     {
       pos < limit &&
-      match (matchBufChar(buf, pos)) {
-        Err(_) => false,
-        Ok(c) => toMatch == c,
-      }
+        match (matchBufChar(buf, pos)) {
+          Err(_) => false,
+          Ok(c) => toMatch == c,
+        }
     }
   ) Some(pos + 1) else None
 }
@@ -2382,13 +2400,13 @@ let stringMatcher = (toMatch, len, next_m) =>
   if (
     {
       pos + len <= limit &&
-      subArraysEqual(
-        buf.matchInputExploded,
-        pos,
-        String.explode(toMatch),
-        0,
-        len
-      )
+        subArraysEqual(
+          buf.matchInputExploded,
+          pos,
+          String.explode(toMatch),
+          0,
+          len
+        )
     }
   ) next_m(buf, pos + len, start, limit, end, state, stack) else None
 }
@@ -2406,13 +2424,13 @@ let stringTailMatcher = (toMatch, len) =>
   if (
     {
       pos + len <= limit &&
-      subArraysEqual(
-        buf.matchInputExploded,
-        pos,
-        String.explode(toMatch),
-        0,
-        len
-      )
+        subArraysEqual(
+          buf.matchInputExploded,
+          pos,
+          String.explode(toMatch),
+          0,
+          len
+        )
     }
   ) Some(pos + len) else None
 }
@@ -2513,10 +2531,10 @@ let rangeMatcher = (rng: CharRange, next_m) =>
   if (
     {
       pos < limit &&
-      match (matchBufChar(buf, pos)) {
-        Err(_) => false,
-        Ok(c) => rangeContains(rng, Char.code(c)),
-      }
+        match (matchBufChar(buf, pos)) {
+          Err(_) => false,
+          Ok(c) => rangeContains(rng, Char.code(c)),
+        }
     }
   ) next_m(buf, pos + 1, start, limit, end, state, stack) else None
 }
@@ -2534,10 +2552,10 @@ let rangeTailMatcher = (rng: CharRange) =>
   if (
     {
       pos < limit &&
-      match (matchBufChar(buf, pos)) {
-        Err(_) => false,
-        Ok(c) => rangeContains(rng, Char.code(c)),
-      }
+        match (matchBufChar(buf, pos)) {
+          Err(_) => false,
+          Ok(c) => rangeContains(rng, Char.code(c)),
+        }
     }
   ) Some(pos + 1) else None
 }
@@ -2636,7 +2654,7 @@ let isWordChar = c => {
 
 let isWordBoundary = (buf, pos, start, limit, end) => {
   !((pos == start || !isWordChar(matchBufChar(buf, pos - 1))) ==
-  (pos == end || !isWordChar(matchBufChar(buf, pos))))
+    (pos == end || !isWordChar(matchBufChar(buf, pos))))
 }
 
 let wordBoundaryMatcher = next_m =>
@@ -3320,7 +3338,7 @@ record RegularExpression {
  * @section Values: Functions for working with regular expressions.
  */
 
-// [TODO] When #661 is resolved, re-add the following pieces of documentation:
+// TODO(#661): re-add the following pieces of documentation:
 /*
  [Under POSIX character classes]
 
@@ -3672,10 +3690,12 @@ let makeMatchResult = (origString, start, end, state) => {
 // Helpers for user-facing match functionality
 
 let fastDriveRegexIsMatch = (rx, string, startOffset, endOffset) => {
-  let state = if (rx.reReferences) Array.make(rx.reNumGroups, None)
+  let state =
+    if (rx.reReferences) Array.make(rx.reNumGroups, None)
     else Array.make(0, None)
-  let toWrap = if (startOffset == 0 && endOffset == String.length(string))
-      string else String.slice(startOffset, endOffset, string)
+  let toWrap =
+    if (startOffset == 0 && endOffset == String.length(string)) string
+    else String.slice(startOffset, endOffset, string)
   let buf = makeMatchBuffer(toWrap)
   Option.isSome(
     searchMatch(rx, buf, 0, 0, Array.length(buf.matchInputExploded), state)
@@ -3687,8 +3707,9 @@ let rec fastDriveRegexMatchAll = (rx, string, startOffset, endOffset) => {
     []
   } else {
     let state = Array.make(rx.reNumGroups, None)
-    let toWrap = if (startOffset == 0 && endOffset == String.length(string))
-        string else String.slice(startOffset, endOffset, string)
+    let toWrap =
+      if (startOffset == 0 && endOffset == String.length(string)) string
+      else String.slice(startOffset, endOffset, string)
     let buf = makeMatchBuffer(toWrap)
     match (searchMatch(
       rx,
@@ -3726,8 +3747,9 @@ let rec fastDriveRegexMatchAll = (rx, string, startOffset, endOffset) => {
 
 let fastDriveRegexMatch = (rx, string, startOffset, endOffset) => {
   let state = Array.make(rx.reNumGroups, None)
-  let toWrap = if (startOffset == 0 && endOffset == String.length(string))
-      string else String.slice(startOffset, endOffset, string)
+  let toWrap =
+    if (startOffset == 0 && endOffset == String.length(string)) string
+    else String.slice(startOffset, endOffset, string)
   let buf = makeMatchBuffer(toWrap)
   match (searchMatch(
     rx,
@@ -3954,11 +3976,12 @@ let regexReplaceHelp =
   let mut out = []
   let rec loop = searchPos => {
     let state = Array.make(rx.reNumGroups, None)
+    let inStart = max(0, searchPos - rx.reMaxLookbehind)
     let poss = searchMatch(
       rx,
       buf,
       searchPos,
-      searchPos,
+      inStart,
       Array.length(buf.matchInputExploded),
       state
     )

package/runtime/bigint.gr

@@ -1827,10 +1827,10 @@ let baseCaseDivRem = (a: WasmI32, b: WasmI32, result: WasmI32) => {
   let n = getHalfSize(b)
   let m = getHalfSize(a) - n
   let qsize = (if (WasmI32.eqz(WasmI32.and(m + 1n, 1n))) {
-        m + 1n
-      } else {
-        m + 2n
-      }) >>
+      m + 1n
+    } else {
+      m + 2n
+    }) >>
     1n
   let mut q = init(qsize)
   let mut a = 0n

package/runtime/compare.gr

@@ -0,0 +1,179 @@
+/* grainc-flags --no-pervasives */
+
+import WasmI32, {
+  eq as (==),
+  ne as (!=),
+  and as (&),
+  xor as (^),
+  or as (|),
+  add as (+),
+  sub as (-),
+  mul as (*),
+  ltS as (<),
+  gtS as (>),
+  remS as (%),
+  shl as (<<),
+  shrU as (>>>),
+} from "runtime/unsafe/wasmi32"
+import WasmI64 from "runtime/unsafe/wasmi64"
+import Memory from "runtime/unsafe/memory"
+import Tags from "runtime/unsafe/tags"
+import { tagSimpleNumber } from "runtime/dataStructures"
+import { isNumber, cmp as numberCompare } from "runtime/numbers"
+
+primitive (!): Bool -> Bool = "@not"
+primitive (||): (Bool, Bool) -> Bool = "@or"
+primitive (&&): (Bool, Bool) -> Bool = "@and"
+
+@unsafe
+let zero = WasmI32.fromGrain(0)
+
+@unsafe
+let rec heapCompareHelp = (heapTag, xptr, yptr) => {
+  match (heapTag) {
+    t when t == Tags._GRAIN_ADT_HEAP_TAG => {
+      // Check if the same constructor variant
+      let xvariant = WasmI32.load(xptr, 12n)
+      let yvariant = WasmI32.load(yptr, 12n)
+      if (xvariant != yvariant) {
+        tagSimpleNumber(xvariant - yvariant)
+      } else {
+        let xarity = WasmI32.load(xptr, 16n)
+        let yarity = WasmI32.load(yptr, 16n)
+
+        let mut result = 0
+
+        let bytes = xarity * 4n
+        for (let mut i = 0n; i < bytes; i += 4n) {
+          let sub = compareHelp(
+            WasmI32.load(xptr + i, 20n),
+            WasmI32.load(yptr + i, 20n)
+          )
+          if (WasmI32.fromGrain(sub) != zero) {
+            result = sub
+            break
+          }
+        }
+
+        result
+      }
+    },
+    t when t == Tags._GRAIN_RECORD_HEAP_TAG => {
+      let xlength = WasmI32.load(xptr, 12n)
+      let ylength = WasmI32.load(yptr, 12n)
+
+      let mut result = 0
+
+      let bytes = xlength * 4n
+      for (let mut i = 0n; i < bytes; i += 4n) {
+        let sub = compareHelp(
+          WasmI32.load(xptr + i, 16n),
+          WasmI32.load(yptr + i, 16n)
+        )
+        if (WasmI32.fromGrain(sub) != zero) {
+          result = sub
+          break
+        }
+      }
+
+      result
+    },
+    t when t == Tags._GRAIN_ARRAY_HEAP_TAG => {
+      let xlength = WasmI32.load(xptr, 4n)
+      let ylength = WasmI32.load(yptr, 4n)
+
+      // Check if the same length
+      if (xlength != ylength) {
+        tagSimpleNumber(xlength - ylength)
+      } else {
+        let mut result = 0
+        let bytes = xlength * 4n
+        for (let mut i = 0n; i < bytes; i += 4n) {
+          let sub = compareHelp(
+            WasmI32.load(xptr + i, 8n),
+            WasmI32.load(yptr + i, 8n)
+          )
+          if (WasmI32.fromGrain(sub) != zero) {
+            result = sub
+            break
+          }
+        }
+
+        result
+      }
+    },
+    t when (
+      t == Tags._GRAIN_STRING_HEAP_TAG || t == Tags._GRAIN_BYTES_HEAP_TAG
+    ) => {
+      let xlength = WasmI32.load(xptr, 4n)
+      let ylength = WasmI32.load(yptr, 4n)
+
+      if (xlength == ylength) {
+        tagSimpleNumber(Memory.compare(xptr + 8n, yptr + 8n, xlength))
+      } else {
+        if (xlength < ylength) {
+          let sub = Memory.compare(xptr + 8n, yptr + 8n, xlength)
+          // The shorter one comes first
+          if (sub == 0n) -1 else tagSimpleNumber(sub)
+        } else {
+          let sub = Memory.compare(xptr + 8n, yptr + 8n, ylength)
+          // The shorter one comes first
+          if (sub == 0n) 1 else tagSimpleNumber(sub)
+        }
+      }
+    },
+    t when t == Tags._GRAIN_TUPLE_HEAP_TAG => {
+      let xsize = WasmI32.load(xptr, 4n)
+      let ysize = WasmI32.load(yptr, 4n)
+
+      let mut result = 0
+      let bytes = xsize * 4n
+      for (let mut i = 0n; i < bytes; i += 4n) {
+        let sub = compareHelp(
+          WasmI32.load(xptr + i, 8n),
+          WasmI32.load(yptr + i, 8n)
+        )
+        if (WasmI32.fromGrain(sub) != zero) {
+          result = sub
+          break
+        }
+      }
+
+      result
+    },
+    _ => {
+      // No other implementation
+      tagSimpleNumber(xptr - yptr)
+    },
+  }
+},
+compareHelp = (x, y) => {
+  let xtag = x & Tags._GRAIN_GENERIC_TAG_MASK
+  let ytag = y & Tags._GRAIN_GENERIC_TAG_MASK
+  if ((xtag & ytag) != Tags._GRAIN_GENERIC_HEAP_TAG_TYPE) {
+    // Short circuit for non-pointer values
+    if ((xtag & Tags._GRAIN_NUMBER_TAG_MASK) == Tags._GRAIN_NUMBER_TAG_TYPE) {
+      // Signed comparisons are necessary for numbers
+      if (x < y) -1 else if (x > y) 1 else 0
+    } else {
+      // Unsigned comparisons are necessary for other stack-allocated values
+      if (WasmI32.ltU(x, y)) -1 else if (WasmI32.gtU(x, y)) 1 else 0
+    }
+  } else if (isNumber(x)) {
+    // Numbers have special comparison rules, e.g. NaN == NaN
+    tagSimpleNumber(numberCompare(x, y, true))
+  } else {
+    // Handle all other heap allocated things
+    // Can short circuit if pointers are the same
+    if (x == y) {
+      0
+    } else {
+      heapCompareHelp(WasmI32.load(x, 0n), x, y)
+    }
+  }
+}
+
+@unsafe
+export let compare = (x: a, y: a) => {
+  compareHelp(WasmI32.fromGrain(x), WasmI32.fromGrain(y))
+}

package/runtime/compare.md

@@ -0,0 +1,6 @@
+### Compare.**compare**
+
+```grain
+compare : (a, a) -> Number
+```
+

package/runtime/equal.gr

@@ -14,13 +14,12 @@ import WasmI32, {
 } from "runtime/unsafe/wasmi32"
 import WasmI64 from "runtime/unsafe/wasmi64"
 import Tags from "runtime/unsafe/tags"
+import { isNumber, numberEqual } from "runtime/numbers"
 
 primitive (!): Bool -> Bool = "@not"
 primitive (||): (Bool, Bool) -> Bool = "@or"
 primitive (&&): (Bool, Bool) -> Bool = "@and"
 
-import { isNumber, numberEqual } from "runtime/numbers"
-
 @unsafe
 let cycleMarker = 0x80000000n
 
@@ -190,7 +189,8 @@ let rec heapEqualHelp = (heapTag, xptr, yptr) => {
       xptr == yptr
     },
   }
-}, equalHelp = (x, y) => {
+},
+equalHelp = (x, y) => {
   if (
     (x & Tags._GRAIN_GENERIC_TAG_MASK) != 0n &&
     (y & Tags._GRAIN_GENERIC_TAG_MASK) != 0n

package/runtime/exception.gr

@@ -9,6 +9,8 @@ import foreign wasm fd_write: (
   WasmI32,
 ) -> WasmI32 from "wasi_snapshot_preview1"
 
+primitive unreachable: () -> a = "@unreachable"
+
 enum Option<a> {
   Some(a),
   None,
@@ -79,8 +81,8 @@ let exceptionToString = (e: Exception) => {
 // the runtime heap, but this is the only module that needs to do it
 let iov = WasmI32.fromGrain([> 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n, 0n])
 
-export let printException = (e: Exception) => {
-  let ptr = WasmI32.fromGrain(exceptionToString(e))
+export let panic = (msg: String) => {
+  let ptr = WasmI32.fromGrain(msg)
   let written = iov + 32n
   let lf = iov + 36n
   WasmI32.store(iov, ptr + 8n, 0n)
@@ -89,7 +91,11 @@ export let printException = (e: Exception) => {
   WasmI32.store(iov, lf, 8n)
   WasmI32.store(iov, 1n, 12n)
   fd_write(2n, iov, 2n, written)
-  void
+  unreachable()
+}
+
+export let panicWithException = (e: Exception) => {
+  panic(exceptionToString(e))
 }
 
 export exception IndexOutOfBounds
@@ -109,7 +115,6 @@ export exception MatchFailure
  */
 export exception AssertionError(String)
 export exception InvalidArgument(String)
-export exception OutOfMemory
 
 let runtimeErrorPrinter = e => {
   match (e) {
@@ -123,7 +128,6 @@ let runtimeErrorPrinter = e => {
       Some("NumberNotRational: Can't coerce number to rational"),
     MatchFailure => Some("MatchFailure: No matching pattern"),
     AssertionError(s) => Some(s),
-    OutOfMemory => Some("OutOfMemory: Maximum memory size exceeded"),
     InvalidArgument(msg) => Some(msg),
     _ => None,
   }

package/runtime/exception.md

@@ -22,9 +22,15 @@ dangerouslyRegisterBasePrinter : a -> Void
 dangerouslyRegisterPrinter : a -> Void
 ```
 
-### Exception.**printException**
+### Exception.**panic**
 
 ```grain
-printException : Exception -> Void
+panic : String -> a
+```
+
+### Exception.**panicWithException**
+
+```grain
+panicWithException : Exception -> a
 ```