README.Rmd

---
output: github_document
---

<!-- README.md is generated from README.Rmd. Please edit that file -->

```{r, include = FALSE}
knitr::opts_chunk$set(
  collapse = TRUE,
  comment = "#>",
  fig.path = "man/figures/README-",
  out.width = "100%"
)
library(baizer)
library(badger)
library(patchwork)
library(ComplexHeatmap)
```

# baizer <img src="man/figures/logo.png" align="right" />

<!-- badges: start -->
[![Codecov test coverage](https://codecov.io/gh/william-swl/baizer/branch/master/graph/badge.svg)](https://app.codecov.io/gh/william-swl/baizer?branch=master)
[![R-CMD-check](https://github.com/william-swl/baizer/actions/workflows/check-standard.yaml/badge.svg)](https://github.com/william-swl/baizer/actions/workflows/check-standard.yaml)
`r badge_cran_release("baizer", "orange")`
`r badge_devel("william-swl/baizer", "blue")`
`r badge_cran_download("baizer", "grand-total", "blue")`
`r badge_cran_download("baizer", "last-month", "green")`
<!-- badges: end -->

- In ancient Chinese mythology, Bai Ze is a divine creature that knows the needs of everything.
- `baizer` provides data processing functions frequently used by the author.
- Hope this package also knows what you want!

## installation

### universal installation

You can install the stable version of `baizer` like so:

``` r
install.packages("baizer")
```

Or install the development version of `baizer` like so:

``` r
devtools::install_github("william-swl/baizer")
```

### specific installation

If you prefer `Macports` on MacOS:

```sh
sudo port install R-baizer
```



## basic utils
- load packages as a batch
```{r basic-utils-pkglib}
pkglib(dplyr, purrr)
```

- versions of packages
```{r basic-utils-pkgver}
pkgver(dplyr, purrr)

# case-insensitive input
pkgver(DplyR)
```

- information of packages
```{r basic-utils-pkginfo}
# pkginfo(dplyr)

# case-insensitive input
# pkginfo(DplyR)
```


- use `%nin%` to get 'not in' logical value
```{r basic-utils-nin}
1 %nin% c(1, 2, 3)

1 %nin% c(2, 3)
```

- use `%neq%` to get `NA` supported 'not equal' logical value
```{r basic-utils-neq}
NA != 0

NA != NA

NA %neq% 0

NA %neq% NA
```

- not NA/NULL
```{r basic-utils-not}
not.na(NA)

not.null(NULL)
```


- dump a vector into string
```{r basic-utils-collapse_vector}
collapse_vector(c("A" = 2, "B" = 3, "C" = 4), front_name = TRUE, collapse = ";")

collapse_vector(c("A" = 2, "B" = 3, "C" = 4), front_name = FALSE, collapse = ",")
```


- slice character vector
```{r basic-utils-slice_char}
x <- c("A", "B", "C", "D", "E")
slice_char(x, "A", "D")
slice_char(x, "D", "A")

x <- c("A", "B", "C", "C", "A", "D", "D", "E", "A")
slice_char(x, "B", "E")
# duplicated element as boundary will throw an error
# slice_char(x, 'A', 'E')
# unique=TRUE to remove the duplicated boundary characters
slice_char(x, "A", "E", unique = TRUE)
```


- the index of different character
```{r basic-utils-diff_index}
diff_index("AAAA", "ABBA")

# ignore case
diff_index("AAAA", "abba", ignore_case = TRUE)

# only the index of nth different character, NA if unaccessible
diff_index("AAAA", "ABBA", nth = 2)

diff_index("AAAA", "ABBA", 10)

# second and third indices
diff_index("AAAA", "ABBB", nth = 2:3)

# support vectorized operations
diff_index(c("ABBA", "AABB"), "AAAA")
```

- the index of same character
```{r basic-utils-same_index}
# just like diff_index
same_index(c("ABBA", "AABB"), "AAAA")
```


- fetch character from strings
```{r basic-utils-fetch_char}
fetch_char(rep("ABC", 3), list(1, 2, 3))

# accept the output of `diff_index` or `same_index`
str1 <- c("ABCD", "AAEF")
str2 <- c("AAAA", "AAAA")
fetch_char(str1, diff_index(str1, str2))

# if the output of `diff_index` have NA, also return NA
fetch_char(str1, diff_index(str1, str2, nth = 1:3), na.rm = FALSE)

# remove NA
fetch_char(str1, diff_index(str1, str2, nth = 1:5), na.rm = TRUE)

# collapse the characters from a same string
fetch_char(str1, diff_index(str1, str2, nth = 1:5), na.rm = TRUE, collapse = ",")
```

- trans fixed string into regular expression string
```{r basic-utils-fix_to_regex}
fix_to_regex("ABC|?(*)")
```

- detect possible duplication in a vector, ignore case, blank and special character
```{r basic-utils-detect_dup}
detect_dup(c("a", "B", "C_", "c -", "#A"))
```

- extract key and values for a character vector
```{r basic-utils-extract_kv}
extract_kv(c("x: 1", "y: 2"))
```

- farthest point sampling (FPS) for a vector
```{r basic-utils-fps_vector}
fps_vector(1:10, 2)

fps_vector(1:10, 4)

fps_vector(c(1, 2, NULL), 2)

fps_vector(c(1, 2, NA), 2)
```


- regex match
```{r basic-utils-reg_match}
v <- stringr::str_c("id", 1:3, c("A", "B", "C"))
v

# return first group as default
reg_match(v, "id(\\d+)(\\w)")

reg_match(v, "id(\\d+)(\\w)", group = 2)

# when group=-1, return full matched tibble
reg_match(v, "id(\\d+)(\\w)", group = -1)
```

- join the matched parts into string
```{r basic-utils-reg_join}
reg_join(c("A_12.B", "C_3.23:2"), "[A-Za-z]+")

reg_join(c("A_12.B", "C_3.23:2"), "\\w+")

reg_join(c("A_12.B", "C_3.23:2"), "\\d+", sep = ",")

reg_join(c("A_12.B", "C_3.23:2"), "\\d", sep = ",")
```



- split vector into list
```{r basic-utils-split_vector}
split_vector(1:10, c(3, 7))


vec <- stringr::str_split("ABCDEFGHIJ", "") %>% unlist()
vec

split_vector(vec, breaks = c(3, 7), bounds = "[)")
```

- group character vector by a regex pattern
```{r basic-utils-group_vector}
v <- c(
  stringr::str_c("A", c(1, 2, 9, 10, 11, 12, 99, 101, 102)),
  stringr::str_c("B", c(1, 2, 9, 10, 21, 32, 99, 101, 102))
) %>% sample()
v

group_vector(v)

group_vector(v, pattern = "\\w\\d")

# the pattern rules are just same as reg_match()
group_vector(v, pattern = "\\w(\\d)")

# unmatched part will alse be stored
group_vector(v, pattern = "\\d{2}")
```


- sort by a function
```{r basic-utils-sortf}
sortf(c(-2, 1, 3), abs)

v <- stringr::str_c("id", c(1, 2, 9, 10, 11, 12, 99, 101, 102)) %>% sample()
v

sortf(v, function(x) reg_match(x, "\\d+") %>% as.double())

# you can also use purrr functions
sortf(v, ~ reg_match(.x, "\\d+") %>% as.double())


# group before sort
v <- c(
  stringr::str_c("A", c(1, 2, 9, 10, 11, 12, 99, 101, 102)),
  stringr::str_c("B", c(1, 2, 9, 10, 21, 32, 99, 101, 102))
) %>% sample()
v

sortf(v, ~ reg_match(.x, "\\d+") %>% as.double(), group_pattern = "\\w")
```

- pileup another logical vector on the TRUE values of first vector
```{r basic-utils-pileup_logical}
# first vector have 2 TRUE value
v1 <- c(TRUE, FALSE, TRUE)

# the length of second vector should also be 2
v2 <- c(FALSE, TRUE)

pileup_logical(v1, v2)
```

- only keep unique vector values and its names

```{r basic-utils-uniq}
v <- c(a = 1, b = 2, c = 3, b = 2, a = 1)

# unique will lost the names
unique(v)

# uniq can keep them
uniq(v)
```

- replace the items of one object by another
```{r basic-utils-replace_item}
x <- list(A = 1, B = 3)
y <- list(A = 9, C = 10)

replace_item(x, y)

replace_item(x, y, keep_extra = TRUE)

x <- list(a = 1, b = list(c = "a", d = FALSE, f = list(x = 0, z = 30)))
y <- list(a = 3, e = 2, b = list(d = TRUE, f = list(x = 10, y = 20)))

replace_item(x, y, keep_extra = TRUE)
```

- generate characters
```{r basic-utils-gen_char}
gen_char(from = "g", n = 5)

gen_char(to = "g", n = 5)

gen_char(from = "g", to = "j")

gen_char(from = "t", n = 5, random = TRUE)

gen_char(from = "x", n = 5, random = TRUE, allow_dup = FALSE, add = c("+", "-"))
```

- trans range character into seq characters
```{r basic-utils-rng2seq}
rng2seq(c("1-5", "2"))
```

- return top n items with highest frequency
```{r basic-utils-top_item}
top_item(c("a", "b", "c", "b"))

top_item(c(1, 2, 3, 2, 2))
```

- melt a vector into single value
```{r basic-utils-melt_vector}
melt_vector(c(NA, 2, 3), method = "first")

melt_vector(c(NA, 2, 3), method = "sum")

melt_vector(c(NA, 2, 3), method = ",")

melt_vector(c(NA, 2, Inf), invalid = c(NA, Inf))
```

- combine multiple vectors into one
```{r basic-utils-combn_vector}
x1 <- c(1, 2, NA, NA)
x2 <- c(3, NA, 2, NA)
x3 <- c(4, NA, NA, 3)

combn_vector(x1, x2, x3, method = "sum")
```


- broadcast the vector into length n

```{r basic-utils-broadcast_vector}
broadcast_vector(1:3, 5)
```

- replace specific characters in a string by their locations

```{r basic-utils-str_replace_loc}
str_replace_loc("abcde", 1, 3, "A")
```

- swap the names and values of a vector

```{r basic-utils-swap_vecname}
v <- c("a" = "A", "b" = "B", "c" = "C")
swap_vecname(v)
```


## numbers

- from float number to fixed digits character
```{r numbers-round_signif}
round(2.1951, 2)

round_string(2.1951, 2)

signif(2.1951, 3)

signif_string(2.1951, 3)
```

- signif or round string depend on the character length
```{r numbers-signif_round_string}
signif_round_string(20.526, 2, "short")
signif_round_string(20.526, 2, "long")

# if you want keep the very small value
signif_round_string(0.000002654, 3, full_small = TRUE)
```

- signif while use floor/ceiling
```{r numbers-signif_floor}
signif_floor(3.19, 2)

signif_ceiling(3.11, 2)
```


- whether the number string only has zero
```{r numbers-iszero}
is.zero("0.000")

is.zero("0.0001")
```


- float and percent trans
```{r numbers-float_percent}
float_to_percent(0.123, digits = 1)

percent_to_float("123%", digits = 3)

percent_to_float("123%", digits = 3, to_double = TRUE)
```

- wrapper of the functions to process number string with prefix and suffix
```{r numbers-number_fun_wrapper}
number_fun_wrapper(">=2.134%", function(x) round(x, 2))
```

- expand a number vector according to the adjacent two numbers
```{r numbers-adjacent_div}
adjacent_div(10^c(1:3), n_div = 10)

# only keep the unique numbers
adjacent_div(10^c(1:3), n_div = 10, .unique = TRUE)
```

- correct the numbers to a target ratio
```{r numbers-correct_ratio}
correct_ratio(c(10, 10), c(3, 5))

# support ratio as a float
correct_ratio(c(100, 100), c(0.2, 0.8))

# more numbers
correct_ratio(10:13, c(2, 3, 4, 6))

# with digits after decimal point
correct_ratio(c(10, 10), c(1, 4), digits = 1)
```

- the ticks near a number
```{r numbers-near_ticks}
near_ticks(3462, level = 10)
```

- the nearest ticks around a number
```{r numbers-nearest_tick}
nearest_tick(3462, level = 10)
```

- generate ticks for a number vector

```{r numbers-generate_ticks}
generate_ticks(c(176, 198, 264))
```

- split a positive integer number as a number vector
```{r numbers-pos_int_split}
pos_int_split(12, 3, method = "average")

pos_int_split(12, 3, method = "random")

# you can also assign the ratio of output
pos_int_split(12, 3, method = c(1, 2, 3))
```

- generate outliers from a series of number
```{r numbers-gen_outlier}
x <- seq(0, 100, 1)

gen_outlier(x, 10)

# generation limits
gen_outlier(x, 10, lim = c(-80, 160))

# assign the low and high outliers
gen_outlier(x, 10, lim = c(-80, 160), assign_n = c(0.1, 0.9))

# just generate low outliers
gen_outlier(x, 10, side = "low")

# return with raw vector
gen_outlier(x, 10, only_out = FALSE)
```

- max-min normalization
```{r numbers-mm_norm}
mm_norm(c(1, 3, 4))
```


## dataframe
- a minimal dataset
```{r dataframe-mini_diamond}
head(mini_diamond)
```

- shortcut of `dplyr::column_to_rownames` and `dplyr::rownames_to_column`
```{r dataframe-cr}
head(mini_diamond) %>% c2r("id")

# use column index
head(mini_diamond) %>% c2r(1)

head(mini_diamond) %>%
  c2r("id") %>%
  r2c("id")
```

- fancy count to show an extended column
```{r dataframe-fancy_count}

# count one column
fancy_count(mini_diamond, cut)

# count an extended column
fancy_count(mini_diamond, cut, ext = clarity)

# change format
fancy_count(mini_diamond, cut, ext = clarity, ext_fmt = "ratio")

fancy_count(mini_diamond, cut, ext = clarity, ext_fmt = "clean")

# count an extended column, in an order by n
fancy_count(mini_diamond, cut, ext = clarity, sort = TRUE)

# extended column after a two-column count
fancy_count(mini_diamond, cut, clarity, ext = id) %>% head(5)
```

- count two columns as a cross-tabulation table
```{r dataframe-cross_count}
cross_count(mini_diamond, cut, clarity)

# show the ratio in the row
cross_count(mini_diamond, cut, clarity, method = "rowr")

# show the ratio in the col
cross_count(mini_diamond, cut, clarity, method = "colr")
```

- split a column and return a longer tibble
```{r dataframe-split_column}
df <- fancy_count(mini_diamond, cut, ext = clarity)
head(df)

split_column(df, name_col = cut, value_col = clarity)
```

- move selected rows to target location
```{r dataframe-rearrange_row}
# move row 3-5 after row 8
move_row(mini_diamond, 3:5, .after = 8)

# move row 3-5 before the first row
move_row(mini_diamond, 3:5, .before = TRUE)

# move row 3-5 after the last row
move_row(mini_diamond, 3:5, .after = TRUE)
```


- slice a tibble by an ordered vector
```{r dataframe-ordered_slice}
ordered_slice(mini_diamond, id, c("id-3", "id-2"))

# support NA and known values in ordered vector
ordered_slice(mini_diamond, id, c("id-3", "id-2", "unknown_id", "id-3", NA))

# remove NA
ordered_slice(mini_diamond, id, c("id-3", "id-2", "unknown_id", "id-3", NA),
  na.rm = TRUE
)

# remove duplication
ordered_slice(mini_diamond, id, c("id-3", "id-2", "unknown_id", "id-3", NA),
  dup.rm = TRUE
)
```

- remove columns by the ratio of `NA`, default to remove the columns only have `NA`
```{r dataframe-remove_nacol}
df_with_nacol <- dplyr::bind_cols(
  mini_diamond,
  tibble::tibble(na1 = NA, na2 = NA)
)
df_with_nacol

remove_nacol(df_with_nacol)

# only keep the columns that have less than 20% NA values
# remove_nacol(df_with_nacol, max_ratio=0.2)
```

- remove rows by the ratio of NA
```{r dataframe-remove_narow}
# remove_narow(df)
```

- remove columns by the ratio of an identical single value (NA supported)

```{r dataframe-remove_monocol}
df_with_monocol <- tibble::tibble(
  x = c(1, 1, 1, 2),
  y = c(1, 1, 2, 2),
  z = c(1, 1, 1, 1),
  x1 = c(1, 1, 1, NA),
  y1 = c(1, 1, NA, NA),
  z1 = c(NA, NA, NA, NA),
  x2 = c(NA, NA, NA, 1),
  y2 = c(NA, NA, 1, 1)
)

df_with_monocol

remove_monocol(df_with_monocol)

# only keep the columns that have less than 60% identical values
remove_monocol(df_with_monocol, max_ratio = 0.6)
```


- separate numeric vector into bins
```{r dataframe-hist_bins}
vector <- dplyr::pull(mini_diamond, price, id)

hist_bins(vector)

# set the max and min limits
hist_bins(vector, bins = 20, lim = c(0, 20000))

# or pass breaks directly
hist_bins(vector, breaks = seq(0, 20000, length.out = 11))
```

- trans a table in markdown format into tibble

``` {r dataframe-as_tibble_md}
x <- "
  | col1 | col2 | col3 |
  | ---- | ---- | ---- |
  | v1   | v2   | v3   |
  | r1   | r2   | r3   |
  "

as_tibble_md(x)
```

- trans a tibble into markdown format table

```{r dataframe-as_md_table}
mini_diamond %>%
  head(5) %>%
  as_md_table()
```


- relevel a target column by another reference column

```{r dataframe-ref_level}
cut_level <- mini_diamond %>%
  pull(cut) %>%
  unique()
df <- mini_diamond %>%
  dplyr::mutate(cut = factor(cut, cut_level)) %>%
  dplyr::mutate(cut0 = stringr::str_c(cut, "xxx"))

levels(df$cut)

levels(df$cut0)

# after relevel
df <- ref_level(df, cut0, cut)

levels(df$cut)

levels(df$cut0)
```

- trans list into tibble
```{r dataframe-list2df}
x <- list(
  c("a", "1"),
  c("b", "2"),
  c("c", "3")
)

list2df(x, colnames = c("char", "num"))


x <- list(
  c("a", "b", "c"),
  c("1", "2", "3")
)

list2df(x, method = "col")
```

- generate a matrix to show whether the item in each element of a list
```{r dataframe-exist_matrix}
x <- 1:5 %>% map(~ gen_char(to = "k", n = 5, random = TRUE, seed = .x))

x

exist_matrix(x)
```

- dataframe rows seriation, which will reorder the rows in a better pattern.
Sometimes clearer than `hclust`

```{r dataframe-seriate_df1, include=FALSE, warning=FALSE}
# create demo dataframe
df <- mini_diamond %>%
  select(id, where(is.numeric)) %>%
  mutate(across(where(is.numeric), ~ round(.x / max(.x), 4))) %>%
  c2r("id")

# p1
p1 <- Heatmap(df,
  cluster_rows = FALSE, cluster_columns = FALSE,
  column_title = "Raw dataframe",
  show_row_names = FALSE, show_heatmap_legend = FALSE
)

# p2
cls <- df %>%
  dist() %>%
  hclust()
df_cls <- df[cls$order, ]
p2 <- Heatmap(df_cls,
  cluster_rows = FALSE, cluster_columns = FALSE,
  column_title = "Hclusted dataframe",
  show_row_names = FALSE, show_heatmap_legend = FALSE
)

# p3
p3 <- Heatmap(seriate_df(df),
  cluster_rows = FALSE, cluster_columns = FALSE,
  column_title = "Seriated dataframe",
  show_row_names = FALSE, show_heatmap_legend = FALSE
)
```

```{r dataframe-seriate_df2}
seriated_df <- seriate_df(df)
```

```{r dataframe-seriate_df3, echo=FALSE, warning=FALSE}
p1 + p2 + p3
```

- diagnosis a tibble for character NA, NULL, all T/F column, blank in cell
```{r dataframe-dx_tb}
x <- tibble(
  c1 = c("NA", NA, "a", "b"),
  c2 = c("c", "d", "e", "NULL"),
  c3 = c("T", "F", "F", "T"),
  c4 = c("T", "F", "F", NA),
  c5 = c("", " ", "\t", "\n")
)
x

dx_tb(x)
```

- generate tibbles
```{r dataframe-gen_tb}
gen_tb()

gen_tb(fill = "str", nrow = 3, ncol = 4, len = 3)
```

- differences between two tibbles
```{r dataframe-diff_tb}
tb1 <- gen_tb(fill = "int", seed = 1)
tb1

tb2 <- gen_tb(fill = "int", seed = 3)
tb2

diff_tb(tb1, tb2)
```

- transpose a dataframe
```{r dataframe-tdf}
tdf(c2r(head(mini_diamond), "id"))
```

- count unique values in each column
```{r dataframe-uniq_in_cols}
uniq_in_cols(mini_diamond)
```

- like `left_join(), full_join(), inner_join()` while ignore the same columns in right tibble
```{r dataframe-expand}
tb1 <- head(mini_diamond, 4)
tb2 <- tibble(
  id = c("id-2", "id-4", "id-5"),
  carat = 1:3,
  price = c(1000, 2000, 3000),
  newcol = c("new2", "new4", "new5")
)

left_expand(tb1, tb2, by = "id")

inner_expand(tb1, tb2, by = "id")
```

- rewrite the NA values in a tibble by another tibble

```{r dataframe-replace_na}
tb1 <- tibble(
  id = c("id-1", "id-2", "id-3", "id-4"),
  group = c("a", "b", "a", "b"),
  price = c(0, -200, 3000, NA),
  type = c("large", "none", "small", "none")
)

tb2 <- tibble(
  id = c("id-1", "id-2", "id-3", "id-4"),
  group = c("a", "b", "a", "b"),
  price = c(1, 2, 3, 4),
  type = c("l", "x", "x", "m")
)

rewrite_na(tb1, tb2, by = c("id", "group"))
```

- remove outliers and NA

```{r dataframe-remove_outliers}
out <- tibble(
  id = stringr::str_c("out-", 1:20),
  price = gen_outlier(mini_diamond %>% dplyr::pull(price), n = 20)
)

dim(bind_rows(mini_diamond, out))

res <- bind_rows(mini_diamond, out) %>%
  remove_outliers(price)

dim(res)
```



## stat
- generate all combinations
```{r stat-gen_combn}
gen_combn(1:4, n = 2)
```

- statistical test which returns a extensible tibble
```{r stat-stat_test}
stat_test(mini_diamond, y = price, x = cut, .by = clarity)
```

- fold change calculation which returns a extensible tibble
```{r stat-stat_fc}
stat_fc(mini_diamond, y = price, x = cut, .by = clarity)
```

- calculate phi coefficient of two binary variables
```{r stat-stat_phi}
data <- matrix(c(10, 8, 14, 18), nrow = 2)
stat_phi(data)
```



## IO
- get the command line arguments
```{r IO-cmdargs}
cmdargs()

cmdargs("R_env")
```

- detect whether directory is empty recursively, and detect 
whether file is empty recursively
```{r empty}
# create an empty directory
dir.create("some/deep/path/in/a/folder", recursive = TRUE)
empty_dir("some/deep/path/in/a/folder")

# create an empty file
file.create("some/deep/path/in/a/folder/there_is_a_file.txt")
empty_dir("some/deep/path/in/a/folder")
empty_file("some/deep/path/in/a/folder/there_is_a_file.txt", strict = TRUE)

# create a file with only character of length 0
write("", "some/deep/path/in/a/folder/there_is_a_file.txt")
empty_file("some/deep/path/in/a/folder/there_is_a_file.txt", strict = TRUE)
empty_file("some/deep/path/in/a/folder/there_is_a_file.txt")

# clean
unlink("some", recursive = TRUE)
```

- read excel file
```{r IO-read_excel}
# read_excel("mini_diamond.xlsx")
```

- write a tibble, or a list of tibbles into an excel file
```{r IO-write_excel}
# write_excel(mini_diamond, "mini_diamond.xlsx")

# Ldf <- list(mini_diamond[1:3, ], mini_diamond[4:6, ])
# write_excel(Ldf, '2sheets.xlsx')
```

- read multi-sheet excel file as a list of tibbles
```{r IO-read_excel_list}
# read_excel_list("mini_diamond.xlsx")
```


- read front matter markdown
```{r IO-read_fmmd}
# read_fmmd("markdown_file.md")
```

- fetch remote files via sftp
```{r IO-sftp_download}
# sftp_con <- sftp_connect(server='remote_host', port=22,
#                         user='username', password = "password", wd='~')
#
# sftp_download(sftp_con,
#    path=c('t1.txt', 't2.txt'),
#    to=c('path1.txt', 'path2.txt')
# )
```

- list files from remote server via sftp
```{r IO-sftp_ls}
# sftp_ls(sftp_con, 'your/dir')
```


## S3 classes in `baizer`
### tbflt
- save a series of filter conditions, and support 
logical operation among conditions
- use `filterC` to apply `tbflt` on `dplyr::filter`

``` {r tbflt}
c1 <- tbflt(cut == "Fair")
c2 <- tbflt(x > 8)
c1 | c2

mini_diamond %>%
  filterC(c1) %>%
  head(5)

mini_diamond %>%
  filterC(!c1) %>%
  head(5)

mini_diamond %>% filterC(c1 & c2)
```

- stricter limitation to avoid the unexpected default behavior
```{r tbflt-uscol}
# default behavior of dplyr::filter, use column in data at first
x <- 8
mini_diamond %>% dplyr::filter(y > x)

# so the default behavior of filterC is just like that
# but if you want y > 8, and the defination of cond is far away from
# its application, the results may be unexpected

x <- 8
cond <- tbflt(y > x)
mini_diamond %>% filterC(cond)

cond <- tbflt(y > 8)
mini_diamond %>% filterC(cond)


# to avoid this, set usecol=FALSE. An error will be raised for warning you
# to change the variable name
# mini_diamond %>% filterC(cond, usecol=FALSE)


# you can always ignore this argument if you know how to use .env or !!
x <- 8
cond1 <- tbflt(y > !!x)
mini_diamond %>% filterC(cond1)

cond2 <- tbflt(y > .env$x)
mini_diamond %>% filterC(cond1)
```




## dev

- add `#'` into each line of codes for roxygen examples
```{r dev-roxygen_fmt}
roxygen_fmt(
  "
code line1
code line2
"
)
```

- use aliases for function arguments
```{r dev-alias_arg}
# set y, z as aliases of x when create a function
func <- function(x = 1, y = NULL, z = NULL) {
  x <- alias_arg(x, y, z, default = x)
  return(x)
}

func()

func(x = 8)

func(z = 10)
```

- check arguments by custom function

```{r dev-check_arg}
x <- 1
y <- 3
z <- NULL

func <- function(x = NULL, y = NULL, z = NULL) {
  if (check_arg(x, y, z, n = 2)) {
    print("As expected, two arguments is not NULL")
  }

  if (check_arg(x, y, z, n = 1, method = ~ .x < 2)) {
    print("As expected, one argument less than 2")
  }
}
```


## Code of Conduct
Please note that the baizer project is released with a [Contributor Code of Conduct](https://contributor-covenant.org/version/2/1/CODE_OF_CONDUCT.html). 
By contributing to this project, you agree to abide by its terms.