Génération de la suite de Fibonacci F#

Tout d'abord, vous utilisez let comme si c'était une déclaration de muter une variable, mais ce n'est pas le cas. En F#, let est utilisé pour déclarer une nouvelle valeur (qui peut cacher toutes les valeurs précédentes du même nom). Si vous voulez écrire du code à l'aide de mutation, alors vous devez utiliser quelque chose comme:

let c = a + b  //declare new local value
l.Add(c)  
a <- b   //mutate value marked as 'mutable'
b <- c   //.. mutate the second value

La deuxième question avec votre code, c'est que vous êtes en train de muter F# liste en ajoutant des éléments à elle - F# les listes sont immuables, donc une fois que vous créez, vous ne pouvez pas les modifier (en particulier, il n'y a pas de Add membre!). Si vous souhaitez écrire à l'aide de cette mutation, vous pourriez écrire:

let fabList = 
  //Create a mutable list, so that we can add elements 
  //(this corresponds to standard .NET 'List<T>' type)
  let l = new ResizeArray<_>([1;2])
  let mutable a = 1
  let mutable b = 2
  while l.[l.Count - 1] < 400 do
    let c = a + b
    l.Add(c) //Add element to the mutable list
    a <- b
    b <- c
  l |> List.ofSeq //Convert any collection type to standard F# list

Mais, comme d'autres l'a déjà noté, l'écriture du code dans cette voie n'est pas la idiomatiques F# solution. En F#, vous pouvez utiliser immuable listes et récursivité au lieu de boucles (comme while). Par exemple, comme ceci:

//Recursive function that implements the looping
//(it takes previous two elements, a and b)
let rec fibsRec a b =
  if a + b < 400 then
    //The current element
    let current = a + b
    //Calculate all remaining elements recursively 
    //using 'b' as 'a' and 'current' as 'b' (in the next iteration)
    let rest = fibsRec b current  
    //Return the remaining elements with 'current' appended to the 
    //front of the resulting list (this constructs new list, 
    //so there is no mutation here!)
    current :: rest
  else 
    [] //generated all elements - return empty list once we're done

//generate list with 1, 2 and all other larger fibonaccis
let fibs = 1::2::(fibsRec 1 2)

OriginalL'auteur Tomas Petricek

let rec fibSeq p0 p1 = seq {
    yield p0
    yield! fibSeq p1 (p0+p1)
}

OriginalL'auteur Grozz

Oui, mutable variables et les boucles while sont généralement un bon signe que votre code n'est pas très fonctionnel. Aussi la suite de fibonacci, ne commence pas avec le 1,2 - il commence avec 0,1 ou 1,1 en fonction de qui vous demandez.

Voici comment je ferais:

let rec fabListHelper (a:int,b:int,n:int) =
  if a+b < n then
    a+b :: fabListHelper (b, a+b, n)
  else
    [];;

let fabList (n:int) = 0 :: 1 :: fabListHelper (0,1, n);;

(*> fabList 400;;
val it : int list = [0; 1; 1; 2; 3; 5; 8; 13; 21; 34; 55; 89; 144; 233; 377]*)

OriginalL'auteur sepp2k

Un plus codata new'ish façon:

let rec fib = seq {
  yield! seq {0..1}
  yield! Seq.map (fun(a,b)->a+b) <| Seq.zip fib (Seq.skip 1 fib)
}
let a = fib |> Seq.take 10 |> Seq.toList

OriginalL'auteur olegz

Voici un bon article .Net le gourou de Scott, Hanselman sur la génération de la suite de fibonacci F#

let rec fib n = if n < 2 then 1 else fib (n-2) + fib(n-1)

http://www.hanselman.com/blog/TheWeeklySourceCode13FibonacciEdition.aspx

Il compare aussi avec d'autres langues comme référence

OriginalL'auteur Robben_Ford_Fan_boy