Using fun1 and fun2 from the question we can define both which sequentially runs them. We also test it.

both <- function(...) {
  fun1(...)
  fun2(...)
}

# test
both(1, 2)
## [1] 2
## [1] 3

Or if you wanted to return their outputs:

both2 <- function(...) list(fun1(...), fun2(...))

Alternately, we can define a factory function which given two functions having the same arguments creates a function which runs them in sequence.

Combine <- function(FUN1, FUN2) {
  function(...) { FUN1(...); FUN2(...) }
}

# test 
mewfun <- Combine(fun1, fun2)
newfun(1, 2)
## [1] 2
## [1] 3

or if you wnated to return their outputs

Combine2 <- function(FUN1, FUN2) {
  function(...) list(FUN1(...), FUN2(...))
}

For future reference you perhaps could have supplied some example data in order to showcase the problem. As i read your question, you're looking for a way to compose two functions (i.e. h(x) = g(f(x)). This can be done as follows:

myDat <- function(filename) {
  dat <- readModels(filename, what = "parameters")$parameters  
  dat <- filter(as.data.frame(dat$unstandardized), 
                grepl("BY|Intercepts", paramHeader))
  return(dat)
}

loading <- function(data) {
  data %>% 
    filter(grepl("BY", paramHeader)) %>% 
    select(c(param, est)) %>% 
    separate(param, c("loading","time")) %>%
    mutate(time = paste0('time',time)) %>% 
    spread(loading, est)
}

combined <- purrr::compose(loading, myDat)

^{Created on 2020-01-27 by the reprex package (v0.3.0)}

Something like this should work:

osuustesti <- function(x1, x2, n1, n2, alpha = 0.05) {
    numer <- x1 / n1 - x2 / n2 
    denum <- sqrt((1 / n1 + 1 / n2) * 
                  ((x1 + x2) / ( n1 + n2)) * 
                  (1 - ( x1 + x2) / (n1 + n2)))
    result <- numer / denum

    if (result > qnorm(alpha / 2, lower.tail = FALSE)) {
        cat("Nollahypoteesi hylätään\n")
    } else {
        cat("Nollahypoteesi hyväksytään\n")
    }
    return(result)
}

I save result to result object, then compare it to alpha, cat the string and in the end use return() to return result from the function.

Do you mean this ?

fun_1 <- function(x){
  x ^ 2
}

fun_2 <- function(x){
  x + 1
}

fun_3 <- function(x){
  fun_1(x) + fun_2(x)
}

fun_3(1)

returns 3

k <- NA
fun <- function(w){
  for (i in 1:100){
  k[i] <- (-i/100)^2 + exp(w)
  }
  sum(k)
}
fun(1)

returns 305.6632

dplyr

You can use across with cur_column() and cur_data() to get what you need.

Data:

set.seed(42)
quux <- data.frame(var1=sample(5), var2=sample(5), var3=sample(5), var1a=11L, var2a=22L, var3a=31L)
quux
#   var1 var2 var3 var1a var2a var3a
# 1    1    4    4    11    22    31
# 2    5    2    1    11    22    31
# 3    4    5    5    11    22    31
# 4    3    1    2    11    22    31
# 5    2    3    3    11    22    31

And using across:

library(dplyr)
quux %>%
  mutate(across(matches("^var[0-9]+$"), ~ if_else(. == 4, cur_data()[[ paste0(cur_column(), "a") ]], .)))
#   var1 var2 var3 var1a var2a var3a
# 1    1   22   31    11    22    31
# 2    5    2    1    11    22    31
# 3   11    5    5    11    22    31
# 4    3    1    2    11    22    31
# 5    2    3    3    11    22    31

base R

qvars <- grep("^var[0-9]+$", names(quux), value = TRUE)
qvarsa <- paste0(qvars, "a")
quux[qvars] <- Map(function(a, b) ifelse(a == 4, b, a), quux[qvars], quux[qvarsa])
quux
#   var1 var2 var3 var1a var2a var3a
# 1    1   22   31    11    22    31
# 2    5    2    1    11    22    31
# 3   11    5    5    11    22    31
# 4    3    1    2    11    22    31
# 5    2    3    3    11    22    31

It is not entirely clear to me what you are looking for. The following function returns all records where the breakover = req_breakover and section_eur is within tolerance of req_eur. Hopefully this is sufficient for you to figure out the remaining steps.

match <- function(df, req_breakover, req_eur, tolerance) {
  lower_bound = req_eur * (1 - tolerance)
  upper_bound = req_eur * (1 + tolerance)

  find_id <- df %>%
    filter(breakover == req_breakover) %>%
    select(id)

  all_case <- df %>%
    inner_join(find_id, by = "id")

  all_case <- all_case %>%
    filter(section_eur > lower_bound ,
           section_eur < upper_bound )%>%
    select(id, well_eur, section_eur, incr_eur)

  return(all_case)
}

You would call the function as follows:

output = match(model, 5, 65000, 0.15)

A more compact function would look like:

match <- function(df, req_breakover, req_eur, tolerance) {
  output <- df %>%
    filter(breakover == req_breakover
           section_eur > req_eur * (1 - tolerance),
           section_eur < req_eur * (1 + tolerance))%>%
    select(id, well_eur, section_eur, incr_eur)

Note that the return command is unnecessary. I have included it for clarity.

Yes, I would say yes. foreach's .combine=arguments takes the function given for it to apply on the results the combination.