- Trending Categories
- Data Structure
- Operating System
- MS Excel
- C Programming
- Social Studies
- Fashion Studies
- Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Haskell Program to create a function without argument and without a return value
In Haskell, we can create a function without argument and without a return value by using user-defined functions. In all the examples, we are going to define user-defined functions to perform the certain tasks that don’t return any value and are passed without argument like, printGreeting, printMultipleLines, printSquares functions.
Step 1 − The user defined function is defined by writing its definition without returning any value.
Step 2 − Program execution will be started from main function. The main() function has whole control of the program. It is written as main = do. In the main function, the user defined function is being called without passing any argument.
Step 3 − The result is printed to the console, after the function is being called.
In this example, printGreeting is a function that simply prints the string "Hello, there!" to the console.
printGreeting :: IO () printGreeting = putStrLn "Hello, there!" main = do printGreeting
In this example, printMessage uses the do notation to execute two separate putStrLn actions, which print the strings "This is a message." and "Goodbye!" to the console.
printMessage :: IO () printMessage = do putStrLn "This is a message." putStrLn "Goodbye!" main = do printMessage
This is a message. Goodbye!
In this example, printMultipleLines uses the mapM_ function to apply the putStrLn function to a list of strings, effectively printing each string on a separate line. The _ in mapM_ indicates that the function is being used for its side-effects (printing to the console), and the result of each action is discarded.
printMultipleLines :: IO () printMultipleLines = mapM_ putStrLn ["Line 1", "Line 2", "Line 3"] main = do printMultipleLines
Line 1 Line 2 Line 3
In this example, printNumbers uses the mapM_ function to print the numbers from 1 to 5.
printNumbers :: IO () printNumbers = mapM_ print [1..5] main = do printNumbers
1 2 3 4 5
In this example, printSquares uses the mapM_ function to print the squares of the numbers from 1 to 5. The (^2) function raises a number to the power of 2, and the (print . (^2)) expression composes the two functions to apply them in sequence.
printSquares :: IO () printSquares = mapM_ (print . (^2)) [1..5] main = do printSquares
1 4 9 16 25
In this example, printSum uses the print function to print the sum of the numbers from 1 to 100. The $ operator is used to apply the print function to the result of the sum function, which adds up the elements of the list..
printSum :: IO () printSum = print $ sum [1..100] main = do printSum
In this example, printCountdown uses the mapM_ function to print the numbers from 10 down to 1. The (putStrLn . show) expression composes the show function (which converts a value to a string) with the putStrLn function, effectively printing the numbers as strings.
printCountdown :: IO () printCountdown = mapM_ (putStrLn . show) [10, 9..1] main = do printCountdown
10 9 8 7 6 5 4 3 2 1
In this example, printFibonacci uses the mapM_ function to print the first 10 Fibonacci numbers. The fib function calculates the nth Fibonacci number, and the mapM_ function applies print . fib to the list of numbers from 1 to 10. The where clause defines the fib function, which uses a simple recursive definition to calculate each number in the sequence.
printFibonacci :: IO () printFibonacci = mapM_ (print . fib) [1..10] where fib n = if n <= 1 then n else fib (n-1) + fib (n-2) main = do printFibonacci
1 1 2 3 5 8 13 21 34 55
In this example, printFactorial uses the mapM_ function to print the factorials of the numbers from 1 to 5. The factorial function calculates the factorial of a given number, and the mapM_ function applies print . factorial to the list of numbers. The factorial function is defined in the where clause.
printFactorial :: IO () printFactorial = mapM_ (print . factorial) [1..5] where factorial n = if n <= 1 then 1 else n * factorial (n-1) main = do printFactorial
1 2 6 24 120
In Haskell, user-defined functions are functions that are created by the programmer to perform specific operations. The users can define functions as per their need even by not passing any argument and not returning any value in the function definition.
Kickstart Your Career
Get certified by completing the courseGet Started