Being able to manipulate lists is really important in any language.

Haskell isn’t as difficult as it may seem at first.

I think the majority of negativity towards this language comes from adjusting to it being a declarative language, not an object-oriented one.

## Squaring All Integers in a Given Range (Single Generator)

You don’t need a function to do this. You can run this directly from your GHCi command screen. The command `[ x^2 | x <- [1..10] ]` more or less translates to “x to the power of 2, for all x in the range 1 to 10.

The `x <- [1..10]` part is the generator. It generates values for x.

## List Of Ordered Pairs (2 Generators) The command `[ (x,y) | x <- [1,2,3,4,5], y <- ["a","b","c"] ]` uses two generators.

One for x, one for y; each has their own list.

It will return all combinations.

## Joining a List of Lists (Dependant Generators)

```-- this program will join a list of lists

demoList = [[1,2,3],[4,5],[6,7]]            -- just a preset list of lists
joinLists :: [[a]] -> [a]                   -- takes in some list of lists containing some polymorphic type
joinLists xss = [ x | xs <- xss, x <- xs ]  -- for x in each xs from xss, x```

You’ll notice in this function, the command `[ x | xs <- xss, x <- xs ]` is used.

This can be understood simply as:

• a list containing “x”s
• where the “xs”s are pulled from the input “xss”
• and the “x”s are pulled from the “xs”s This uses a dependant generator in that, we cannot get to `x <- xs` without getting `xs <- xss` first.

## Get All Even Numbers in a Given Range (Uses a Guard)

If we want to find all even numbers in a given range we can do that. We’ll be using a generator of `x , [1..n]` which gives us a list of all numbers from 1 to `n` the input. However, we want to guard against the odd numbers, so we need to use `x mod 2 == 0` so we’re only given numbers that divide by `2` and leave a remainder of `0`.

```allEvenUpto     :: Integer -> [Integer]
allEvenUpto n   = [ x | x <- [1..n], x `mod` 2 == 0 ]``` The generator is guarded in this case by `x mod 2 == 0`.

Only when the guard is true, is the `x` generated and put into the list for returning.

## Get List of Factors for a Given Number

This program is very similar to the “all even in range” example. We’re generating all x between 1 and (input) n, where `n mod x` is equal to 0.

The `mod` part is useful for determining whether something divides into something. If `n mod x == 0` then it must be a factor. For example, `2 mod 4` would equal 0. However, `2 mod 5` would be equal to `1` because there is `1` remaining after the division.

```getFactors     	:: Integer -> [Integer]
getFactors n   	= [ x | x <- [1..n], n `mod` x == 0 ]```

This program works really well for this purpose. It returns the list of all factors for the given input `n`. You can see in the above example that for each of the numbers `[1,2,5,10]` they are a factor of `10`.

##### You May Also Like ## 7 eBay SEO Ranking Factors (Exploit Them, Rank High)

You can rank high on ebay using these 7 SEO factors to… ## CPA: I Quit CPA Content Locking for a Few Reasons

I first found out about CPA at a pretty young age. When I started pushing locked content monetized by CPAGrip. But there was always this feeling of wrong-doing when I pushed CPA.

## Does Social Media Affect SEO & Click-Through Rates?

If you’re looking for a quick simple answer then then no, Social…

## Make Money Online with Josh – Project Journal #1

The first project journal post I’ve done so far. These are…