Function definition in R Programming - Step-by-Step Execution

Concept Flow - Function definition

Start

↓

Define function with name and parameters

↓

Function body: code inside function

↓

Function ready to use

↓

Call function with arguments

↓

Execute function body with arguments

↓

Return result

↓

End

This flow shows how you define a function, then call it to run its code and get a result.

Execution Sample

R Programming

add <- function(x, y) {
  sum <- x + y
  return(sum)
}

result <- add(3, 5)
print(result)

Defines a function 'add' that adds two numbers and returns the sum, then calls it with 3 and 5.

Execution Table

Step	Action	Evaluation	Result
1	Define function 'add' with parameters x and y	Function stored in 'add'	Function ready
2	Call add(3, 5)	Parameters x=3, y=5	Function starts
3	Calculate sum = x + y	sum = 3 + 5	sum = 8
4	Return sum	return 8	Function returns 8
5	Assign result = 8	result = 8	Variable 'result' set
6	Print result	print(8)	8 printed to console

💡 Function completes after returning the sum and printing the result.

Variable Tracker

Variable	Start	After Call	Final
x	undefined	3	undefined
y	undefined	5	undefined
sum	undefined	8	undefined
result	undefined	undefined	8

Key Moments - 3 Insights

Why do we need to define parameters (x, y) in the function?

Parameters x and y are placeholders for values you give when calling the function, as shown in step 2 of the execution_table.

What happens if we forget to use 'return' inside the function?

Without 'return', the function returns the last evaluated expression by default, but explicitly using 'return' (step 4) makes it clear what value is sent back.

Why do we assign the function call to 'result'?

Assigning the function call to 'result' (step 5) saves the output so we can use or print it later, as shown in step 6.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'sum' after step 3?

A 3

B 8

C 5

D undefined

💡 Hint

Check the 'Result' column in row 3 of the execution_table.

At which step does the function return its result?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look for the 'Return sum' action in the execution_table.

If we call add(10, 20) instead of add(3, 5), what would 'result' be after step 5?

A 30

B 15

C 8

D undefined

💡 Hint

Think about how sum is calculated as x + y in the function body.

Concept Snapshot

Function definition in R:
function_name <- function(parameters) {
  # code to run
  return(value)
}
Call with arguments: function_name(args)
Returns the value from return() or last expression.

Full Transcript

This visual trace shows how to define a function in R with parameters, how the function stores the code, and how calling it runs the code with given arguments. Variables inside the function get values from the call, the function calculates the sum, returns it, and the result is saved and printed. Key points include understanding parameters as placeholders, the role of return, and saving the function output for later use.

Practice

1. What is the correct way to start defining a function named greet in R?

easy

A. greet <- function() { }

B. function greet() { }

C. def greet() { }

D. function <- greet() { }

Solution

1. Step 1: Recognize R function syntax

   In R, functions are defined by assigning a function() to a name using <-.

2. Step 2: Match the correct syntax

   greet <- function() { } uses the correct syntax: name <- function() { }.

3. Final Answer:

   greet <- function() { } -> Option A

4. Quick Check:

   Function definition = name <- function() [OK]

Hint: Use name <- function() to define functions in R [OK]

Common Mistakes:

• Using def instead of function
• Writing function name() without <-
• Placing function keyword after name

2. Which of the following is the correct syntax to define a function add that takes two arguments x and y in R?

easy

A. function add(x, y) { x + y }

B. add(x, y) <- function { return x + y }

C. add <- function(x, y) { return(x + y) }

D. add <- function x, y { return(x + y) }

Solution

1. Step 1: Check function definition format

   In R, arguments go inside parentheses after function keyword, and the body is inside braces.

2. Step 2: Verify return statement and assignment

   add <- function(x, y) { return(x + y) } correctly assigns function with arguments and uses return() properly.

3. Final Answer:

   add <- function(x, y) { return(x + y) } -> Option C

4. Quick Check:

   Arguments inside function() and return() used [OK]

Hint: Put arguments inside function() parentheses [OK]

Common Mistakes:

• Placing arguments outside function()
• Missing braces {} around function body
• Incorrect assignment syntax

3. What will be the output of the following R code?

multiply <- function(a, b) {
  result <- a * b
  return(result)
}
multiply(3, 4)

medium

A. 12

B. 7

C. 34

D. Error

Solution

1. Step 1: Understand function behavior

   The function multiply takes two numbers and returns their product.

2. Step 2: Calculate the product of 3 and 4

   3 * 4 equals 12, so the function returns 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply inputs and return result to get output [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Forgetting to return the result

4. Identify the error in this R function definition:

sum_values <- function(x, y) 
  total <- x + y
  return(total)
}

medium

A. Function name is invalid

B. Missing opening brace { after function()

C. Incorrect use of return()

D. Arguments should be inside square brackets []

Solution

1. Step 1: Check function body braces

   The function body must be enclosed in braces { } immediately after function() declaration.

2. Step 2: Locate missing brace

   The code lacks an opening brace { after function(x, y), causing syntax error.

3. Final Answer:

   Missing opening brace { after function() -> Option B

4. Quick Check:

   Function body needs { } [OK]

Hint: Always put { after function() to start body [OK]

Common Mistakes:

• Omitting braces around function body
• Placing return outside function
• Using wrong brackets for arguments

5. You want to write a function filter_positive that takes a numeric vector and returns only the positive numbers. Which function definition correctly does this in R?

hard

A. filter_positive <- function(vec) { return(vec[vec == 0]) }

B. filter_positive <- function(vec) { return(vec[vec < 0]) }

C. filter_positive <- function(vec) { vec > 0 }

D. filter_positive <- function(vec) { return(vec[vec > 0]) }

Solution

1. Step 1: Understand filtering in R

   To get positive numbers, select elements where vec > 0.

2. Step 2: Check return statement

   filter_positive <- function(vec) { return(vec[vec > 0]) } returns vec elements where condition vec > 0 is TRUE, correctly filtering positives.

3. Final Answer:

   filter_positive <- function(vec) { return(vec[vec > 0]) } -> Option D

4. Quick Check:

   Filter with vec[vec > 0] returns positives [OK]

Hint: Use vec[vec > 0] to filter positive numbers [OK]

Common Mistakes:

• Using wrong comparison operator
• Not returning filtered vector
• Returning logical vector instead of values