JsError

Functions for working with JavaScript errors.

See Error on MDN.

fileName

RESCRIPT

let fileName: t => option<string>

fileName(error) retrieves the fileName property of the error, if it exists.

See Error.prototype.fileName on MDN.

ignore

RESCRIPT

let ignore: t => unit

ignore(error) ignores the provided error and returns unit.

This helper is useful when you want to discard a value (for example, the result of an operation with side effects) without having to store or process it further.

make

RESCRIPT

let make: string => t

make(message) creates a new error, setting its message to the provided value.

See Error on MDN.

Example

RESCRIPT
let error = JsError.make("Some message here")
error->JsError.message == "Some message here"
error->JsError.name == "Error"

message

RESCRIPT

let message: t => string

message(error) retrieves the message property of the error.

See Error.prototype.message on MDN.

Example

RESCRIPT
let error = JsError.SyntaxError.make("Some message here")
error->JsError.message == "Some message here"

name

RESCRIPT

let name: t => string

name(error) retrieves the name property of the error.

See Error.prototype.name on MDN.

Example

RESCRIPT
let error = JsError.SyntaxError.make("Some message here")
error->JsError.name == "SyntaxError"

panic

RESCRIPT

let panic: string => 'a

Throws a panic exception with the given message.

A panic exception is a native JavaScript exception that is not intended to be caught and handled. Compared to a ReScript exception this will give a better stack trace and debugging experience.

Examples

RESCRIPT
try {
  JsError.panic("Uh oh. This was unexpected!")
} catch {
| JsExn(obj) =>
  switch JsExn.message(obj) {
  | Some(m) => assert(m == "Panic! Uh oh. This was unexpected!")
  | None => assert(false)
  }
| _ => assert(false)
}

stack

RESCRIPT

let stack: t => option<string>

stack(error) retrieves the stack property of the error, if it exists. The stack is a list of what functions were called, and what files they are defined in, prior to the error happening.

See Error.prototype.stack on MDN.

Example

RESCRIPT
let error = JsError.make("error")
Console.log(error->JsError.stack) // Logs `stack` if it exists on `someError`

t

RESCRIPT

type t

Represents a JavaScript error.

throw

RESCRIPT

let throw: t => 'a

Throws the given error, terminating execution unless caught by a surrounding try/catch block.

Examples

RESCRIPT
let error = JsError.make("Everything is upside down.")

if 5 > 10 {
  JsError.throw(error)
} else {
  Console.log("Phew, sanity still rules.")
}

throwWithMessage

RESCRIPT

let throwWithMessage: string => 'a

Creates a new Error with the provided message and throws it.

JsError.throwWithMessage("message") is equivalent to JsError.make("message")->JsError.throw.

toJsExn

RESCRIPT

let toJsExn: t => JsExn.t

Casts a JsError.t to a JsExn.t.

This is useful when you want to compare a JS exception and a JS error.