Q:

Created a function that calculates fib of some number and now I want to add all them to a list

So I created this function to calculate the fib of some number, pretty standard:
fib 0 = 0
fib 1 = 1
fib x = fib(x-1) + fib(x-2)

But now I want to be able to calculate the fib up to some number and add each of those answers to a list. For example, if I were to calculate the fib up 6 then I should get a list of [0, 1, 1, 2, 3, 5, 8]

A:

The fibs version in @milad zahedi's answer is a classic Haskell method for generating the infinite sequence, though it's probably too clever by half for someone just learning Haskell.  Here's another method of coming up with a decent answer.
A very standard way of generating a list recursively in Haskell is to write something like this:
countDownFrom 0 = []
countDownFrom n = n : countDownFrom (n-1)

Here, the second line generates a list by producing the next element n and attaching it at the head of the "rest of the list", generated by a recursive call to countDownFrom (n-1).  The first line provides the base case when we reach zero, so we don't keep counting forever (assuming we started with a non-negative integer -- otherwise, yikes!).
Counting up needs to be handled a little differently, since:
countUpFrom n = n : countUpFrom (n+1)

doesn't have a common base case -- it depends how high we want to count.  There are lots of ways of handling this in Haskell, but a pretty common pattern is to generate an infinite list and take a finite number of elements from the beginning:
countUpLen n = take n (countUpFrom 1)
   where countUpFrom n = n : countUpFrom (n+1)

where countUpLen 5 generates [1,2,3,4,5].
With all that said, we can use a similar pattern for your Fibonacci sequence.  However, if we try to write:
fibs n = take n (allFibs 0)

allFibs x = x : allFibs ???

we run into a bit of a problem.  For example, if allFibs 1 is supposed to generate the sequence starting with 1, it's not clear if it should generate [1,1,2,3,...] or [1,2,3,5,...] -- in other words, which 1 are we starting with?
Fixing this requires a bit of trick, though once you've seen it, it's obvious.  Let's say we need to generate the part of the Fibonacci sequence that starts [2,3,5,...].  If we kept track of the next two numbers (2 and 3), it would be easy -- we'd spit out 2 and attach it at the head of the rest of the sequence, which would be generated by the two numbers 3 and 5 (calculated from 2+3).  In other words, for this specific case, we'd have:
allFibs 2 3 = 2 : allFibs 3 (2+3)

and more generally, we could write:
allFibs a b = a : allFibs b (a+b)

The interpretation is that allFibs a b generates "the rest of the Fibonacci sequence starting with a and b".
Then, we can write the final solution:
fibs :: Int -> [Int]
fibs n = take n (allFibs 0 1)
    where allFibs a b = a : allFibs b (a+b)

which works like so:
> fibs 10
[0,1,1,2,3,5,8,13,21,34]
>

A:

Here is a good solution
fibs :: [Integer]
fibs = 0:1:zipWith (+) fibs (tail fibs)

but if we improve on your solution we get:
fib :: Integer -> Integer
fib 0 = 0
fib 1 = 1
fib n = fib(n-1) + fib (n-2)

fibs :: [Integer]
fibs = fmap fib [0..]

which is way less efficient than the first solution.

