- Trending Categories
- Data Structure
- Networking
- RDBMS
- Operating System
- Java
- MS Excel
- iOS
- HTML
- CSS
- Android
- Python
- C Programming
- C++
- C#
- MongoDB
- MySQL
- Javascript
- PHP
- Physics
- Chemistry
- Biology
- Mathematics
- English
- Economics
- Psychology
- 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 display all prime numbers from 1 to n

This tutorial will discuss writing a program to display all prime numbers from 1 to N in Haskell Programming Language. Haskell is a declarative, strongly typed, and functional language. The computations in Haskell are mathematical functions.

A prime number is one that must have two positive factors 1 and the number itself.

**Example** 2,3,5,7,..

**Note** 1 is not a prime number because it has only one factor.

### Algorithm steps

Implementing a function to check whether a number is prime.

Implementing a function to generate all prime in a range.

Display the prime numbers.

Program to Display all primes from 1 to N

We break the program into simpler functions.

### Syntax

Function to find all factors of a number.

–- function declaration factors :: Int->[Int] –- function definition factors n = [x | x<-[1..n], (mod n x)==0]

Above function is an utility function useful for checking whether a number is prime. We declared a function factor that takes the input of an Integer and returns a list of Integers. In the function, we are generating numbers 1 to n (argument) using list comprehension and Return numbers that divide argument n i.e list comprehension generates all factors of an argument n and returns them as a list.

Ex: output for factors 50 is: [1,2,5,10,25,50] Function to check a number is prime -- function declaration isPrime :: Int->Bool -- function definition isPrime n = (factors n) == [1,n]

Above function is an utility function useful in generating prime numbers in a given range. We declared a function isPrime which takes Integer as an input and returns a boolean. In the function definition, we are invoking the factors function with the argument as a first parameter and comparing the returned list with a list containing two numbers one, and an argument i.e This function checks whether the factors of a number are equal to one and the number itself which is a definition of a prime number, Returns true if the number is prime else returns false.

Ex: Output for isPrime 13 is: True

Function to generate primes from 1 to N in iterative way

-- function declaration generatePrime :: Int->[Int] -- function definition generatePrime n = [x | x<-[1..n], isPrime x]

Above function generates all primes from 1 to N. We declared a function generatePrime which takes an Integer as an argument and returns the list of Integers. In the function definition, we are generating a list of integers from 1 to n using list comprehension and filtering them using isPrime function which returns only numbers that are primes.

Ex: output for generatePrime 50 is: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47]

Function to generate primes from 1 to N in recursive way

-- function declaration generatePrime2 :: Int->[Int] -- function definition -- base case generatePrime2 0 = [] generatePrime2 n = if (isPrime n) then generatePrime2 (n-1) ++ [n] else generatePrime2 (n-1)

Above function generatePrime2 generate all primes from 1 to N in a recursive way. We declared the function as it takes an integer as input and returns a list of integers. In the function definition, we are taking an integer n as an argument and we are checking whether it is prime, If n is prime we are concatenating n with the result returned by a recursive call with argument n-1. If n is not prime we are returning the recursive call with an argument n-1. This goes on until the base case is reached, i.e when n reaches 0 where a function returns an empty list. This checks from n to 0 for primes recursively.

Example: Output for generatePrime 60 is: [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59]

### Overall Program

factors :: Int->[Int] factors n = [x | x<-[1..n], (mod n x)==0] isPrime :: Int->Bool isPrime n = (factors n) == [1,n] generatePrime :: Int->[Int] generatePrime n = [x | x<-[1..n], isPrime x] main = do let n = 100 print (generatePrime n)

### Output

[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]

In the above program we combined all the utility functions to generate prime numbers in a given range. In the main function, we declared and initialized the number n with the value 100 and we invoked the function generatePrime which generates all prime numbers from 1 to N. Finally, we printed the returned list of the invoked function.

## Conclusion

In this tutorial, we discussed writing a program to display all primes from 1 to N in Haskekell Programming Language.

- Related Articles
- Java Program to Display All Prime Numbers from 1 to N
- Swift Program to Display All Prime Numbers from 1 to N
- Kotlin Program to Display All Prime Numbers from 1 to N
- How to Display all Prime Numbers from 1 to N in Golang?
- C program to display all prime numbers between 1 to N using for loop
- Haskell Program to Display Prime Numbers Between Two Intervals
- Haskell Program to Display Prime Numbers Between Intervals Using Function
- Program to find all missing numbers from 1 to N in Python
- Print prime numbers from 1 to N in reverse order
- Haskell Program to calculate the sum of all odd numbers up to N
- Program to find sum of prime numbers between 1 to n in C++
- Find count of Almost Prime numbers from 1 to N in C++
- C++ Program to Display Prime Numbers Between Two Intervals
- Java Program to Display Prime Numbers Between Two Intervals
- Swift program to display prime numbers between two intervals