Chapter 8: Conditions

# Chapter 8: Conditions
## Maya Gans
### R4DS Reading Group

---

# Overview

- Signaling conditions
  - Error
  - Warning
  - Message
- Ignoring conditions
 - try
 - suppress Warning/Message
- Handling conditions
 - tryCatch
 - withCallingHandlers

```r
brewing_materials <- readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2020/2020-03-31/brewing_materials.csv')
beer_taxed <- readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2020/2020-03-31/beer_taxed.csv')
brewer_size <- readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2020/2020-03-31/brewer_size.csv')
beer_states <- readr::read_csv('https://raw.githubusercontent.com/rfordatascience/tidytuesday/master/data/2020/2020-03-31/beer_states.csv')
```

---

- Error
- Warning
- Message

---

# Errors

> "An error message should start with a general statement of the problem then give a concise description of what went wrong. Consistent use of punctuation and formatting makes errors easier to parse.

> (This guide is currently almost entirely aspirational; most of the bad examples come from existing tidyverse code.)"

---

## stop

```r
beer_mean_error <- function(x) {
  if (!is.numeric(x)) {
*   stop("Need numeric column", call.=FALSE)
    mean(which(!is.na(x)[x]))
  } else{
    mean(which(!is.na(x)[x]))
  }
}
```

```r
beer_mean_error(beer_states$barrels)
```

```
## [1] 806.4551
```
]

```r
beer_mean_error(beer_states$states)
```

```
Error: Need numeric column
   2. stop("Need numeric column", call. = FALSE)
   1. beer_mean(beer_states$state)
```
]
---

## `rlang::abort`

```r
beer_mean_abort <- function(x) {
  if (!is.numeric(x)) {
*   abort(
*     message = "Need numeric column",
*     arg = x
*     )
  } else{
    mean(which(!is.na(x)[x]))
  }
}
```

```r
beer_mean_abort(beer_states$barrels)
```

```
## [1] 806.4551
```
]

```r
beer_mean_abort(beer_states$state)
```
```
Error: Need numeric column
   4. stop(fallback)
   3. signal_abort(cnd)
   2. abort(message = "Need numeric column", arg = x)
   1. beer_mean(beer_states$state)
```
]

---

## abort + glue

```r
beer_mean_abort_glue <- function(data, x) {
  
  column_name <- x
  
  msg <- glue::glue("Can't calculate mean, {column_name} is not numeric")
  
  if (!is.numeric(data[[x]])) {
    abort(
*     message = msg,
*     arg = column_name,
*     data = data
    )
    mean(which(!is.na(data[[x]])[data[[x]]]))
  } else {
    mean(which(!is.na(data[[x]])[data[[x]]]))
  }
}
```

```r
beer_mean_abort_glue(beer_states, "barrels")
```

```
## [1] 806.4551
```
]

```r
beer_mean_abort_glue(beer_states, "state")
```

```
Error: Can't calculate mean, "state" is not numeric
Run `rlang::last_error()` to see where the error occurred. 
   4. stop(fallback) 
   3. signal_abort(cnd) 
   2. abort(message = msg, arg = column_name, data = data) 
   1. beer_mean(beer_states, "state") 
```
]

---

# abort metadata

```r
str(catch_cnd(beer_mean_abort(beer_states, "state")))
```

```r
[1] "\"state\""
List of 5
*$ message: 'glue' chr "Can't calculate mean, \"state\" is not numeric"
 $ trace  :List of 4
 ...
 $ parent : NULL
*$ arg    : chr "\"state\""
*$ data   : tibble [1,872 × 4] (S3: spec_tbl_df/tbl_df/tbl/data.frame)
  ..$ state  : chr [1:1872] "AK" "AK" "AK" "AK" ...
  ..$ year   : num [1:1872] 2008 2009 2010 2011 2012 ...
  ..$ barrels: num [1:1872] 2068 2264 1929 2251 2312 ...
  ..$ type   : chr [1:1872] "On Premises" "On Premises" "On Premises" "On Premises" ...
  ..- attr(*, "spec")=
  .. .. cols(
  .. ..   state = col_character(),
  .. ..   year = col_double(),
  .. ..   barrels = col_double(),
  .. ..   type = col_character()
  .. .. )
 - attr(*, "class")= chr [1:3] "rlang_error" "error" "condition"
```

---

# Warnings

> Warnings occupy a somewhat challenging place between messages (“you should know about this”) and errors (“you must fix this!”)

```r
beer_mean_warning <- function(data, x) {
  
  column_name <- deparse(substitute(x))
  
  if (is.Date(data[[x]])) {
*   warning(glue::glue("Are you sure you wanna calculate the mean? {x} is of type date"))
    mean(data[[x]][which(!is.na(data[[x]]))])
  } else {
    mean(data[[x]][which(!is.na(data[[x]]))])
  }
}

beer_mean_warning(beer_states, "year")
```

```
## Warning in beer_mean_warning(beer_states, "year"): Are you sure you wanna
## calculate the mean? year is of type date
```

```
## [1] "2013-07-02"
```

.footnote[
_Not shown: (1) mutating the year column to a date type, (2) creating an `is.Date` function to check for date types. See .Rmd for code_
]

---

# Messages

>Good messages are a balancing act: you want to provide just enough information so the user knows what’s going on, but not so much that they’re overwhelmed.

```r
basic_summary_stats <- function(data, x, round_n = NULL, quiet = FALSE) {
  
  if (!is.numeric(data[[x]])) abort(glue::glue("Need numeric value to calculate stats and {x} is categorical"))
  if (is.null(round_n)) {
    
*   if (isFALSE(quiet)) message("round_n argument null, rounding to 2 digits by default")
    
    data %>% 
      summarise(
        missing = sum(is.na( data[[x]] )),
        mean = round(mean(which(!is.na(data[[x]])[data[[x]]])), 2)
       )
  } else {
    data %>% 
      summarise(
        missing = sum(is.na( data[[x]] )),
        mean = round(mean(which(!is.na(data[[x]])[data[[x]]])), round_n)
       )
  }
}
```

```r
basic_summary_stats(beer_states, "barrels")
```

```
## round_n argument null, rounding to 2 digits by default
```

```
## # A tibble: 1 x 2
##   missing  mean
##     <int> <dbl>
## 1      19  806.
```
]

```r
basic_summary_stats(beer_states, "barrels", quiet = TRUE)
```

```
## # A tibble: 1 x 2
##   missing  mean
##     <int> <dbl>
## 1      19  806.
```
]

---

- try
- suppressMessage

---

# try

```r
beer_mean_try <- function(x) {
* try(beer_mean_abort(x), silent = TRUE)
}
```

```r
beer_mean_try(beer_states$barrels)
```

```
## [1] 806.4551
```
]

```r
beer_mean_try(beer_states$state)
```
]

---

# suppressMessages

```r
testthat::test_that("beer mean function works", {
  
  # calculate mean using base and round to two digits
  base_mean <- round(mean(which(!is.na(beer_states$barrels)[beer_states$barrels])), 2)
  
  # use our function and suppress warning since we're not supplying a rounding argument
* suppressMessages(
*   our_function <- basic_summary_stats(beer_states, "barrels") %>% pull(mean)
* )
  
  # test that they are equal
  testthat::expect_equal(base_mean, our_function)
  # test that our function will produce a message
  testthat::expect_message(basic_summary_stats(beer_states, "barrels") %>% pull(mean))
})
```

.footnote[
_My thoughts behind this were that we don't want to clutter the output log when we run all our tests, but is this really best practice?_
]

---

- tryCatch
- withCallingHandlers

The condition system splits the responsibilities into three parts–signaling:
 1. a condition
 2. handling it
 3. restarting

---

# tryCatch

```r
beer_mean_tryCatch <- function(expr) {
  tryCatch(
*   error = function(cnd) NA,
    {
      glue::glue(
*       "Average Beer Barrels Produced: {round(expr,2)}"
      )
    },
*   finally = { print("Thank God for Beer!") }
  )
}
```

```r
beer_mean_tryCatch(beer_mean_abort(beer_states$barrels))
```

```
## [1] "Thank God for Beer!"
```

```
## Average Beer Barrels Produced: 806.46
```
]

```r
beer_mean_tryCatch(beer_mean_abort(beer_states$state))
```

```
## [1] "Thank God for Beer!"
```

```
## [1] NA
```
]

.footnote[
_I find it interesting that the `finally` statement is printed **before** the code inside the tryCatch. Can anyone explain why?_
]

---

# tryCatch

_We can use tryCatch within the for loop to catch errors without breaking the loop_

```r
for (indx in 1:ncol(beer_states)) {
    tryCatch(
        expr = {
            basic_summary_stats(beer_states, names(beer_states[indx]))
            message("Iteration ", indx, " successful.")
        },
        error = function(e){
            message("* Caught an error on itertion ", indx)
            print(e)
        }
    )
}
```

```
* Caught an error on itertion 1
<error/rlang_error>
Need numeric value to calculate stats and state is categorical
Backtrace:
 1. base::tryCatch(...)
 5. global::basic_summary_stats(beer_states, names(beer_states[indx]))
* Caught an error on itertion 2
<error/rlang_error>
Need numeric value to calculate stats and year is categorical
Backtrace:
 1. base::tryCatch(...)
 5. global::basic_summary_stats(beer_states, names(beer_states[indx]))
round_n argument null, rounding to 2 digits by default
* Iteration 3 successful.
* Caught an error on itertion 4
<error/rlang_error>
Need numeric value to calculate stats and type is categorical
Backtrace:
 1. base::tryCatch(...)
 5. global::basic_summary_stats(beer_states, names(beer_states[indx]))
```

---

# withCallingHandlers

> R’s error handling system lets you separate the code that actually recovers from an error from the code that decides how to recover. Thus, you can put recovery code in low-level functions without committing to actually using any particular recovery strategy, leaving that decision to code in high-level functions.

---

```r
expensive_function <- function(x, 
                               # warning print the warning and send us to browser
                               warning = function(w) { print(paste('warning:', w ));  browser() },
                               # error print the error and send us to browser
                               error=function(e) { print(paste('e:',e )); browser()} ) {
  
  print(paste("big expensive step we don't want to repeat for x:",x))
  
  z <- x  # the "expensive operation"
  
  # second function on z that isn't expensive but could potentially error
  repeat
  # put code in here that actually handles the errors
  withRestarts(
    withRestarts(
      withCallingHandlers(
        {
          print(paste("attempt cheap operation for z:",z))
          return(log(z))
        },
        warning = warning,
        error = error
      ),
      # action restart will take
      # if the function fails this will take us to the browser
      # and findRestart will find this name
      force_positive = function() {z <<- -z} 
    ),
    # or we can use this is the browser
    set_to_one = function() {z <<- 1}
  )
}
```

.footnote[
http://www.win-vector.com/blog/2012/10/error-handling-in-r/?utm_source=rss&utm_medium=rss&utm_campaign=error-handling-in-r
]

---

# Using `browser`

#### Success

```r
expensive_function(2)
```

```
[1] "big expensive step we don't want to repeat for x: 2"
[1] "attempt cheap operation for z: 2"
[1] 0.6931472
```

```r
expensive_function(-2)
```

```
[1] "big expensive step we don't want to repeat for x: -2"
[1] "attempt cheap operation for z: -2"
[1] "warning: simpleWarning in log(z): NaNs produced\n"
Called from: (function(w) { print(paste('warning:', w ));  
    browser() })(list(
    message = "NaNs produced", call = log(z)))
```

```r
Browse[1]> invokeRestart("force_positive")
```

```
[1] "attempt cheap operation for z: 2"
[1] 0.6931472
```
]

```r
expensive_function('a')
```

```
expensive_function('a')
[1] "big expensive step we don't want to repeat for x: a"
[1] "attempt cheap operation for z: a"
[1] "e: Error in log(z): non-numeric 
  argument to mathematical function\n"
  Called from: h(simpleError(msg, call))
```

```r
Browse[1]> invokeRestart("set_to_one")
```

```
[1] "attempt cheap operation for z: 1"
[1] 0
```
]

---

# Without `browser`

Get the handler functions to invoke the restart (rather than print error as in example above)

```r
force_positive <- function(w) {invokeRestart("force_positive")}
set_to_one <- function(e) {invokeRestart("set_to_one")}

auto_expensive_function = function(x) {
  expensive_function(x, warning=force_positive, error=set_to_one)
}
```

---

```r
auto_expensive_function(2)
```

```
## [1] "big expensive step we don't want to repeat for x: 2"
## [1] "attempt cheap operation for z: 2"
```

```
## [1] 0.6931472
```

```r
auto_expensive_function(-2)
```

```
## [1] "big expensive step we don't want to repeat for x: -2"
## [1] "attempt cheap operation for z: -2"
## [1] "attempt cheap operation for z: 2"
```

```
## [1] 0.6931472
```

```r
auto_expensive_function('a')
```

```
## [1] "big expensive step we don't want to repeat for x: a"
## [1] "attempt cheap operation for z: a"
## [1] "attempt cheap operation for z: 1"
```

```
## [1] 0
```

---

> We can use the condition system to allow a low-level function to detect a problem and signal an error, to allow mid-level code to provide several possible ways of recovering from such an error, and to allow code at the highest level of the application to define a policy for choosing which recovery strategy to use.

- `simple_mean`
- `mean_count`
- `mean_or_count`

---

# Low level function

```r
simple_mean <- function(x) { 
  #detecting of a problem
  if(!is.numeric(x)){ #if x is not numeric
    #create condition
    rlang::abort( 
      "categorical_column",  #class of condition
      message = "Not sure what to do with categorical column", #message to signal error
      x = x  #metadata
    )
  }
  cat("Returning from simple mean()\n")
  return(mean(x[which(!is.na(x))]))
}
```

```r
simple_mean(beer_states$barrels)
```

```
Returning from simple mean()
[1] 2286370
```
]

```r
simple_mean(beer_states$state)
```

```
Error: Not sure what to do with categorical column
```
]

---

# Medium - work around error

```r
mean_count <- function(y){
  
  as_count <- withRestarts( #establish restart
    simple_mean(y) , 
    #create code that recovers from errors in restart categorical_column_restart
    #restart name describes its action
    categorical_column_restart = function(z) { 
      plyr::count(z)
    } 
    #choosing this restart later in condition handler, will invoke it automatically
    #here you can define various restarts for other recoveries for 
    #condition handler to choose from
  )
  cat("Returning from mean_count()\n")
  return(as_count)
}
```

```r
mean_count(beer_states$barrels)
```

```
## Returning from simple mean()
## Returning from mean_count()
```

```
## [1] 2286370
```
]

```r
mean_count(beer_states$state)
```

```
Error: Not sure what to do with categorical column
```
]

---

# High level function

```r
mean_or_count <- function(z){
  as_mean_or_count <- withCallingHandlers(
    #call mean or count function 
    mean_count(z), 
    
    # if error occurs function that invokes restart 
    error = function(err){
      
      # if the error is a 'categorical column error'
      if (inherits(err, "categorical_column")) { 
        #if object err's class atrribute inherits from class of condition "categorical_column"
        #invoke the restarts called categorical_column_restart
        invokeRestart("categorical_column_restart",
                      #finds restart and invoke it with parameter
                      err$x #argument to pass to restart
        )
      } else {
        #otherwise re-raise the error
        stop(err)
      }
    }
  )
  cat("Returning from mean_or_count()\n")
  return(as_mean_or_count)
}
```
]

```r
mean_or_count(beer_states$barrels)
```

```
## Returning from simple mean()
## Returning from mean_count()
## Returning from mean_or_count()
```

```
## [1] 2286370
```
]

```r
head(mean_or_count(beer_states$state))
```

```
## Returning from mean_count()
## Returning from mean_or_count()
```

```
##    x freq
## 1 AK   36
## 2 AL   36
## 3 AR   36
## 4 AZ   36
## 5 CA   36
## 6 CO   36
```
]

---

#ftnvhlfjhp .gt_table {
  display: table;
  border-collapse: collapse;
  margin-left: auto;
  margin-right: auto;
  color: #333333;
  font-size: 9px;
  background-color: #FFFFFF;
  width: auto;
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #A8A8A8;
  border-right-style: none;
  border-right-width: 2px;
  border-right-color: #D3D3D3;
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #A8A8A8;
  border-left-style: none;
  border-left-width: 2px;
  border-left-color: #D3D3D3;
}

#ftnvhlfjhp .gt_heading {
  background-color: #FFFFFF;
  text-align: center;
  border-bottom-color: #FFFFFF;
  border-left-style: none;
  border-left-width: 1px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 1px;
  border-right-color: #D3D3D3;
}

#ftnvhlfjhp .gt_title {
  color: #333333;
  font-size: 125%;
  font-weight: initial;
  padding-top: 4px;
  padding-bottom: 4px;
  border-bottom-color: #FFFFFF;
  border-bottom-width: 0;
}

#ftnvhlfjhp .gt_subtitle {
  color: #333333;
  font-size: 85%;
  font-weight: initial;
  padding-top: 0;
  padding-bottom: 4px;
  border-top-color: #FFFFFF;
  border-top-width: 0;
}

#ftnvhlfjhp .gt_bottom_border {
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
}

#ftnvhlfjhp .gt_col_headings {
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #D3D3D3;
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  border-left-style: none;
  border-left-width: 1px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 1px;
  border-right-color: #D3D3D3;
}

#ftnvhlfjhp .gt_col_heading {
  color: #333333;
  background-color: #FFFFFF;
  font-size: 100%;
  font-weight: normal;
  text-transform: inherit;
  border-left-style: none;
  border-left-width: 1px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 1px;
  border-right-color: #D3D3D3;
  vertical-align: bottom;
  padding-top: 5px;
  padding-bottom: 6px;
  padding-left: 5px;
  padding-right: 5px;
  overflow-x: hidden;
}

#ftnvhlfjhp .gt_column_spanner_outer {
  color: #333333;
  background-color: #FFFFFF;
  font-size: 100%;
  font-weight: normal;
  text-transform: inherit;
  padding-top: 0;
  padding-bottom: 0;
  padding-left: 4px;
  padding-right: 4px;
}

#ftnvhlfjhp .gt_column_spanner_outer:first-child {
  padding-left: 0;
}

#ftnvhlfjhp .gt_column_spanner_outer:last-child {
  padding-right: 0;
}

#ftnvhlfjhp .gt_column_spanner {
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  vertical-align: bottom;
  padding-top: 5px;
  padding-bottom: 6px;
  overflow-x: hidden;
  display: inline-block;
  width: 100%;
}

#ftnvhlfjhp .gt_group_heading {
  padding: 8px;
  color: #333333;
  background-color: #FFFFFF;
  font-size: 100%;
  font-weight: initial;
  text-transform: inherit;
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #D3D3D3;
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  border-left-style: none;
  border-left-width: 1px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 1px;
  border-right-color: #D3D3D3;
  vertical-align: middle;
}

#ftnvhlfjhp .gt_empty_group_heading {
  padding: 0.5px;
  color: #333333;
  background-color: #FFFFFF;
  font-size: 100%;
  font-weight: initial;
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #D3D3D3;
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  vertical-align: middle;
}

#ftnvhlfjhp .gt_striped {
  background-color: red;
}

#ftnvhlfjhp .gt_from_md > :first-child {
  margin-top: 0;
}

#ftnvhlfjhp .gt_from_md > :last-child {
  margin-bottom: 0;
}

#ftnvhlfjhp .gt_row {
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 5px;
  padding-right: 5px;
  margin: 10px;
  border-top-style: solid;
  border-top-width: 1px;
  border-top-color: #D3D3D3;
  border-left-style: none;
  border-left-width: 1px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 1px;
  border-right-color: #D3D3D3;
  vertical-align: middle;
  overflow-x: hidden;
}

#ftnvhlfjhp .gt_stub {
  color: #333333;
  background-color: #FFFFFF;
  font-size: 100%;
  font-weight: initial;
  text-transform: inherit;
  border-right-style: solid;
  border-right-width: 2px;
  border-right-color: #D3D3D3;
  padding-left: 12px;
}

#ftnvhlfjhp .gt_summary_row {
  color: #333333;
  background-color: #FFFFFF;
  text-transform: inherit;
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 5px;
  padding-right: 5px;
}

#ftnvhlfjhp .gt_first_summary_row {
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 5px;
  padding-right: 5px;
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #D3D3D3;
}

#ftnvhlfjhp .gt_grand_summary_row {
  color: #333333;
  background-color: #FFFFFF;
  text-transform: inherit;
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 5px;
  padding-right: 5px;
}

#ftnvhlfjhp .gt_first_grand_summary_row {
  padding-top: 8px;
  padding-bottom: 8px;
  padding-left: 5px;
  padding-right: 5px;
  border-top-style: double;
  border-top-width: 6px;
  border-top-color: #D3D3D3;
}

#ftnvhlfjhp .gt_table_body {
  border-top-style: solid;
  border-top-width: 2px;
  border-top-color: #D3D3D3;
  border-bottom-style: solid;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
}

#ftnvhlfjhp .gt_footnotes {
  color: #333333;
  background-color: #FFFFFF;
  border-bottom-style: none;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  border-left-style: none;
  border-left-width: 2px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 2px;
  border-right-color: #D3D3D3;
}

#ftnvhlfjhp .gt_footnote {
  margin: 0px;
  font-size: 90%;
  padding: 4px;
}

#ftnvhlfjhp .gt_sourcenotes {
  color: #333333;
  background-color: #FFFFFF;
  border-bottom-style: none;
  border-bottom-width: 2px;
  border-bottom-color: #D3D3D3;
  border-left-style: none;
  border-left-width: 2px;
  border-left-color: #D3D3D3;
  border-right-style: none;
  border-right-width: 2px;
  border-right-color: #D3D3D3;
}

#ftnvhlfjhp .gt_sourcenote {
  font-size: 90%;
  padding: 4px;
}

#ftnvhlfjhp .gt_left {
  text-align: left;
}

#ftnvhlfjhp .gt_center {
  text-align: center;
}

#ftnvhlfjhp .gt_right {
  text-align: right;
  font-variant-numeric: tabular-nums;
}

#ftnvhlfjhp .gt_font_normal {
  font-weight: normal;
}

#ftnvhlfjhp .gt_font_bold {
  font-weight: bold;
}

#ftnvhlfjhp .gt_font_italic {
  font-style: italic;
}

#ftnvhlfjhp .gt_super {
  font-size: 65%;
}

#ftnvhlfjhp .gt_footnote_marks {
  font-style: italic;
  font-size: 65%;
}
</style>
<div id="ftnvhlfjhp" style="overflow-x:auto;overflow-y:auto;width:auto;height:auto;"><table class="gt_table" style="table-layout: fixed; width: 650px">
  <colgroup>
    <col style="width: 150px"/>
    <col style="width: 500px"/>
  </colgroup>
  <thead class="gt_header">
    <tr>
      <th colspan="2" class="gt_heading gt_title gt_font_normal" style>Other [base] Condition Functions</th>
    </tr>
    <tr>
      <th colspan="2" class="gt_heading gt_subtitle gt_font_normal gt_bottom_border" style>R Documentation</th>
    </tr>
  </thead>
  <thead class="gt_col_headings">
    <tr>
      <th class="gt_col_heading gt_columns_bottom_border gt_right" rowspan="1" colspan="1">Function</th>
      <th class="gt_col_heading gt_columns_bottom_border gt_left" rowspan="1" colspan="1">Definition</th>
    </tr>
  </thead>
  <tbody class="gt_table_body">
    <tr>
      <td class="gt_row gt_right">signalCondition</td>
      <td class="gt_row gt_left">Implements the mechanism of searching for an applicable condition handler and invoking its handler function</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">simpleCondition</td>
      <td class="gt_row gt_left">default condition class</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">simpleError</td>
      <td class="gt_row gt_left">default error class</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">simpleWarning</td>
      <td class="gt_row gt_left">default warning class</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">simpleMessage</td>
      <td class="gt_row gt_left">default message class</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">errorCondition</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">warningCondition</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">conditionCall</td>
      <td class="gt_row gt_left">return sthe message of a condition</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">conditionMessage</td>
      <td class="gt_row gt_left">returns the call of a condition</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">withRestarts</td>
      <td class="gt_row gt_left">establishes recovery protocols</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">computeRestarts</td>
      <td class="gt_row gt_left">returns a list of all restarts</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">findRestart</td>
      <td class="gt_row gt_left">returns the most recently established restart of the specified name</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">invokeRestart</td>
      <td class="gt_row gt_left">a way to specify how to handle errors and warnings</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">invokeRestartInteractively</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">isRestart</td>
      <td class="gt_row gt_left">TODO: check if object is a restart function</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">restartDescription</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">restartFormals</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">suspendInterrupts</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
    <tr>
      <td class="gt_row gt_right">allowInterrupts</td>
      <td class="gt_row gt_left">TODO</td>
    </tr>
  </tbody>
  
  
</table></div>

.small-font {
  font-size: 13px;
}

.small-font pre{
  font-size: 9px;
}

.footnote {
  color: #800020;
  font-size: 9px;
}

</style>