Different fibonacci implementation in Haskell using lists

Question

I have searched the blog for a Fibonacci implementation similar the the one I desire. Nothing came up although there were a lot of questions about Haskell's Fibonacci implementation.

I want a recursive Fibonacci function (speed doesn't matter) that appends each Fibonacci number to a global list on each call to the fib function. I am new to Haskell and coming from an Imperative background. Here is what I thought would work but did'n to the trick.

fibos = []

fib 0 = 1
fib 1 = 1
fib n = (fib(n-1) + fib(n-2)):fibos


main = do 
    putStrLn "Please enter a number:"
    n <- readLn
    fib n
    print fibos

I know about the already existing Fibonacci list in Haskell but my assignment specification wants me to do it in this way. I'm trying to cons each Fibonacci number up to user defined number n into the empty global fibos list. Any help or pointers will be much appreciated.

EDIT:

I now have a working function that returns a list of fibonacci numbers with n number of elements where n is user input, here is the code:

fib::Int->Int
fib 0 = 0
fib 1 = 1
fib n = fib (n-1) + fib (n-2)
fibList n = map fib [0..n]

main :: IO ()
main = do 
    putStrLn "Please enter a positive integer:"
    n <- readLn 
    print (fibList n)

What I need is a function that prints [0,1,1,2] if the user enters 2 and [0,1,1,2,3,5,8] if the user enters 8 or anything between 8 and 12(because 13 is a fib number).

Answer 1

import Data.List

fibo :: Int -> Int
fibo 0 = 0
fibo 1 = 1
fibo n = fibo (n-1)+fibo(n-2)


fiboList x =map fibo [1..x]

main = do
    print ( fiboList 35 )

Answer 2

EDIT:

if all you need is to see the sequence of values that led to fib n, you should just use something like:

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
fib n = (take n fibs, fibs !! n)

which works like this:

*Main> fib 0
([],0)
*Main> fib 1
([0],1)
*Main> fib 10
([0,1,1,2,3,5,8,13,21,34],55)

If you want, you can use the State monad to separate out the list aspect of the computation but it would only mean a list that is "global" in a limited scope (e.g. the main function). That's the closest you can get to whay you want while staying in proper Haskell land.

The Right Way

I'm assuming you're attempting this for purposes of momoization? If yes, basically there already is a global list under the hood of any list-based implementation of fib — any callers of fib use the same lazily evaluated list that the Haskell (e.g. GHC) runtime uses under the hood; any elements of that list that have already been computed are not going to be re-computed.

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

— here, fibs is a global list, and whereas you can't explicitly/manually mutate it, by accessing individual elements in it (fibs !! n), you are indirectly causing the underlying list to be mutated as the runtime adds new values to it.

---

The Wrong Way (but go ahead if you're not going to use this in real code)

If, on the other hand, you need the list for the sake of just having that list, e.g. for debugging or some other weird reason, you can use a really ugly and unsafe hack such as the following IORef based solution, but please remember to stick to function names that end in Unsafe, in the spirit of how the stdlib is marking all of the unsafe calls so that people who use them are aware of the dangers:

import Data.IORef
import System.IO.Unsafe (unsafePerformIO)

fibsStorageUnsafe :: IORef [Integer]
fibsStorageUnsafe = unsafePerformIO $ newIORef []

-- this is one one that uses the pure definition
-- above to compute the value and then store it
-- in a global, mutable IORef
fibUnsafe n = unsafePerformIO (updateFibs ret) `seq` ret
  where
    ret = fib' n

    updateFibs x = do
      old <- readIORef fibsStorageUnsafe
      writeIORef fibsStorageUnsafe (x:old)

    fib' :: Int -> Integer
    fib' 0 = 0
    fib' 1 = 1
    -- you can recursively call fib' instead of fibUnsafe
    -- to only log the "top level" (non-recursive)
    -- calls to fibUnsafe and not all recursive calls
    fib' n = fibUnsafe (n-1) + fibUnsafe (n-2)

which works like this:

*Main> readIORef fibsStorageUnsafe
[]
*Main> fibUnsafe 0
0
*Main> readIORef fibsStorageUnsafe
[0]
*Main> fibUnsafe 1
1
*Main> readIORef fibsStorageUnsafe
[1,0]
*Main> fibUnsafe 3
2
*Main> readIORef fibsStorageUnsafe
[1,0,1,1,2,1,0]
*Main> fibUnsafe  10
55
*Main> readIORef fibsStorageUnsafe
[1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,1,0,1,1,2,1,0,1,3,8,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,13,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,1,0,1,1,2,1,0,1,3,8,21,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,1,0,1,1,2,1,0,1,3,8,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,13,34,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,1,0,1,1,2,1,0,1,3,8,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,13,1,0,1,1,2,1,0,1,3,1,0,1,1,2,5,1,0,1,1,2,1,0,1,3,8,21,55,1,0,1,1,2,1,0]

You can adjust the definitions of fibUnsafe, fib' and other components to fit your goals, but again: I'd strongly recommend against using an approach like this, unless it's solely for learning or experimentation purposes.

For example, if you modify fib' to call itself not fibUnsafe like this:

fib' n = fib' (n-1) + fib' (n-2)

then calling fibUnsafe 10 will yield the following contents for fibStorageUnsafe instead of what you're seeing above:

*Main> fibUnsafe  10
55
*Main> readIORef fibsStorageUnsafe
[55]

DISCLAIMER: I don't even know if the IORef based code above will work correctly under all circumstances — I admit I'm not too familiar with IORefs and how unsafePerformIO works to give any guarantees as to the semantics of the code above.

Answer 3

You can do something similar as you want if it's okay to get a list back:

fibs 0 = [0]
fibs 1 = [0,1]
fibs n = let fs@(f1:f2:_) = fibs (n-1) 
         in (f1+f2) : fs

Then fibs 10 would return [55,34,21,13,8,5,3,2,1,1,0]. Note that it would be either wasteful or more complicated to build the list in the opposite order, as Haskell lists operate only on the "front". For the strange fs@(f1:f2:_), please consult https://en.wikibooks.org/wiki/Haskell/Pattern_matching (@ is the "as"-pattern)

For a "real" Fibonacci function you just need to return the head:

fib n = head (fibs n)

I think this version comes your intentions quite close, and its performance is okay, too. However, this code isn't very idiomatic. The typical approach here are infinite lists (like some other answers show).

If you allow me a personal remark: I found that "imperative" knowledge was more irritating than helpful when learning Haskell. I think you should consciously try to "forget" or "unlearn" what you know about (imperative) programming in order to "grok" functional programming.

Answer 4

In purely functional programming, one does not operate with global, mutable variables. Thus, if you define a global value fibos = [], then that list will never be anything but an empty list. If you instead want a top-level definition that is immutable, fixing it to the n first Fibonacci numbers, where n is determined at runtime and fibs has no parameters, becomes difficult.

An alternative is Haskell's lazy evaluation which enables you to create a top-level definition for all Fibonacci numbers, but they will only be computed to the extent they are requested.

fibs :: [Integer]
fibs = 1:1:zipWith (+) fibs (tail fibs)

Or less fancy:

fibs :: [Integer]
fibs = fib 0 1
  where fib a b = b : fib b (a+b)

You can then extract as many Fibonacci numbers as you need:

main :: IO ()
main = do
  putStr "n: "
  n <- readLn
  putStrLn $ "Fibs: " ++ show (take n fibs)