F # problèmes d'options de type

Question

j'ai le code suivant:

let rec sums1 n = function 
      | (a,b,x:int array,s,k) when (s<n&&b=x.Length-1) -> []//None 
      | (a,b,x:int array,s,k) when (a=b&&((x.Length-1)=b))->[]// None 
      | (a,b,x,s,k) when (s=n) -> (Array.toList(Array.sub x a k)) 
      | (a,b,x,s,k) when (s<n) -> sums1 n (a,b+1,x,s+x.[b+1],k+1) 
      | (a,b,x,s,k) when (s>n) -> sums1 n (a+1,b,x,s-x.[a],k-1)  
      | (a,b,c,d,e) -> []//None 

let neco n s =match (sums1 n (0,-1,s,0,0)) with 
     | [] ->None 
     | x ->Some x 
let ssum n xs:list<int> = neco n (List.toArray xs) 

Comment il est possible que le compilateur ne me permet pas de revenir de la valeur ssum de l'option de type < liste < int>>. Je vais retourner ce type, pas autre chose. Avoir quelqu'un une idée? Un grand merci.

Answer 1

Je pense que vous êtes manquant parens:

let ssum n (xs:list<int>) = neco n (List.toArray xs) 
     ^  ^

Sans eux, vous décrivez le type de retour de ssum, pas le type d'argument de xs.

Answer 2

Dans ce cas, vous pouvez simplement laisser l'inférence de type faire son travail et de supprimer la déclaration de type:

let ssum n xs = neco n (List.toArray xs)