

### Function declarations

## 1
{
  fun <- function(argument1,
                  argument2) {
    body
  }
}

## 2
{
  function(
           argument1,
           argument2
           )
  {
    body
  }
}

## 3
function(argument_fun(sub_argument1,
  sub_argument2),
  argument) {}

## 4
function(argument1, parameter = fun_call(
  sub_argument),
  argument2) {}

## 5
function()

  function() body

## 6a
object <- function()
{
  body
}

## 6b
object <-
  function()
  {
    body
  }

## 6c
object =
  function()
  {
    body
  }

## 6d
fun_call(argument) <-
  function()
  {
    body
  }

## 7
{
  object <- function()
  {
    body
  }
}

## 8
{
  fun_call(parameter = function()
  {
    body
  })
}

## 9
{
  fun_call(parameter = function() {
    body
  })
}

## 10
fun_call(
  function() {
    stuff
  }
)

## 11
{
  fun_call1(fun_call2(argument, function() {
    stuff
  })
  )
}

## 12
{
  fun_call1(argument, fun_call2(function() {
    stuff
  })
  )
}

## 13
fun_call(object :=
           function()
           {
             body
           })

## 14
fun_call(argument,
  function(x)
    stuff
)

## 15a
`object` <- function()
{
  body
}

## 15b
"object" <- function()
{
  body
}

## 15c
'object' <- function()
{
  body
}


### Function calls

## 1
fun_call(argument1,
  argument2)

## 2
fun_call(
  argument1,
  argument2
)

## 3
fun_call(parameter = (
  stuff
),
argument)

## 4
fun_call(parameter = fun_argument(
  argument1
),
argument2)

## 5
fun_call(parameter = fun_argument(argument1,
  argument2
)
,
argument3)

## 6
`fun_call`(argument1,
  argument2)

## 6b
`:=`(argument1,
  argument2)

## 7
`fun_call`(
  argument1,
  argument2
)

## 7b
`:=`(
  argument1,
  argument2
)

## 8
fun_call(argument1
, argument2
, argument3,
  argument4, (
    stuff1
  ),
  argument5, (
    stuff2
  )
 ,
  argument6
)

## 9
fun_call(parameter =
           fun_argument(
             sub_argument
           ),
  argument
)

## 10
fun_call(parameter = fun_argument(
  sub_argument
),
argument
)

## 11
{
  fun_call1(
    fun_call2 (argument1, argument2,
      parameter = fun_call3(
        argument3,
        argument4
      ), function(x) {
        body
      },
      argument5,
      fun_call4(
        argument6
      ),
      argument7
    ), {
      stuff
    },
    argument8
  )
}

## 12
object <- fun_call(
  arg1,
  arg2
)

## 13
fun_call1(fun_call2(
  argument
))

## 14
some_function <- fun_call1(fun_call2(
  argument
))

## 15
object[, fun_call(
  argument
)]

## 16
fun_call1(argument1, fun_call2(fun_call3(
  argument2
))
)

## 17
fun_call({
  stuff1
  stuff2

  stuff3
})

## 18
fun_call(argument1 %>%
           stuff,
  argument2)

## 19
fun_call(argument,
  )

## 20
fun_call(parameter1 = ,
  parameter2 = argument)


### Blocks

## 1
{
  function()
  {
    body
  }
}

## 2
{
  fun_call({
    stuff1
  },
  {
    stuff2
  }
  )
}

## 3
fun_call({
  stuff1
}, {
  stuff2
})

## 4
fun_call(
  parameter1 = {
    stuff1
  },
  parameter2 = {
    stuff2
  }
)

## 5
fun_call(parameter1 = {
  stuff1
},
{
  stuff2
}, parameter2 = {
  stuff3
}, {
  stuff4
},
parameter3 =
  stuff5 ~
    stuff6 +
    stuff7,
argument)

## 6
fun <- fun_call({
  stuff1
}, {
  stuff2
},
{
  stuff3
}
)

## 7
fun <- fun_call({
  stuff
},
argument
)

## 8
fun_call(function(x) {
  body1
},
function(x) {
  body2
})

## 9
fun_call(
{
  stuff
}, {
  stuff
}
)

## 10
object <-
  fun_call({
    stuff
  }, {
    stuff
  })

## 11
object <-
  fun_call(     {
    body
  }
  )

## 12
fun_call1(
  fun_call2({
    stuff
  }
  )
)

## 13
{
  stuff1

  {
    stuff2
  }
}

## 14
{{
  stuff
}
}

## 15
({
  stuff
})

## 16
( {
  stuff
}
)

## 17
fun_call(argument, function(argument1,
                            argument2) {
  body
}
)

## 18
fun_call(
  argument,
  function(argument1,
           argument2) {
    body
  }
)

## 19
fun_call1(
  fun_call2(argument, function(x) {
    body
  })
)

## 20
fun_call1({
  object1 <- fun_call2(
    argument)
  object2
})

## 21
fun_call(argument,
  function() {

    stuff
  }
}

## 22
function_call()
stuff


### Bracket indexing

## 1
object[
  argument1,
  argument2
]

## 2
object[argument1,
  argument2
]

## 3
object[(
  argument1
)]

## 4
{
  object[
    fun_call(
      body
    ),
    argument[
    (
      sub_argument
    )
    ]
  ]
}

## 5
{
  object[
    argument1,
    argument2,
    by = argument3
  ][
    argument4,
    fun_call1(argument1,
      argument2)
    argument5
  ][
    argument6,
    fun_call2(
      argument1,
      argument2
    )
  ]
}


### Control flow

## 1
{
  if (condition) {
    stuff1
  } else {
    stuff2
  }
}

## 2
{
  if (condition) {
    stuff1
  }
  else {
    stuff2
  }
}

## 3
{
  if (condition)
  {
    stuff1
  } else
  {
    stuff2
  }
}

## 4
{
  if (condition)
  {
    stuff1
  }
  else
  {
    stuff2
  }
}

## 5
{
  for (sequence)
  {
    stuff
  }
}

## 6
{
  for (sequence) {
    stuff
  }
}

## 7
if (condition)
  stuff

## 8
for (sequence)
  stuff

## 9
object <-
  if (condition) {
    stuff1
  } else {
    stuff2
  }

## 10
{
  object <-
    if (condition) stuff1
  else stuff2
}

## 10
{
  object <-
    if (condition) fun_call(
      argument1,
      argument2
    )
  else stuff
}

## 11
{
  fun_call(parameter =
             if (condition)
               stuff1
    else
      stuff2
  )
}

## 12
{
  if (condition1) {
    stuff1
  }
  else if (condition2)
    stuff2
  else if (condition3) {
    stuff3
  } else if (condition4)
    stuff4
  else
    stuff5
}

## 13
fun_call(
  argument,
  parameter = if (condition1) {
    stuff1
  } else if (condition2) {
    stuff3
  } else {
    stuff2
  }
)

## 14
fun_call(
  argument,
  parameter =
    if (condition1)
      stuff1
  else if (condition2)
    stuff3
  else
    stuff2
)

## 15
object <- fun_call(argument,
  parameter = if (condition1) {
    stuff1
  } else if (condition2) {
    stuff3
  } else {
    stuff2
  }
)

## 16
object <- fun_call(argument, if (condition)
  stuff1
  else if (condition2)
    stuff2
)

## 17
while(condition)
  stuff

## 18
if (condition1)
  stuff1
else
  if (condition2) {
    stuff2
  }

## 19
object <-
  if (condition)
    fun_call()[index]
else
  stuff

## 20
funcall({
  if (test1)
    stuff1
  if (test2)
    stuff2
})

## 21
fun_call(argument,
  function() {

    if (cond) object1 <- object2
    else object3 <- object4
  })

## 22
if (cond1)
  if (cond2)
    if (cond3)
      stuff1
else if (cond4)
  stuff2
else
  if (cond5)
    stuff3
else
  stuff4
else if (cond6)
  stuff5
else
  if (cond7)
    stuff6
else
  stuff7
else if (cond8)
  stuff8
else
  if (cond9)
    stuff9
else
  stuff10

## 23
if (cond1)
  if (cond2)
    for (sequence1)
      if (cond3)
        stuff1
else
  stuff2
else if (cond4)
  for (sequence2)
    stuff3
else
  if (cond5)
    fun_call(
      argument
    )
else
  stuff5
else
  stuff6

## 24
object <- if(cond)
            stuff1
else
  stuff2

## 25
if (condition) {
  (stuff)
}

## 26
{
  if (condition1)
    stuff1
  else if (condition2) {
    stuff2
  }
  else if (condition3)
    stuff3
}

## 27
object <- if (condition) {
  stuff1
}
else {
  stuff2
}

## 28
if (condition)
  object <-
    stuff

## 29
if (condition1)
  object <-
    if (condition2)
      stuff1
else
  stuff2
else
  stuff3


### Continuation lines

## 1
stuff1 %>%
  stuff2 %>%
  stuff3

## 2
{
  stuff1 %>%
    stuff2 %>%
    stuff3
} %>%
  stuff4 %>%
  stuff5

## 3
(
  stuff1 %>%
    stuff2 %>%
    stuff3
) %>%
  stuff4 %>%
  stuff5

## 4
object[
  stuff1 %>%
    stuff2 %>%
    stuff3
] %>%
  stuff4 %>%
  stuff5

## 5
stuff1 %>%
  stuff2 %>%
  if (condition) {
    stuff3 %>%
      stuff4 %>%
      stuff5
  } else {
    stuff6 %>%
      stuff7 %>%
      stuff8
  } %>%
  stuff9 %>%
  stuff10

## 6
stuff[stuff1 %>%
        stuff2 %>%
        stuff3] %>%
  stuff4 %>%
  stuff5

## 7
ggplot() +
  geom(lhs -
         rhs
  ) +
  geom()

## 8
{
  ggplot() +
    geom1(argument1,
      argument2 = (
        stuff1
      ) -
        stuff2) +
    geom2() +
    geom3()
}

## 9
stuff +
  fun_call(parameter = argument1,
    fun_call((stuff1 - stuff2 +
                stuff3
    ) /
      stuff4)
  ) /
  stuff5

fun_call(arg1 +
           arg2, arg3 +
                   arg4)

## 10
fun_call(argument1 %>%
           stuff1, argument2 %>%
                     stuff2, {
                       stuff3 %>%
                         stuff4
                     } %>%
                       stuff5,
           argument3
)

## 11
object1 <- object2 %>%
  fun_call1() %>%
  fun_call2()

## 12
object1 <-
  object2%>%fun_call1() %>%
  fun_call2()%>%
  fun_call3()

## 13
{
  (stuff) %>%
    fun_call()

  {stuff} %>%
    fun_call()
}

## 14
{
  object + (
    stuff
  ) %>%
    fun_call()

  object + {
    stuff
  } %>%
    fun_call()
}

## 15
object <-
  stuff1 +
  stuff2 ~
    stuff3 +
    stuff4 :=
      stuff5 +
      stuff6 =
        stuff7 +
        stuff8

## 16
object <- stuff1 +
  stuff2 + stuff3 +
  stuff4 ~ stuff5 +
    stuff6 + stuff7 +
    stuff8 := stuff9 +
      stuff10 + stuff11 +
      stuff12 = stuff13 +
        stuff14 + stuff15 +
        stuff16

## 17
object %>%
  {
    stuff1
  } %>% object[index] %>% {stuff2} %>% fun_call1() +
  {if (condition1) stuff3 else stuff4} +
  if (condition2) {
    stuff5
  } else if (condition3) {
    stuff6
  } else {
    stuff7
  } %>%
  (fun_call2()) %>% fun_call3() %>%
  fun_call3()

## 18
`object`$`elem` <- stuff1 +
  stuff2
`object`@`elem` <- stuff1 +
  stuff2

## 19
{
  ## comment
  object1 <-
    object2
}

## 20
fun_call(stuff1 + stuff2 +
           stuff3 +
           (stuff4 + stuff5 +
              stuff6) +
           object[stuff7 +
                    stuff8] +
           {stuff9 +
              stuff10})


## 21
object %>% fun_call({
  stuff1
}) %>%
  stuff2

## 22
"string1" %>%
  'string2' %>%
  `stuff1` %>%
  stuff2

## 23
object[index] %>%
  fun_call1(
    argument1
  )[index2] %>%
  fun_call2(
    argument2
  )[[index3]] %>%
  stuff

## 24
fun_call(argument) <-
  hop

## 25
fun_call1(argument, fun_call2(
  stuff1
) +
  stuff2)

## 26
object <-
  {
    stuff1
  } %>%
  (
    stuff2
  )

## 27
fun_call1(fun_call2(fun_call3(
  argument
))) %>%
  fun_call2()

## 28
fun_call(argument1 %>%
           stuff,
  argument2)

## 29
fun_call(stuff1 :=
           (stuff2),
  argument)

## 30
fun_call1(fun_call2(
  fun_call3()) %>%
    stuff)

## 31
fun_call(object1 + object2 ~ object3 +
           object4 + object5 := object6 +
             object7,
           argument)

## 32
fun_call(object ~
           )

## 33
fun_call(object +
           )

## 34
fun_call(object[index1]$element[index2][index3]@attribute +
           stuff)

## 35a
fun_call(argument <-
           object)

## 35b
fun_call(argument <<-
           object)

## 36
funcall(!stuff1 ||
          stuff2)

## 37 (issue #857)
fun_call({

  stuff <-
    namespace:::fun_call() %>%
    fun_call()

  stuff
})

fun_call({
  stuff <-
    namespace::fun_call() %>%
    fun_call()
  stuff
})

## 38a (issue #412)

namespace::fun_call() %>%
  namespace::fun_call() %>%
  namespace::fun_call() %>%
  namespace::fun_Call()

## 38b

namespace:::fun_call() %>%
  namespace:::fun_call() %>%
  namespace:::fun_call() %>%
  namespace:::fun_Call()

## 38c

object@fun_call() %>%
  object@fun_call() %>%
  object@fun_call() %>%
  object@fun_Call()

## 38d

object$fun_call() %>%
  object$fun_call() %>%
  object$fun_call() %>%
  object$fun_Call()


## 39
x |>
  f1() |>
  f2() |>
  f3()

## 40
\(x) x +
       2


### Comments

## 1
# Side comment

## 2
{
  ## Hanging comment 1
  fun_call(
  {
    ## Hanging comment 2
  }
  )
}

## 3
{
  ### Section comment
}

## 4
fun_call(
  ## Comment
  argument
)

## 5
object %>%
  ## comment,
  ## comment
  stuff

## 6a
object <-
  function()
  {
    stuff
    ## comment
  }

## 6b
object <-
  function()
  {
    ## comment
  }

## 7
{
  fun_call(lhs +
             ### Comment
             rhs
  )
}

## 8
"#" + # comment
  NULL

## 9
"* #"
x


### Logical operators

## 1
stuff1 &&
  stuff2 ||
  stuff3

## 2
(stuff1 &&
   stuff2 ||
   stuff3)

## 3
if (condition1 &&
      condition2 ||
      (condition3 && condition4) ||
      (condition5 &&
         condition6 &&
         condition7) ||
      condition8) {
  stuff
} && condition8 ||
  condition9 ||
  condition10

## 4
stuff1 == stuff2 ||
  condition

## 5
(stuff1 == stuff2 ||
   condition
)

## 6
(stuff1 != stuff2 ||
   condition
)

## 7
object <-
  condition1 | condition2 |
  condition3 | condition4

## 8
if (condition1 || object1 %op% object2 ||
      condition3) {
  stuff
}

## 9
any(condition1 |
      condition2) &&
  all(condition3 &
        condition4)


### Specific situations and overrides

## 10
fun_call(
  ifelse(condition1, argument1,
    ifelse(condition2, argument2,
      ifelse))
)

## 11
1:10 |>
  x => 2 ** x %>%
  sum()
