F #: Liste. [(Argument) ..] Fehler im Match Pattern

Question

Ich habe eine Funktion erstellt, wo ich die Länge einer Liste von einem bestimmten Index bis zum Ende der Liste übereinstimmen möchte. Beispiel. Liste [4 ..] gibt Ihnen eine neue Liste mit den Elementen von der Liste von Index 4 bis zum Ende. Ich weiß, dass dies wahr ist, seit ich das viele Male getan habe.

Aber jetzt, wenn ich versuche, dieses Muster in einem Spiel zu tun, dann ist es Fehler:

„Lookup auf Objekt von unbestimmter Art basierte auf Informationen, die vor diesem Programmpunkt A Typanmerkung zu diesem Programm benötigt, bevor sein. Zeigen Sie, um den Typ des Objekts zu beschränken. Dadurch kann die Suche aufgelöst werden. "

mein Code sieht wie folgt aus:

let rec possibilityGuess n p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 SS = 
    match (List.length (SS.[n..])) with 
    |1 -> match (validate (List.item(0) SS) (List.item(n) SS)) with 
     |(0,0) -> [(p1+1);p2;p3;p4;p5;p6;p7;p8;p9;p10;p11;p12;p13;p14] 
     |(0,1) -> [p1;(p2+1);p3;p4;p5;p6;p7;p8;p9;p10;p11;p12;p13;p14] 
     |(0,2) -> [p1;p2;(p3+1);p4;p5;p6;p7;p8;p9;p10;p11;p12;p13;p14] 
     |(0,3) -> [p1;p2;p3;(p4+1);p5;p6;p7;p8;p9;p10;p11;p12;p13;p14] 
     |(0,4) -> [p1;p2;p3;p4;(p5+1);p6;p7;p8;p9;p10;p11;p12;p13;p14] 
     |(1,0) -> [p1;p2;p3;p4;p5;(p6+1);p7;p8;p9;p10;p11;p12;p13;p14] 
     |(1,1) -> [p1;p2;p3;p4;p5;p6;(p7+1);p8;p9;p10;p11;p12;p13;p14] 
     |(1,2) -> [p1;p2;p3;p4;p5;p6;p7;(p8+1);p9;p10;p11;p12;p13;p14] 
     |(1,3) -> [p1;p2;p3;p4;p5;p6;p7;p8;(p9+1);p10;p11;p12;p13;p14] 
     |(2,1) -> [p1;p2;p3;p4;p5;p6;p7;p8;p9;(p10+1);p11;p12;p13;p14] 
     |(2,2) -> [p1;p2;p3;p4;p5;p6;p7;p8;p9;p10;(p11+1);p12;p13;p14] 
     |(3,0) -> [p1;p2;p3;p4;p5;p6;p7;p8;p9;p10;p11;(p12+1);p13;p14] 
     |(3,1) -> [p1;p2;p3;p4;p5;p6;p7;p8;p9;p10;p11;p12;(p13+1);p14] 
     |_ ->  [p1;p2;p3;p4;p5;p6;p7;p8;p9;p10;p11;p12;p13;(p14+1)] 
    |_ -> match (validate (List.item(0) SS) (List.item(n) SS)) with 
     |(0,0) -> (possibilityGuess (n+1) (p1+1) p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(0,1) -> (possibilityGuess (n+1) p1 (p2+1) p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(0,2) -> (possibilityGuess (n+1) p1 p2 (p3+1) p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(0,3) -> (possibilityGuess (n+1) p1 p2 p3 (p4+1) p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(0,4) -> (possibilityGuess (n+1) p1 p2 p3 p4 (p5+1) p6 p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(1,0) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 (p6+1) p7 p8 p9 p10 p11 p12 p13 p14 SS) 
     |(1,1) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 (p7+1) p8 p9 p10 p11 p12 p13 p14 SS) 
     |(1,2) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 (p8+1) p9 p10 p11 p12 p13 p14 SS) 
     |(1,3) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 (p9+1) p10 p11 p12 p13 p14 SS) 
     |(2,1) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 p9 (p10+1) p11 p12 p13 p14 SS) 
     |(2,2) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 (p11+1) p12 p13 p14 SS) 
     |(3,0) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 (p12+1) p13 p14 SS) 
     |(3,1) -> (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 (p13+1) p14 SS) 
     |_ ->  (possibilityGuess (n+1) p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 (p14+1) SS) 
printfn "%A" (possibilityGuess 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S) 

so ist es in der zweiten Zeile, wo ich versuche List.length SS.[n..] with 1 'das ist das Problem zu passen, die ich, warum verstehen kann nicht?

n ist ein Int, das in 0 beginnt und für jeden rekursiven Aufruf 1 hinzufügt.

Ich habe versucht, es so zu rearrangieren, ich würde 1 mit x when x = List.length SS.[n..] übereinstimmen, das gibt den gleichen Fehler.

So wie ich es verstehe, dann wird es nicht akzeptieren SS.[n..] in einem Match-Muster, das mich wirklich verwirrt, da ich weiß, dass dieser Ausdruck in anderen Fällen funktioniert.

bitte helfen Sie mir.

Answer 1

Die Tatsache, dass Sie SS.[n..] in einem match tun, ist nicht das Problem; Das eigentliche Problem (wie direkt durch die Fehlermeldung angezeigt) ist, dass an dem Punkt, den Sie SS.[n..] tun, der Typ SS nicht bekannt ist. Die Tatsache, dass Sie das Ergebnis dieses Ausdrucks an List.length übergeben, hilft nicht weiter, da jeder Typ, der das Schneiden unterstützt, konnte eine Liste zurückgeben. Geben Sie SS einen expliziten Typ Annotation und alles ist gut:

let rec possibilityGuess n p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 (SS:list<_>) = 
    ...