Package 'constructive'

Description

Exported for custom constructor design. If recurse is TRUE (default), we recurse to construct args and insert their construction code in a fun(...) call returned as a character vector. If args already contains code rather than object to construct one should set recurse to FALSE.

Usage

.cstr_apply(
  args,
  fun = "list",
  ...,
  trailing_comma = FALSE,
  recurse = TRUE,
  implicit_names = FALSE,
  new_line = TRUE,
  one_liner = FALSE,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE
)

Arguments

Value

A character vector of code

Examples

a <- 1
.cstr_apply(list(a=a), "foo")
.cstr_apply(list(a=a), "foo", data = list(a=1))
.cstr_apply(list(a=a), "foo", data = list(a=1), implicit_names = TRUE)
.cstr_apply(list(b=a), "foo", data = list(a=1), implicit_names = TRUE)
.cstr_apply(list(a="c(1,2)"), "foo")
.cstr_apply(list(a="c(1,2)"), "foo", recurse = FALSE)

Description

Exported for custom constructor design. This function allows combining independent checks so information is given about all failing checks rather than the first one. All parameters except ... are forwarded to rlang::abort()

Usage

.cstr_combine_errors(
  ...,
  class = NULL,
  call,
  header = NULL,
  body = NULL,
  footer = NULL,
  trace = NULL,
  parent = NULL,
  use_cli_format = NULL,
  .internal = FALSE,
  .file = NULL,
  .frame = parent.frame(),
  .trace_bottom = NULL
)

Arguments

Value

Returns NULL invisibly, called for side effects.

Description

Exported for custom constructor design. .cstr_construct() is basically a naked construct(), without the checks, the style, the object post processing etc...

Usage

.cstr_construct(x, ..., data = NULL, classes = NULL)

Arguments

Value

A character vector

Description

Exported for custom constructor design.

Usage

.cstr_options(class, ...)

Arguments

Value

An object of class c(paste0("constructive_options_", class), "constructive_options")

Description

Exported for custom constructor design.

Usage

.cstr_pipe(x, y, ..., pipe = NULL, one_liner = FALSE, indent = TRUE)

Arguments

Value

A character vector

Examples

.cstr_pipe("iris", "head(2)", pipe = "magrittr", one_liner = FALSE)
.cstr_pipe("iris", "head(2)", pipe = "magrittr", one_liner = TRUE)

Description

Exported for custom constructor design. In the general case an object might have more attributes than given by the idiomatic construction. .cstr_repair_attributes() sets some of those attributes and ignores others.

Usage

.cstr_repair_attributes(
  x,
  code,
  ...,
  ignore = NULL,
  idiomatic_class = NULL,
  remove = NULL,
  flag_s4 = TRUE,
  repair_names = FALSE
)

Arguments

Value

A character vector

Description

Exported for custom constructor design. Generally called through .cstr_apply().

Usage

.cstr_wrap(args, fun, new_line = FALSE)

Arguments

Value

A character vector.

Description

This is designed to be used in constructed output. The parents and ... arguments are not processed and only used to display additional information. If used on an improper memory address it will either fail (most likely) or the output will be erratic.

Usage

.env(address, parents = NULL, ...)

Arguments

Value

The environment that the memory address points to.

Description

Base R doesn't provide utilities to build or manipulate external pointers (objects of type "externalptr"), so we provide our own. Objects defined with .xptr() are not stable across sessions,

Usage

.xptr(address)

Arguments

Value

The external pointer (type "externalptr") that the memory address points to.

Description

Builds options that will be passed to waldo::compare() down the line.

Usage

compare_options(
  ignore_srcref = TRUE,
  ignore_attr = FALSE,
  ignore_function_env = FALSE,
  ignore_formula_env = FALSE
)

Arguments

Value

A list

Description

• construct() builds the code to reproduce one object,

• construct_multi() builds the code to reproduce objects stored in a named list or environment.

Usage

construct(
  x,
  ...,
  data = NULL,
  pipe = NULL,
  check = NULL,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template"),
  classes = NULL
)

construct_multi(
  x,
  ...,
  data = NULL,
  pipe = NULL,
  check = NULL,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template"),
  classes = NULL,
  include_dotted = TRUE
)

Arguments

Details

construct_multi() recognizes promises (also called lazy bindings), this means that for instance construct_multi(environment()) can be called when debugging a function and will construct unevaluated arguments using delayedAssign().

Value

An object of class 'constructive'.

Constructive options

Constructive options provide a way to customize the output of 'construct()'. We can provide calls to 'opts_*()' functions to the '...' argument. Each of these functions targets a specific type or class and is documented on its own page.

• opts_array(constructor = c("array", "next"), ...)

• opts_AsIs(constructor = c("I", "next"), ...)

• opts_atomic(..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE)

• opts_bbox(constructor = c("st_bbox", "next"), ...)

• opts_bibentry(constructor = c("bibentry", "next"), ...)

• opts_blob(constructor = c("blob", "next"), ...)

• opts_character(constructor = c("default"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE, unicode_representation = c("ascii", "latin", "character", "unicode"), escape = FALSE, multiline = FALSE)

• opts_citationFooter(constructor = c("citFooter", "next"), ...)

• opts_citationHeader(constructor = c("citHeader", "next"), ...)

• opts_classGeneratorFunction(constructor = c("setClass"), ...)

• opts_classPrototypeDef(constructor = c("prototype"), ...)

• opts_classRepresentation(constructor = c("getClassDef"), ...)

• opts_clock_duration(constructor = c("duration", "next", "list"), ...)

• opts_clock_iso_year_week_day(constructor = c("iso_year_week_day", "next", "list"), ...)

• opts_clock_naive_time(constructor = c("as_naive_time", "next", "list"), ...)

• opts_clock_sys_time(constructor = c("as_sys_time", "next", "list"), ...)

• opts_clock_weekday(constructor = c("weekday", "next", "integer"), ...)

• opts_clock_year_day(constructor = c("year_day", "next", "list"), ...)

• opts_clock_year_month_day(constructor = c("year_month_day", "next", "list"), ...)

• opts_clock_year_month_weekday(constructor = c("year_month_weekday", "next", "list"), ...)

• opts_clock_year_quarter_day(constructor = c("year_quarter_day", "next", "list"), ...)

• opts_clock_year_week_day(constructor = c("year_week_day", "next", "list"), ...)

• opts_clock_zoned_time(constructor = c("as_zoned_time", "next", "list"), ...)

• opts_col_spec(constructor = c("cols", "next", "list"), ...)

• opts_collector(constructor = c("col", "next", "list"), ...)

• opts_complex(constructor = c("default"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE)

• opts_constructive_options(constructor = c("opts", "next"), ...)

• opts_CoordCartesian(constructor = c("default", "coord_cartesian", "next", "environment"), ...)

• opts_CoordFixed(constructor = c("coord_fixed", "next", "environment"), ...)

• opts_CoordFlip(constructor = c("coord_flip", "next", "environment"), ...)

• opts_CoordMap(constructor = c("coord_map", "next", "environment"), ...)

• opts_CoordMunch(constructor = c("coord_munch", "next", "environment"), ...)

• opts_CoordPolar(constructor = c("coord_polar", "next", "environment"), ...)

• opts_CoordQuickmap(constructor = c("coord_quickmap", "next", "environment"), ...)

• opts_CoordRadial(constructor = c("coord_radial", "next"), ...)

• opts_CoordSf(constructor = c("coord_sf", "next", "environment"), ...)

• opts_CoordTrans(constructor = c("coord_trans", "next", "environment"), ...)

• opts_CoordTransform(constructor = c("coord_transform", "next"), ...)

• opts_crs(constructor = c("st_crs", "next"), ...)

• opts_data.frame(constructor = c("data.frame", "read.table", "next", "list"), ..., recycle = TRUE)

• opts_data.table(constructor = c("data.table", "next", "list"), ..., selfref = FALSE, recycle = TRUE)

• opts_Date(constructor = c("as.Date", "as_date", "date", "new_date", "as.Date.numeric", "as_date.numeric", "next", "double"), ..., origin = "1970-01-01")

• opts_date_names(constructor = c("date_names_lang", "date_names", "next", "list"), ...)

• opts_denseMatrix(constructor = c("Matrix", "next"), ...)

• opts_diagonalMatrix(constructor = c("Diagonal", "next"), ...)

• opts_difftime(constructor = c("as.difftime", "next"), ...)

• opts_dist(constructor = c("as.dist", "next"), ...)

• opts_dm(constructor = c("dm", "next", "list"), ...)

• opts_dots(constructor = c("default"), ...)

• opts_double(constructor = c("default"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE)

• opts_Duration(constructor = c("default", "dseconds", "duration", "next"), ...)

• opts_ecdf(constructor = c("ecdf", "next"), ...)

• opts_element_blank(constructor = c("element_blank", "next", "list"), ...)

• opts_element_grob(constructor = c("element_grob", "next", "list"), ...)

• opts_element_line(constructor = c("element_line", "next", "list"), ...)

• opts_element_rect(constructor = c("element_rect", "next", "list"), ...)

• opts_element_render(constructor = c("element_render", "next", "list"), ...)

• opts_element_text(constructor = c("element_text", "next", "list"), ...)

• opts_ellmer_TypeArray(constructor = c("type_array", "TypeArray", "next"), ...)

• opts_ellmer_TypeBasic(constructor = c("default", "TypeBasic", "next"), ...)

• opts_ellmer_TypeEnum(constructor = c("type_enum", "TypeEnum", "next"), ...)

• opts_ellmer_TypeJsonSchema(constructor = c("type_from_schema", "TypeJsonSchema", "next"), ...)

• opts_ellmer_TypeObject(constructor = c("type_object", "TypeObject", "next"), ...)

• opts_environment(constructor = c(".env", "list2env", "as.environment", "new.env", "topenv", "new_environment", "predefine", "unserialize"), ..., recurse = FALSE, context = c("parents", "attributes", "locked"))

• opts_error(constructor = c("errorCondition", "next"), ...)

• opts_expression(constructor = c("default"), ...)

• opts_externalptr(constructor = c("default"), ...)

• opts_FacetGrid(constructor = c("facet_grid", "ggproto", "next", "environment"), ...)

• opts_FacetNull(constructor = c("facet_null", "next"), ...)

• opts_FacetWrap(constructor = c("facet_wrap", "ggproto", "next", "environment"), ...)

• opts_factor(constructor = c("factor", "as_factor", "new_factor", "next", "integer"), ...)

• opts_formula(constructor = c("default", "formula", "as.formula", "new_formula", "next"), ..., environment = TRUE)

• opts_fs_bytes(constructor = c("as_fs_bytes", "next"), ...)

• opts_fs_path(constructor = c("path", "as_fs_path", "next"), ...)

• opts_fs_perms(constructor = c("as_fs_perms", "next"), ...)

• opts_ftable(constructor = c("ftable", "next"), ...)

• opts_function(constructor = c("function", "as.function", "new_function"), ..., environment = TRUE, srcref = FALSE, trim = NULL)

• opts_ggplot(constructor = c("ggplot", "next", "list"), ...)

• opts_ggplot2_element_blank(constructor = c("element_blank", "next"), ...)

• opts_ggplot2_element_geom(constructor = c("element_geom", "next"), ...)

• opts_ggplot2_element_line(constructor = c("element_line", "next"), ...)

• opts_ggplot2_element_point(constructor = c("element_point", "next"), ...)

• opts_ggplot2_element_polygon(constructor = c("element_polygon", "next"), ...)

• opts_ggplot2_element_rect(constructor = c("element_rect", "next"), ...)

• opts_ggplot2_element_text(constructor = c("element_text", "next"), ...)

• opts_ggplot2_ggplot(constructor = c("ggplot", "next", "list"), ...)

• opts_ggplot2_labels(constructor = c("labs", "next"), ...)

• opts_ggplot2_mapping(constructor = c("aes", "next", "list"), ...)

• opts_ggplot2_margin(constructor = c("margin", "next", "double"), ...)

• opts_ggplot2_theme(constructor = c("default", "theme", "next", "list"), ...)

• opts_ggproto(constructor = c("default", "ggproto", "next", "environment"), ...)

• opts_glue(constructor = c("as_glue", "next"), ...)

• opts_grouped_df(constructor = c("default", "next", "list"), ...)

• opts_grouped_ts(constructor = c("group_by", "next"), ...)

• opts_Guide(constructor = c("default", "next", "environment"), ...)

• opts_GuideAxis(constructor = c("guide_axis", "next"), ...)

• opts_GuideAxisLogticks(constructor = c("guide_axis_logticks", "next"), ...)

• opts_GuideAxisStack(constructor = c("guide_axis_stack", "next"), ...)

• opts_GuideAxisTheta(constructor = c("guide_axis_theta", "next"), ...)

• opts_GuideBins(constructor = c("guide_bins", "next"), ...)

• opts_GuideColourbar(constructor = c("guide_colorbar", "next"), ...)

• opts_GuideColoursteps(constructor = c("guide_colorsteps", "next"), ...)

• opts_GuideCustom(constructor = c("guide_custom", "next"), ...)

• opts_GuideLegend(constructor = c("guide_legend", "next"), ...)

• opts_GuideNone(constructor = c("guide_none", "next"), ...)

• opts_Guides(constructor = c("guides", "next"), ...)

• opts_haven_labelled(constructor = c("labelled", "next"), ...)

• opts_haven_labelled_spss(constructor = c("labelled_spss", "next"), ...)

• opts_hexmode(constructor = c("as.hexmode", "next"), ..., integer = FALSE)

• opts_hms(constructor = c("as_hms", "hms", "new_hms", "next", "double"), ...)

• opts_html(constructor = c("HTML", "next"), ...)

• opts_html_dependency(constructor = c("htmlDependency", "next"), ...)

• opts_IDate(constructor = c("as.IDate", "next", "integer"), ...)

• opts_indMatrix(constructor = c("as", "next"), ...)

• opts_integer(constructor = c("default"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE)

• opts_integer64(constructor = c("as.integer64", "next", "double"), ...)

• opts_Interval(constructor = c("interval", "next"), ...)

• opts_ITime(constructor = c("as.ITime", "next", "integer"), ...)

• opts_labels(constructor = c("labs", "next", "list"), ...)

• opts_language(constructor = c("default"), ...)

• opts_Layer(constructor = c("default", "layer", "next", "environment"), ...)

• opts_list(constructor = c("list", "list2"), ..., trim = NULL, fill = c("vector", "new_list", "+", "...", "none"))

• opts_locale(constructor = c("locale", "next", "list"), ...)

• opts_logical(constructor = c("default"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE)

• opts_margin(constructor = c("margin", "next", "double"), ...)

• opts_matrix(constructor = c("matrix", "array", "cbind", "rbind", "next"), ..., byrow = FALSE)

• opts_mixed_units(constructor = c("mixed_units", "next"), ...)

• opts_mts(constructor = c("ts", "next", "atomic"), ...)

• opts_noquote(constructor = c("noquote", "next"), ...)

• opts_NULL(constructor = "NULL", ...)

• opts_numeric_version(constructor = c("numeric_version", "next", "list"), ...)

• opts_object(constructor = c("prototype", "S7_object"), ...)

• opts_octmode(constructor = c("as.octmode", "next"), ..., integer = FALSE)

• opts_ordered(constructor = c("ordered", "factor", "new_ordered", "next", "integer"), ...)

• opts_package_version(constructor = c("package_version", "next", "list"), ...)

• opts_pairlist(constructor = c("pairlist", "pairlist2"), ...)

• opts_Period(constructor = c("period", "next"), ...)

• opts_person(constructor = c("person", "next"), ...)

• opts_POSIXct(constructor = c("as.POSIXct", ".POSIXct", "as_datetime", "as.POSIXct.numeric", "as_datetime.numeric", "next", "atomic"), ..., origin = "1970-01-01")

• opts_POSIXlt(constructor = c("as.POSIXlt", "next", "list"), ...)

• opts_quosure(constructor = c("new_quosure", "next", "language"), ...)

• opts_quosures(constructor = c("new_quosures", "next", "list"), ...)

• opts_R_system_version(constructor = c("R_system_version", "next", "list"), ...)

• opts_R6(constructor = c("R6Class", "next"), ...)

• opts_R6ClassGenerator(constructor = c("R6Class", "next"), ...)

• opts_raster(constructor = c("as.raster", "next"), ...)

• opts_raw(constructor = c("as.raw", "charToRaw"), ..., trim = NULL, fill = c("default", "rlang", "+", "...", "none"), compress = TRUE, representation = c("hexadecimal", "decimal"))

• opts_rel(constructor = c("rel", "next", "double"), ...)

• opts_roman(constructor = c("as.roman", "next"), ...)

• opts_rowwise_df(constructor = c("default", "next", "list"), ...)

• opts_S4(constructor = c("new", "prototype"), ...)

• opts_S7_any(constructor = c("class_any", "next"), ...)

• opts_S7_base_class(constructor = c("S7", "next"), ...)

• opts_S7_class(constructor = c("new_class", "next"), ...)

• opts_S7_external_generic(constructor = c("new_external_generic", "next"), ...)

• opts_S7_generic(constructor = c("new_generic", "next"), ...)

• opts_S7_object(constructor = c("S7_object", "next"), ...)

• opts_S7_property(constructor = c("new_property", "next"), ...)

• opts_S7_S3_class(constructor = c("new_S3_class", "next"), ...)

• opts_S7_union(constructor = c("default", "|", "new_union", "next"), ...)

• opts_Scale(constructor = c("default", "next", "environment"), ...)

• opts_ScalesList(constructor = c("ScalesList", "next", "list"), ...)

• opts_sf(constructor = c("st_sf", "next"), ...)

• opts_sfc(constructor = c("st_sfc", "next"), ...)

• opts_sfg(constructor = c("st_sfg", "next"), ...)

• opts_shiny.tag(constructor = c("tags", "tag", "next"), ...)

• opts_shiny.tag.function(constructor = c("tagFunction", "next"), ...)

• opts_shiny.tag.list(constructor = c("tagList", "next"), ...)

• opts_simpleCondition(constructor = c("simpleCondition", "next"), ...)

• opts_simpleError(constructor = c("simpleError", "next"), ...)

• opts_simpleMessage(constructor = c("simpleMessage", "next"), ...)

• opts_simpleUnit(constructor = c("unit", "next", "double"), ...)

• opts_simpleWarning(constructor = c("simpleWarning", "next"), ...)

• opts_sparseMatrix(constructor = c("sparseMatrix", "next"), ...)

• opts_sparseVector(constructor = c("sparseVector", "next"), ...)

• opts_stepfun(constructor = c("stepfun", "next"), ...)

• opts_Surv(constructor = c("Surv", "next"), ...)

• opts_table(constructor = c("as.table", "next"), ...)

• opts_tbl_df(constructor = c("tibble", "tribble", "next", "list"), ..., trailing_comma = TRUE, justify = c("left", "right", "centre", "none"), recycle = TRUE)

• opts_tbl_ts(constructor = c("tsibble", "as_tsibble", "next"), ...)

• opts_theme(constructor = c("default", "theme", "next", "list"), ...)

• opts_ts(constructor = c("ts", "next", "atomic"), ...)

• opts_uneval(constructor = c("aes", "next", "list"), ...)

• opts_units(constructor = c("set_units", "as_units", "next"), ...)

• opts_vctrs_list_of(constructor = c("list_of", "next", "list"), ...)

• opts_vctrs_rcrd(constructor = c("new_rcrd", "next", "list"), ...)

• opts_vctrs_unspecified(constructor = c("unspecified", "next"), ...)

• opts_vctrs_vctr(constructor = c("new_vctr", "next"), ...)

• opts_waiver(constructor = c("waiver", "next", "list"), ...)

• opts_warning(constructor = c("warningCondition", "next"), ...)

• opts_weakref(constructor = c("new_weakref"), ...)

• opts_xml_document(constructor = c("default", "next"), ..., simplify = TRUE)

• opts_xts(constructor = c("xts", "as.xts.matrix", "as.xts.data.frame", ".xts", "next"), ...)

• opts_yearmon(constructor = c("as.yearmon", "yearmon", "next"), ...)

• opts_yearmonth(constructor = c("yearmonth", "next"), ...)

• opts_yearqtr(constructor = c("as.yearqtr", "yearqtr", "next"), ...)

• opts_yearquarter(constructor = c("yearquarter", "next"), ...)

• opts_yearweek(constructor = c("yearweek", "next"), ...)

• opts_zoo(constructor = c("zoo", "next"), ...)

• opts_zooreg(constructor = c("zooreg", "next"), ...)

See Also

construct_dput() construct_base() construct_clip() construct_dump() construct_reprex() construct_diff()

Examples

construct(head(cars))
construct(head(cars), opts_data.frame("read.table"))
construct(head(cars), opts_data.frame("next"))
construct(iris$Species)
construct(iris$Species, opts_atomic(compress = FALSE), opts_factor("new_factor"))
construct_multi(list(a = head(cars), b = iris$Species))

Description

This is a simple wrapper for convenience, construct_clip(x, ...) is equivalent to print(construct(x, ...), print_mode = "clipboard") (an idiom that you might use to use the clipboard with other functions). For more flexible printing options see ?constructive_print_mode.

Usage

construct_clip(
  x,
  ...,
  data = NULL,
  pipe = NULL,
  check = NULL,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template"),
  classes = NULL
)

Arguments

Value

An object of class 'constructive', invisibly. Called for side effects.

Examples

## Not run: 
construct_clip(head(cars))

## End(Not run)

Description

This calls construct() on two objects and compares the output using diffobj::diffChr().

Usage

construct_diff(
  target,
  current,
  ...,
  data = NULL,
  pipe = NULL,
  check = TRUE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template"),
  classes = NULL,
  mode = c("sidebyside", "auto", "unified", "context"),
  interactive = TRUE
)

Arguments

Value

Returns NULL invisibly, called for side effects

Examples

## Not run: 
# some object print the same though they're different
# `construct_diff()` shows how they differ :
df1 <- data.frame(a=1, b = "x")
df2 <- data.frame(a=1L, b = "x", stringsAsFactors = TRUE)
attr(df2, "some_attribute") <- "a value"
df1
df2
construct_diff(df1, df2)


# Those are made easy to compare
construct_diff(substr, substring)
construct_diff(month.abb, month.name)

# more examples borrowed from {waldo} package
construct_diff(c("a", "b", "c"), c("a", "B", "c"))
construct_diff(c("X", letters), c(letters, "X"))
construct_diff(list(factor("x")), list(1L))
construct_diff(df1, df2)
x <- list(a = list(b = list(c = list(structure(1, e = 1)))))
y <- list(a = list(b = list(c = list(structure(1, e = "a")))))
construct_diff(x, y)

## End(Not run)

Description

• construct_dput() is a closer counterpart to base::dput() that doesn't use higher level constructors such as data.frame() and factor().

• construct_base() uses higher constructors, but only for the classes maintained in the default base R packages. This includes data.frame() and factor(), the S4 constructors from the 'method' package etc, but not data.table() and other constructors for classes from other packages.

Usage

construct_dput(
  x,
  ...,
  data = NULL,
  pipe = NULL,
  check = NULL,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template")
)

construct_base(
  x,
  ...,
  data = NULL,
  pipe = NULL,
  check = NULL,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE,
  compare = compare_options(),
  one_liner = FALSE,
  template = getOption("constructive_opts_template")
)

Arguments

Details

Both functions are valuable for object inspection, and might provide more stable snapshots, since supporting more classes in the package means the default output of construct() might change over time for some objects.

To use higher level constructor from the base package itself, excluding for instance stats::ts(), utils::person() or methods::classGeneratorFunction()), we can call ⁠construct(x, classes = "{base}"⁠

Value

An object of class 'constructive'.

Examples

construct_dput(head(iris, 2))
construct_base(head(iris, 2))

Description

An alternative to base::dump() using code built with constructive.

Usage

construct_dump(x, path, append = FALSE, ...)

Arguments

Value

Returns NULL invisibly, called for side effects.

Description

Usually called without arguments right after an imperfect code generation, but can also be called on the 'constructive' object itself.

Usage

construct_issues(x = NULL)

Arguments

Value

A character vector with class "waldo_compare"

Description

construct_reprex() constructs all objects of the local environment, or a caller environment n steps above. If n > 0 the function call is also included in a comment.

Usage

construct_reprex(..., n = 0, include_dotted = TRUE)

Arguments

Details

construct_reprex() doesn't call the {reprex} package. construct_reprex() builds reproducible data while the reprex package build reproducible output once you have the data.

construct_reprex() wraps construct_multi() and is thus able to construct unevaluated arguments using delayedAssign(). This means we can construct reprexes for functions that use Non Standard Evaluation.

A useful trick is to use options(error = recover) to be able to inspect frames on error, and use construct_reprex() from there to reproduce the data state.

construct_reprex() might fail to reproduce the output of functions that refer to environments other than their caller environment. We believe these are very rare and that the simplicity is worth the rounded corners, but if you encounter these limitations please do open a ticket on our issue tracker at ⁠https://github.com/cynkra/constructive/⁠ and we might expand the feature.

Value

An object of class 'constructive'.

See Also

construct_multi()

Description

construct_serialize() creates code that reconstructs an R object by serializing it to raw bytes and then calling unserialize(). This is a fallback method that works for almost any R object, including those that are difficult or impossible to construct idiomatically.

Usage

construct_serialize(x, collapse_header = FALSE)

Arguments

Details

This function generates code in the form:

unserialize(as.raw(c(
  # --- HEADER ---
  c(0x58, 0x0a, ...),
  # --- DATA ---
  c(0x00, 0x00, ...)
)))

The generated code includes detailed comments explaining the binary structure, making it useful for understanding R's serialization format.

Limitations

construct_serialize() reproduces faithfully what serialize() does, so it shares its limitations. Some objects don't survive serialization or can be restored only in some conditions:

• External pointers: The address is lost, we get a null pointer

• Weak references: The key and value are lost

• Connections: Only the connection number is stored, the reconstructed object is valid only in the same session, as long as the connection is open

• Namespaces and package environments: They are stored by name, so the package must be available when the code is run

The function is designed for small objects, every byte is documented so the output is long and large objects (hundreds of kilobytes once serialized) are slow to process. Note that functions defined in a file keep a reference to the whole file through their srcref, use utils::removeSource() to get rid of it.

Value

An object of class "constructive_code" containing the generated code as a character vector. Each element is one line of code.

See Also

construct() for idiomatic object construction, serialize() for the underlying serialization mechanism.

Examples

# Simple objects
construct_serialize(1:5)
construct_serialize(c("hello", "world"))

# Complex objects
construct_serialize(data.frame(a = 1:3, b = letters[1:3]))
construct_serialize(matrix(1:6, nrow = 2))

# Objects with attributes
x <- c(a = 1, b = 2, c = 3)
construct_serialize(x)

# Expressions and calls
construct_serialize(quote(mean(x)))
construct_serialize(expression(x + 1, y * 2))

# Special values
construct_serialize(c(NA, NaN, Inf, -Inf))

# Builtin functions
construct_serialize(sum)
construct_serialize(`if`)

# The generated code can be evaluated to reconstruct the object
code <- construct_serialize(iris)
reconstructed <- eval(parse(text = paste(code, collapse = "\n")))
identical(reconstructed, iris)

Description

Construct a function's signature such as the one you can see right below in the 'Usage' section.

Usage

construct_signature(x, name = NULL, one_liner = FALSE, style = TRUE)

Arguments

Value

a string or a character vector, with a class "constructive_code" for pretty printing if style is TRUE

Examples

construct_signature(lm)

Description

Set these options to tweak {constructive}'s global behavior, to set them permanently you can edit your .RProfile1, e.g. using usethis::edit_r_profile().

Details

• Set ⁠options(constructive_print_mode = <character>)⁠ to change the default value of the print_mode argument, of print.constructive, where ⁠<character>⁠ is a vector of strings among the following :

  • "console" : The default behavior, the code is printed in the console

  • "script" : The code is copied to a new R script

  • "reprex" : The code is shown in the viewer as a reprex, the reprex (not only the code!) is also copied to the clipboard.

  • "clipboard" : The constructed code is copied to the clipboard, if combined with "reprex" this takes precedence (the reprex is showed in the viewer, the code without output is copied to the clipboard)

• Set ⁠options(constructive_opts_template = <list>)⁠ to set default constructive options, see documentation of the template arg in ?construct

• Set options(constructive_pretty = FALSE) to disable syntax highlighting.

Relevant options from other packages:

• cli.code_theme can be used to configure the syntax highlighting theme used by {constructive}; see cli::code_theme_list() for more information.

Description

An alternative to base::deparse() and rlang::expr_deparse() that handles additional corner cases and fails when encountering tokens other than symbols and syntactic literals where cited alternatives would produce non syntactic code.

Usage

deparse_call(
  call,
  one_liner = FALSE,
  pipe = FALSE,
  style = TRUE,
  collapse = !style,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  pedantic_encoding = FALSE
)

Arguments

Value

a string or a character vector, with a class "constructive_code" for pretty printing if style is TRUE.

Examples

expr <- quote(foo(bar({this; that}, 1)))
deparse_call(expr)
deparse_call(expr, one_liner = TRUE)
deparse_call(expr, pipe = TRUE)
deparse_call(expr, style = FALSE)

Description

We export a collection of functions that can be used to design custom methods for .cstr_construct() or custom constructors for a given method.

• .cstr_new_class() : Open template to support a new class

• .cstr_new_constructor() : Open template to implement a new constructor

• .cstr_construct() : Low level generic for object construction code generation

• .cstr_repair_attributes()' : Helper to repair attributes of objects

• .cstr_options() : Define and check options to pass to custom constructors

• .cstr_apply() : Build recursively the arguments passed to your constructor

• .cstr_wrap() : Wrap argument code in function code (rarely needed)

• .cstr_pipe() : Pipe a call to another (rarely needed)

• .cstr_combine_errors() : helper function report several errors at once when relevant

Description

These options will be used on arrays. Note that arrays can be built on top of vectors, lists or expressions. Canonical arrays have an implicit class "array" shown by class() but "array" is not part of the class attribute.

Usage

opts_array(constructor = c("array", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "array" (default): Use the array() function

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_array>

Description

These options will be used on objects of class AsIs. AsIs objects are created with I() which only prepends "AsIs" to the class attribute.

Usage

opts_AsIs(constructor = c("I", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "I" (default): Use the I() function

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_AsIs>

Description

These options will be used on atomic types ("logical", "integer", "numeric", "complex", "character" and "raw"). They can also be directly provided to atomic types through their own ⁠opts_*()⁠ function, and in this case the latter will have precedence.

Usage

opts_atomic(
  ...,
  trim = NULL,
  fill = c("default", "rlang", "+", "...", "none"),
  compress = TRUE
)

Arguments

Details

If trim is provided, depending on fill we will present trimmed elements as followed:

• "default" : Use default atomic constructors, so for instance c("a", "b", "c") might become c("a", character(2)).

• "rlang" : Use rlang atomic constructors, so for instance c("a", "b", "c") might become c("a", rlang::new_character(2)), these rlang constructors create vectors of NAs, so it's different from the default option.

• "+": Use unary +, so for instance c("a", "b", "c") might become c("a", +2).

• "...": Use ..., so for instance c("a", "b", "c") might become c("a", ...)

• "none": Don't represent trimmed elements.

Depending on the case some or all of the choices above might generate code that cannot be executed. The 2 former options above are the most likely to succeed and produce an output of the same type and dimensions recursively. This would at least be the case for data frame.

Value

An object of class <constructive_options/constructive_options_atomic>

Examples

construct(iris, opts_atomic(trim = 2), check = FALSE) # fill = "default"
construct(iris, opts_atomic(trim = 2, fill = "rlang"), check = FALSE)
construct(iris, opts_atomic(trim = 2, fill = "+"), check = FALSE)
construct(iris, opts_atomic(trim = 2, fill = "..."), check = FALSE)
construct(iris, opts_atomic(trim = 2, fill = "none"), check = FALSE)
construct(iris, opts_atomic(trim = 2, fill = "none"), check = FALSE)
x <- c("a a", "a\U000000A0a", "a\U00002002a", "\U430 \U430")

Description

These options will be used on objects of class 'bbox'.

Usage

opts_bbox(constructor = c("st_bbox", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "st_bbox" (default): We build the object using sf::st_bbox() on a named double vector, with a crs argument if relevant.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_bbox>

Description

These options will be used on objects of class 'blob'.

Usage

opts_blob(constructor = c("blob", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "blob" (default): Use blob::blob() on a raw object.

  • "new_blob" (default): Use blob::new_blob() on a list of raw objects.

• "as.blob" : Use blob::as_blob() on a character vector

Use opts_raw() and opts_character() to tweak the construction of raw or character objects constructed as part of the blob construction.

Value

An object of class <constructive_options/constructive_options_blob>

Description

These options will be used on objects of type 'character'. This type has a single native constructor, but some additional options can be set.

unicode_representation and escape are usually better set in the main function (construct() or other) so they apply not only on strings but on symbols and argument names as well.

To set options on all atomic types at once see opts_atomic().

Usage

opts_character(
  constructor = c("default"),
  ...,
  trim = NULL,
  fill = c("default", "rlang", "+", "...", "none"),
  compress = TRUE,
  unicode_representation = c("ascii", "latin", "character", "unicode"),
  escape = FALSE,
  multiline = FALSE
)

Arguments

Value

An object of class <constructive_options/constructive_options_character>

Description

These options will be used on objects of class 'classGeneratorFunction'.

Usage

opts_classGeneratorFunction(constructor = c("setClass"), ...)

Arguments

Value

An object of class <constructive_options/constructive_options_classGeneratorFunction>

Description

These options will be used on objects of class 'classPrototypeDef'.

Usage

opts_classPrototypeDef(constructor = c("prototype"), ...)

Arguments

Value

An object of class <constructive_options/constructive_options_classPrototypeDef>

Description

These options will be used on objects of class 'classRepresentation'.

Usage

opts_classRepresentation(constructor = c("getClassDef"), ...)

Arguments

Value

An object of class <constructive_options/constructive_options_classRepresentation>

Description

These options will be used on objects of class 'clock_duration'.

Usage

opts_clock_duration(constructor = c("duration", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "duration" (default): We build the object using the ⁠clock::duration_*()⁠ helper matching the precision, e.g. clock::duration_days(). Durations that don't fit in an integer are constructed with the "list" constructor.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_duration>

Description

These options will be used on objects of class 'clock_iso_year_week_day'.

Usage

opts_clock_iso_year_week_day(
  constructor = c("iso_year_week_day", "next", "list"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "iso_year_week_day" (default): We build the object using clock::iso_year_week_day(), providing the components required by the precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_iso_year_week_day>

Description

These options will be used on objects of class 'clock_naive_time'.

Usage

opts_clock_naive_time(constructor = c("as_naive_time", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_naive_time" (default): We build the object using clock::as_naive_time() on a clock::year_month_day() call of the same precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_naive_time>

Description

These options will be used on objects of class 'clock_sys_time'.

Usage

opts_clock_sys_time(constructor = c("as_sys_time", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_sys_time" (default): We build the object using clock::as_sys_time() on a clock::year_month_day() call of the same precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_sys_time>

Description

These options will be used on objects of class 'clock_weekday'.

Usage

opts_clock_weekday(constructor = c("weekday", "next", "integer"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "weekday" (default): We build the object using clock::weekday() on day codes, from 1 (Sunday) to 7 (Saturday).

• "next" : Use the constructor for the next supported class.

• "integer" : We define as an atomic vector and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_weekday>

Description

These options will be used on objects of class 'clock_year_day'.

Usage

opts_clock_year_day(constructor = c("year_day", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "year_day" (default): We build the object using clock::year_day(), providing the components required by the precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_year_day>

Description

These options will be used on objects of class 'clock_year_month_day'.

Usage

opts_clock_year_month_day(
  constructor = c("year_month_day", "next", "list"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "year_month_day" (default): We build the object using clock::year_month_day(), providing the components required by the precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_year_month_day>

Description

These options will be used on objects of class 'clock_year_month_weekday'.

Usage

opts_clock_year_month_weekday(
  constructor = c("year_month_weekday", "next", "list"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "year_month_weekday" (default): We build the object using clock::year_month_weekday(), providing the components required by the precision.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_year_month_weekday>

Description

These options will be used on objects of class 'clock_year_quarter_day'.

Usage

opts_clock_year_quarter_day(
  constructor = c("year_quarter_day", "next", "list"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "year_quarter_day" (default): We build the object using clock::year_quarter_day(), providing the components required by the precision, and start if it is not the default.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_year_quarter_day>

Description

These options will be used on objects of class 'clock_year_week_day'.

Usage

opts_clock_year_week_day(constructor = c("year_week_day", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "year_week_day" (default): We build the object using clock::year_week_day(), providing the components required by the precision, and start if it is not the default.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_year_week_day>

Description

These options will be used on objects of class 'clock_zoned_time'.

Usage

opts_clock_zoned_time(constructor = c("as_zoned_time", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_zoned_time" (default): We build the object using clock::as_zoned_time() on the local naive time, providing the zone and, when some local times are ambiguous, the ambiguous argument.

• "next" : Use the constructor for the next supported class.

• "list" : We define as a list and repair attributes.

Value

An object of class <constructive_options/constructive_options_clock_zoned_time>

Description

These options will be used on objects of class 'col_spec'.

Usage

opts_col_spec(constructor = c("cols", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "cols" (default): We build the object using readr::cols(), or readr::cols_only() when the default collector is readr::col_skip(). The .default argument is omitted when it's readr::col_guess().

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to "list"

• "list" : We define as a list and repair attributes

Use opts_collector() to tweak the construction of the column specifications.

Value

An object of class <constructive_options/constructive_options_col_spec>

Description

These options will be used on objects of class 'collector', i.e. column specifications as created by readr::col_double(), readr::col_date(), readr::col_factor() etc. They all share the class 'collector' and a subclass 'collector_' that maps to the constructor ⁠readr::col_<type>()⁠.

Usage

opts_collector(constructor = c("col", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "col" (default): We build the object using the relevant ⁠readr::col_*()⁠ function, e.g. readr::col_double() or readr::col_date(format = "%Y"), providing only non default arguments.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to "list"

• "list" : We define as a list and repair attributes

Value

An object of class <constructive_options/constructive_options_collector>

Description

These options will be used on objects of type 'complex'. This type has a single native constructor, but some additional options can be set.

To set options on all atomic types at once see opts_atomic().

Usage

opts_complex(
  constructor = c("default"),
  ...,
  trim = NULL,
  fill = c("default", "rlang", "+", "...", "none"),
  compress = TRUE
)

Arguments

Value

An object of class <constructive_options/constructive_options_complex>

Description

These options will be used on objects of class constructive_options.

Usage

opts_constructive_options(constructor = c("opts", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "opts" : Use the relevant ⁠constructive::opts_?()⁠ function.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_constructive_options>

Description

These options will be used on objects of class 'CoordRadial'.

Usage

opts_CoordRadial(constructor = c("coord_radial", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "coord_radial" (default): We build the object using ggplot2::coord_radial().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_CoordRadial>

Description

These options will be used on objects of class 'CoordTransform'.

Usage

opts_CoordTransform(constructor = c("coord_transform", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "coord_transform" (default): We build the object using ggplot2::coord_transform().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_CoordTransform>

Description

These options will be used on objects of class 'crs'.

Usage

opts_crs(constructor = c("st_crs", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "st_crs" (default): We build the object using sf::st_crs() on an EPSG code if possible (e.g. sf::st_crs(4326)), or else on the user input (e.g. sf::st_crs("OGC:CRS84")) or on the wkt definition, the first that reproduces the object exactly.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

The wkt definition of a crs depends on the installed PROJ version, so a crs object created on a different setup might not be reproducible with sf::st_crs(), in this case we fall back to the next constructor.

Value

An object of class <constructive_options/constructive_options_crs>

Description

These options will be used on objects of class 'data.frame'.

Usage

opts_data.frame(
  constructor = c("data.frame", "read.table", "next", "list"),
  ...,
  recycle = TRUE
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "data.frame" (default): Wrap the column definitions in a data.frame() call. If some columns are lists or data frames, we wrap the column definitions in tibble::tibble(). then use as.data.frame().

• "read.table" : We build the object using read.table() if possible, or fall back to data.frame().

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : Use list() and treat the class as a regular attribute.

Value

An object of class <constructive_options/constructive_options_data.frame>

Description

These options will be used on objects of class 'data.table'.

Usage

opts_data.table(
  constructor = c("data.table", "next", "list"),
  ...,
  selfref = FALSE,
  recycle = TRUE
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "data.table" (default): Wrap the column definitions in a data.table() call.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : Use list() and treat the class as a regular attribute.

Value

An object of class <constructive_options/constructive_options_data.table>

Description

These options will be used on objects of class 'date'.

Usage

opts_Date(
  constructor = c("as.Date", "as_date", "date", "new_date", "as.Date.numeric",
    "as_date.numeric", "next", "double"),
  ...,
  origin = "1970-01-01"
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as.Date" (default): We wrap a character vector with as.Date(), if the date is infinite it cannot be converted to character and we wrap a numeric vector and provide an origin argument.

• "as_date" : Similar as above but using lubridate::as_date(), the only difference is that we never need to supply origin.

• "date" : Similar as above but using lubridate::date(), it doesn't support infinite dates so we fall back on lubridate::as_date() when we encounter them.

• "new_date" : We wrap a numeric vector with vctrs::new_date()

• "as.Date.numeric" : We wrap a numeric vector with as.Date() and use the provided origin

• "as_date.numeric" : Same as above but using lubridate::as_date() and use the provided origin

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "double" : We define as an double vector and repair attributes

If the data is not appropriate for a constructor we fall back to another one appropriately.

Value

An object of class <constructive_options/constructive_options_Date>

Description

These options will be used on objects of class 'date_names'.

Usage

opts_date_names(
  constructor = c("date_names_lang", "date_names", "next", "list"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "date_names_lang" (default): We build the object using readr::date_names_lang() if the object matches one of the languages listed by readr::date_names_langs(), and fall back to the "date_names" constructor otherwise.

• "date_names" : We build the object using readr::date_names(), providing only non default arguments.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to "list"

• "list" : We define as a list and repair attributes

Value

An object of class <constructive_options/constructive_options_date_names>

Description

These options will be used on objects of class 'denseMatrix' from the 'Matrix' package, i.e. objects of classes such as 'dgeMatrix', 'lgeMatrix', 'dsyMatrix' or 'dtrMatrix'.

Usage

opts_denseMatrix(constructor = c("Matrix", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "Matrix" (default): We build the object using Matrix::Matrix() on a base matrix, with sparse = FALSE. Matrix::Matrix() detects symmetric and triangular matrices so if this cannot reproduce the object exactly (e.g. a general matrix with symmetric content, packed storage, cached factorizations) we fall back to the next constructor.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_denseMatrix>

Description

These options will be used on objects of class 'diagonalMatrix' from the 'Matrix' package, i.e. objects of classes 'ddiMatrix' or 'ldiMatrix'.

Usage

opts_diagonalMatrix(constructor = c("Diagonal", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "Diagonal" (default): We build the object using Matrix::Diagonal(). If this cannot reproduce the object exactly (e.g. different row and column names) we fall back to the next constructor.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_diagonalMatrix>

Description

These options will be used on objects of class 'dist'.

Usage

opts_dist(constructor = c("as.dist", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as.dist" (default): We build the object using as.dist() on a symmetric matrix. The "call" attribute, and the "method" attribute set by dist(), are then repaired.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to opts_atomic().

Value

An object of class <constructive_options/constructive_options_dist>

Description

These options will be used on objects of class 'dm'.

Usage

opts_dm(constructor = c("dm", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "dm" (default): We use dm::dm() and other functions from dm to adjust the content. This does not strictly reproduce the object because each dm calls creates different uuid values for its tables, but the recreated object is functionally equivalent. Use the "list" constructor for fully accurate reconstruction.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : Use list() and treat the class as a regular attribute.

Value

An object of class <constructive_options/constructive_options_dm>

Description

These options will be used on objects of type '...'. These are rarely encountered in practice. By default this function is useless as nothing can be set, this is provided in case users want to extend the method with other constructors.

Usage

opts_dots(constructor = c("default"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "default" : We use the construct ⁠(function(...) get(\"...\"))(a = x, y)⁠ which we evaluate in the correct environment.

Value

An object of class <constructive_options/constructive_options_dots>

Description

These options will be used on objects of type 'double'. This type has a single native constructor, but some additional options can be set.

To set options on all atomic types at once see opts_atomic().

Usage

opts_double(
  constructor = c("default"),
  ...,
  trim = NULL,
  fill = c("default", "rlang", "+", "...", "none"),
  compress = TRUE
)

Arguments

Value

An object of class <constructive_options/constructive_options_double>

Description

These options will be used on objects of class 'Duration'.

Usage

opts_Duration(constructor = c("default", "dseconds", "duration", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "default" (default): We build the object using the largest of lubridate::dyears(), lubridate::dmonths(), lubridate::dweeks(), lubridate::ddays(), lubridate::dhours(), lubridate::dminutes() and lubridate::dseconds() for which all the elements are whole numbers and the object is reproduced exactly, so an hour is built with lubridate::dhours(1) rather than lubridate::dseconds(3600). Note that the years and months of 'lubridate' durations are fixed approximations, of 365.25 and 30.4375 days respectively, so 31557600 seconds come out as lubridate::dyears(1). NA elements don't constrain the choice, and we use lubridate::dseconds() if all elements are NA or zero, or if the object is empty.

• "dseconds" : We build the object using lubridate::dseconds() on a number of seconds.

• "duration" : We build the object using lubridate::duration() on a number of seconds.

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_Duration>

Description

These options will be used on objects of class 'ecdf'.

Usage

opts_ecdf(constructor = c("ecdf", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "ecdf" (default): We build the object using ecdf(), the sorted non-missing data is retrieved from the function's enclosure. The "call" attribute is repaired if it differs from the constructed call.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to opts_stepfun().

Value

An object of class <constructive_options/constructive_options_ecdf>

Description

These options will be used on objects of class 'ellmer::TypeArray''.

Usage

opts_ellmer_TypeArray(constructor = c("type_array", "TypeArray", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "TypeArray" (default): We build the object using ellmer::TypeArray().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ellmer::TypeArray'>

Description

These options will be used on objects of class 'ellmer::TypeBasic''.

Usage

opts_ellmer_TypeBasic(constructor = c("default", "TypeBasic", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "TypeBasic" (default): We build the object using ellmer::TypeBasic().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ellmer::TypeBasic'>

Description

These options will be used on objects of class 'ellmer::TypeEnum''.

Usage

opts_ellmer_TypeEnum(constructor = c("type_enum", "TypeEnum", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "TypeEnum" (default): We build the object using ellmer::TypeEnum().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ellmer::TypeEnum'>

Description

These options will be used on objects of class 'ellmer::TypeJsonSchema''.

Usage

opts_ellmer_TypeJsonSchema(
  constructor = c("type_from_schema", "TypeJsonSchema", "next"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "TypeJsonSchema" (default): We build the object using ellmer::TypeJsonSchema().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ellmer::TypeJsonSchema'>

Description

These options will be used on objects of class 'ellmer::TypeObject''.

Usage

opts_ellmer_TypeObject(
  constructor = c("type_object", "TypeObject", "next"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "TypeObject" (default): We build the object using ellmer::TypeObject().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ellmer::TypeObject'>

Description

Environments use reference semantics, they cannot be copied. An attempt to copy an environment would indeed yield a different environment and identical(env, copy) would be FALSE.
Moreover most environments have a parent (exceptions are emptyenv() and some rare cases where the parent is NULL) and thus to copy the environment we'd have to have a way to point to the parent, or copy it too.
For this reason environments are constructive's cryptonite. They make some objects impossible to reproduce exactly. And since every function or formula has one they're hard to avoid.

Usage

opts_environment(
  constructor = c(".env", "list2env", "as.environment", "new.env", "topenv",
    "new_environment", "predefine", "unserialize"),
  ...,
  recurse = FALSE,
  context = c("parents", "attributes", "locked")
)

Arguments

Details

In some case we can build code that points to a specific environment, namely:

• .GlobalEnv, .BaseNamespaceEnv, baseenv() and emptyenv() are used to construct the global environment, the base namespace, the base package environment and the empty environment

• Namespaces are constructed using asNamespace("pkg")

• Package environments are constructed using as.environment("package:pkg")

• "imports" environments are constructed with parent.env(asNamespace("pkg"))

• "lazydata" environments are constructed with getNamespaceInfo("pkg", "lazydata")

By default For other environments we use constructive's function constructive::.env(), it fetches the environment from its memory address and provides as additional information the sequence of parents until we reach a special environment (those enumerated above). The advantage of this approach is that it's readable and that the object is accurately reproduced. The inconvenient is that it's not stable between sessions. If an environment has a NULL parent it's always constructed with constructive::.env(), whatever the choice of the constructor.

Often however we wish to be able to reproduce from scratch a similar environment, so that we might run the constructed code later in a new session. We offer different different options to do this, with different trade-offs regarding accuracy and verbosity.

{constructive} will not signal any difference if it can reproduce an equivalent environment, defined as containing the same values and having a same or equivalent parent.

See also the ignore_function_env argument in ?compare_options, which disables the check of environments of function.

Value

An object of class <constructive_options/constructive_options_environment>

Constructors

We might set the constructor argument to:

• ".env" (default): use constructive::.env() to construct the environment from its memory address. Additional information is displayed through its non-functional arguments, see the context argument.

• "list2env": We construct the environment as a list then use base::list2env() to convert it to an environment and assign it a parent. By default we use as a parent the first special environment we find when going through ancestors, so we can print code that doesn't use .env(). If recurse is TRUE the parent will be built recursively so all ancestors will be created until we meet a known environment, this might be verbose and will fail if environments are nested too deep or have a circular relationship. If the environment is empty we use new.env(parent=) for a more economic syntax.

• "new_environment" : Similar to the above, but using rlang::new_environment().

• "new.env" : All environments will be recreated with the code "base::new.env()", without argument, effectively creating an empty environment child of the local (often global) environment. This is enough in cases where the environment doesn't matter (or matters as long as it inherits from the local environment), as is often the case with formulas. recurse is ignored.

• "as.environment" : we attempt to construct the environment as a list and use base::as.environment() on top of it, as in as.environment(list(a=1, b=2)), it will contain the same variables as the original environment but the parent will be the emptyenv(). recurse is ignored.

• "topenv" : we construct base::topenv(x), see ?topenv. recurse is ignored. This is the most accurate we can be when constructing only special environments.

• "predefine" : Building environments from scratch using the above methods can be verbose, sometimes redundant and sometimes even impossible due to circularity (e.g. an environment referencing itself). With "predefine" we define the environments and their content above the object returning call, using placeholder names ..env.1.., ..env.2.. etc. The caveat is that the created code won't be a single call and will create objects in the workspace. recurse is ignored.

• "unserialize" : We serialize the environment and construct it with unserialize() on the raw vector. The code is not readable but it reproduces the environment exactly in a new session: its parents up to a special environment, its bindings including active bindings and promises, its attributes and whether it is locked. Special environments met on the way, like namespaces, are serialized by name. recurse is ignored.

Description

These options will be used on objects of type 'externalptr'. By default this function is useless as nothing can be set, this is provided in case users wan to extend the method with other constructors.

Usage

opts_externalptr(constructor = c("default"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "default" : We use a special function from the constructive

Value

An object of class <constructive_options/constructive_options_externalptr>

Description

These options will be used on objects of class 'FacetNull'.

Usage

opts_FacetNull(constructor = c("facet_null", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "facet_null" (default): We build the object using ggplot2::facet_null().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_FacetNull>

Description

These options will be used on objects of class 'factor'.

Usage

opts_factor(
  constructor = c("factor", "as_factor", "new_factor", "next", "integer"),
  ...
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "factor" (default): Build the object using factor(), levels won't be defined explicitly if they are in alphabetical order (locale dependent!)

• "as_factor" : Build the object using forcats::as_factor() whenever possible, i.e. when levels are defined in order of appearance in the vector. Otherwise falls back to "factor" constructor.

• "new_factor" : Build the object using vctrs::new_factor(). Levels are always defined explicitly.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "integer" : We define as an integer vector and repair attributes.

Value

An object of class <constructive_options/constructive_options_factor>

Description

These options will be used on formulas, defined as calls to ~, regardless of their "class" attribute.

Usage

opts_formula(
  constructor = c("default", "formula", "as.formula", "new_formula", "next"),
  ...,
  environment = TRUE
)

Arguments

Value

An object of class <constructive_options/constructive_options_formula>

Description

These options will be used on objects of class 'fs_bytes'.

Usage

opts_fs_bytes(constructor = c("as_fs_bytes", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_fs_bytes" (default): Build the object using fs::as_fs_bytes() on a numeric vector.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_fs_bytes>

Description

These options will be used on objects of class 'fs_path'.

Usage

opts_fs_path(constructor = c("path", "as_fs_path", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "path" (default): Build the object using fs::path() on a character vector.

• "as_fs_path" : Build the object using fs::as_fs_path() on a character vector.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Both fs::path() and fs::as_fs_path() tidy their input, so paths that are not tidy (e.g. "a//b/") are always constructed with the "next" constructor.

Value

An object of class <constructive_options/constructive_options_fs_path>

Description

These options will be used on objects of class 'fs_perms'.

Usage

opts_fs_perms(constructor = c("as_fs_perms", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_fs_perms" (default): Build the object using fs::as_fs_perms() on octal strings such as "644". Vectors of length other than 1 or 2 are first converted with as.octmode(), because fs::as_fs_perms() scrambles the order of longer character vectors.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Objects containing NA or negative values are always constructed with the "next" constructor.

Value

An object of class <constructive_options/constructive_options_fs_perms>

Description

These options will be used on objects of class 'ftable'.

Usage

opts_ftable(constructor = c("ftable", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "ftable" (default): We build the object using ftable() on a table, providing the row.vars argument when needed.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried. This will usually be equivalent to opts_matrix("matrix").

Value

An object of class <constructive_options/constructive_options_ftable>

Description

These options will be used on functions, i.e. objects of type "closure", "special" and "builtin".

Usage

opts_function(
  constructor = c("function", "as.function", "new_function"),
  ...,
  environment = TRUE,
  srcref = FALSE,
  trim = NULL
)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "function" (default): Build the object using a standard function() {} definition. This won't set the environment by default, unless environment is set to TRUE. If a srcref is available, if this srcref matches the function's definition, and if trim is left NULL, the code is returned from using the srcref, so comments will be shown in the output of construct(). In the rare case where the ast body of the function contains non syntactic nodes this constructor cannot be used and falls back to the "as.function" constructor.

• "as.function" : Build the object using a as.function() call. back to data.frame().

• "new_function" : Build the object using a rlang::new_function() call.

Value

An object of class <constructive_options/constructive_options_function>

Description

These options will be used on objects of class 'ggplot'.

Usage

opts_ggplot(constructor = c("ggplot", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "ggplot" (default): Use ggplot2::ggplot()

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : Use list() and treat the class as a regular attribute.

Value

An object of class <constructive_options/constructive_options_ggplot>

Description

These options will be used on objects of class 'ggplot2::ggplot'.

Usage

opts_ggplot2_ggplot(constructor = c("ggplot", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "ggplot" (default): Use ggplot2::ggplot()

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : Use list() and treat the class as a regular attribute.

Value

An object of class <constructive_options/constructive_options_ggplot2::ggplot>

Description

These options will be used on objects of class 'ggplot2::labels'.

Usage

opts_ggplot2_labels(constructor = c("labs", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "labs" (default): We build the object using ggplot2::labs().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_ggplot2::labels>

Description

These options will be used on objects of class 'glue'.

Usage

opts_glue(constructor = c("as_glue", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_glue" (default): Use glue::as_glue() on a character vector.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Use opts_character() to tweak the construction of the character vector constructed as part of the glue construction.

Value

An object of class <constructive_options/constructive_options_glue>

Description

These options will be used on objects of class 'grouped_df'.

Usage

opts_grouped_df(constructor = c("default", "next", "list"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "list" : We define as an list object and repair attributes.

Value

An object of class <constructive_options/constructive_options_factor>

Description

These options will be used on objects of class 'grouped_ts'.

Usage

opts_grouped_ts(constructor = c("group_by", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "group_by" (default): Construct the ungrouped tsibble and pipe it into dplyr::group_by(), and into tsibble::index_by() if the object is grouped by an index. Use opts_tbl_ts() to tweak the construction of the tsibble.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_grouped_ts>

Description

These options will be used on objects of class 'GuideAxis'.

Usage

opts_GuideAxis(constructor = c("guide_axis", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_axis" (default): We build the object using ggplot2::guide_axis().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideAxis>

Description

These options will be used on objects of class 'GuideAxisLogticks'.

Usage

opts_GuideAxisLogticks(constructor = c("guide_axis_logticks", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_axis_logticks" (default): We build the object using ggplot2::guide_axis_logticks().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideAxisLogticks>

Description

These options will be used on objects of class 'GuideAxisStack'.

Usage

opts_GuideAxisStack(constructor = c("guide_axis_stack", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_axis_stack" (default): We build the object using ggplot2::guide_axis_stack().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideAxisStack>

Description

These options will be used on objects of class 'GuideAxisTheta'.

Usage

opts_GuideAxisTheta(constructor = c("guide_axis_theta", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_axis_theta" (default): We build the object using ggplot2::guide_axis_theta().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideAxisTheta>

Description

These options will be used on objects of class 'GuideBins'.

Usage

opts_GuideBins(constructor = c("guide_bins", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_bins" (default): We build the object using ggplot2::guide_bins().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideBins>

Description

These options will be used on objects of class 'GuideColourbar'.

Usage

opts_GuideColourbar(constructor = c("guide_colorbar", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_colorbar" (default): We build the object using ggplot2::guide_colorbar().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideColourbar>

Description

These options will be used on objects of class 'GuideColoursteps'.

Usage

opts_GuideColoursteps(constructor = c("guide_colorsteps", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_colorsteps" (default): We build the object using ggplot2::guide_colorsteps().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideColoursteps>

Description

These options will be used on objects of class 'GuideCustom'.

Usage

opts_GuideCustom(constructor = c("guide_custom", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_custom" (default): We build the object using ggplot2::guide_custom().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideCustom>

Description

These options will be used on objects of class 'GuideLegend'.

Usage

opts_GuideLegend(constructor = c("guide_legend", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_legend" (default): We build the object using ggplot2::guide_legend().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideLegend>

Description

These options will be used on objects of class 'GuideNone'.

Usage

opts_GuideNone(constructor = c("guide_none", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guide_none" (default): We build the object using ggplot2::guide_none().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_GuideNone>

Description

These options will be used on objects of class 'Guides'.

Usage

opts_Guides(constructor = c("guides", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "guides" (default): We build the object using ggplot2::guides().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_Guides>

Description

These options will be used on objects of class 'haven_labelled'.

Usage

opts_haven_labelled(constructor = c("labelled", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "labelled" (default): We build the object using haven::labelled(), the labels and label arguments are omitted when NULL.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_haven_labelled>

Description

These options will be used on objects of class 'haven_labelled_spss'.

Usage

opts_haven_labelled_spss(constructor = c("labelled_spss", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "labelled_spss" (default): We build the object using haven::labelled_spss(), the labels, na_values, na_range and label arguments are omitted when NULL.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

Value

An object of class <constructive_options/constructive_options_haven_labelled_spss>

Description

These options will be used on objects of class 'hexmode'.

Usage

opts_hexmode(constructor = c("as.hexmode", "next"), ..., integer = FALSE)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as.hexmode" (default): We build the object using as.hexmode()

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_hexmode>

Description

These options will be used on objects of class 'hms'.

Usage

opts_hms(constructor = c("as_hms", "hms", "new_hms", "next", "double"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "as_hms" (default): We build the object using hms::as_hms() on a character vector in the format "12:34:56". If some values cannot be reproduced exactly this way (e.g. negative values, durations of more than 24 hours, or some fractional seconds) we fall back to the "hms" constructor.

• "hms" : We build the object using hms::hms() on seconds, minutes and hours arguments. If the decomposition is not exact we provide only the seconds argument.

• "new_hms" : We build the object using hms::new_hms() on a double vector.

• "next" : Use the constructor for the next supported class. Call .class2() on the object to see in which order the methods will be tried.

• "double" : We define as an atomic vector and repair attributes.

Value

An object of class <constructive_options/constructive_options_hms>

Description

These options will be used on objects of class 'html'.

Usage

opts_html(constructor = c("HTML", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "HTML" (default): We build the object using htmltools::HTML().

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_html>

Description

These options will be used on objects of class 'html_dependency'.

Usage

opts_html_dependency(constructor = c("htmlDependency", "next"), ...)

Arguments

Details

Depending on constructor, we construct the object as follows:

• "htmlDependency" (default): We build the object using htmltools::htmlDependency(), arguments left to their default values are omitted.

• "next" : Use the constructor for the next supported class.

Value

An object of class <constructive_options/constructive_options_html_dependency>

Description

These options will be used on objects of class 'IDate'.

Usage

opts_IDate(constructor = c("as.IDate", "next", "integer"), ...)

Arguments