f＃ - 这个表达式预计有int类型，但是这里有类型'a - > int

我试图在f＃中使用函数，但是现在我发现了一个问题。f＃ - 这个表达式预计有int类型，但是这里有类型'a - > int

我创建了函数来在数组和文件txt中添加数字，但Visual Studio说我的代码中有一个错误。

功能是：

let fnAddNodeFileAndArray (pstrnode:string) lintRowResult:int = 

//Declare variables 
let mutable lstrText = "" 
let mutable larrColisionsAux = Array2D.zeroCreate 0 0 
let mutable lintIndexOfSpace = 0 
let mutable lstrfirstNumber = "" 
let mutable lstrsecondNumber = "" 
let mutable lintNumberColisionNetwork = 0 
let mutable lblnCollisionExist = false 
let mutable lintRowResultAux=0 

//Identify the position where the separator 
lintIndexOfSpace<-pstrnode.IndexOf(",") 
//Get nodes of the collision 
lstrfirstNumber<-(pstrnode.Substring(0,lintIndexOfSpace)) 
lstrsecondNumber<-(pstrnode.Substring(lintIndexOfSpace + 1)) 

for lintRow = 0 to garrrows - 1 do 
    let mutable lintNumberAux1 = int garrColisions.[lintRow,0] 
    let mutable lintNumberAux2 = int garrColisions.[lintRow,1]  
    if (string lstrfirstNumber = string lintNumberAux1 && string lstrsecondNumber = string lintNumberAux2) || 
     (string lstrfirstNumber = string lintNumberAux1 && string lstrsecondNumber = string lintNumberAux2) then 
     lblnCollisionExist <- true 

if lblnCollisionExist=true then 
    printfn "" 
    printfn "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" 
    printfn "Node already exist." 
    printfn "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" 
    lintRowResultAux 
else  

    //Copy the values of the array to auxiliar array 
    larrColisionsAux<-garrColisions 

    //Update de number of collisions 
    garrrows <- garrrows + 1 

    //Re-Create array 
    garrColisions <- Array2D.zeroCreate garrrows 3 

    for lintRow = 0 to garrrows - 2 do 
     garrColisions.[lintRow,0] <- larrColisionsAux.[lintRow,0] 
     garrColisions.[lintRow,1] <- larrColisionsAux.[lintRow,1] 
     garrColisions.[lintRow,2] <- larrColisionsAux.[lintRow,2] 

    //Save the new Number in auxiliar Array 
    garrColisions.[(garrrows-1),0] <- string lstrfirstNumber 
    garrColisions.[(garrrows-1),1] <- string lstrsecondNumber 

    //Save the number in the file 
    for lintCount = 0 to garrrows-1 do 
     lstrText <- lstrText + garrColisions.[lintCount,0] + " " + garrColisions.[lintCount,1] + "\n" 
    File.WriteAllText(gstrpath,lstrText) 

    for lintRow = 0 to (garrrows - 2) do  
     let mutable lintNumberAux1 = int garrColisions.[lintRow,0] 
     let mutable lintNumberAux2 = int garrColisions.[lintRow,1]  
     let mutable lintNumberCollisionNetworkAux = int garrColisions.[lintRow,2] 
     let mutable lblnLessOneNumberOfTheCollisionNetwork = false 

     if (lstrfirstNumber <> string lintNumberAux1) && 
      (lstrsecondNumber <> string lintNumberAux2) && 
      (lstrfirstNumber <> string lintNumberAux2) && 
      (lstrsecondNumber <> string lintNumberAux1) then 
      if lintNumberColisionNetwork = 0 then 
       gintNumberColisionNetwork <- gintNumberColisionNetwork + 1 
       garrColisions.[(garrrows-1),2] <- string (gintNumberColisionNetwork) 
     elif ((lstrfirstNumber = string lintNumberAux1) && (lstrsecondNumber <> string lintNumberAux2)) || 
       ((lstrfirstNumber <> string lintNumberAux1) && (lstrsecondNumber = string lintNumberAux2)) || 
       ((lstrfirstNumber <> string lintNumberAux2) && (lstrsecondNumber = string lintNumberAux1)) || 
       ((lstrfirstNumber = string lintNumberAux2) && (lstrsecondNumber <> string lintNumberAux1)) then 
      if lintNumberColisionNetwork < lintNumberCollisionNetworkAux then 
       garrColisions.[(garrrows-1),2] <- garrColisions.[lintRow,2] 
       if lintNumberColisionNetwork <> 0 && lblnLessOneNumberOfTheCollisionNetwork = false then 
        gintNumberColisionNetwork <- gintNumberColisionNetwork - 1 
        lblnLessOneNumberOfTheCollisionNetwork <- true 
       lintNumberColisionNetwork <- int garrColisions.[lintRow,2] 
      elif lintNumberColisionNetwork > lintNumberCollisionNetworkAux then 
       garrColisions.[lintRow,2] <- garrColisions.[(garrrows-1),2] 
       if lintNumberColisionNetwork <> 0 && lblnLessOneNumberOfTheCollisionNetwork = false then 
        gintNumberColisionNetwork <- gintNumberColisionNetwork - 1 
        lblnLessOneNumberOfTheCollisionNetwork <- true 
       lintNumberColisionNetwork <- int garrColisions.[lintRow,2] 
    garrrows 

let fnAddnode() = 

    let mutable lintrow = 0 
    let mutable lstrNode = "" 

    lstrNode <- fnGetNewNode() 
    lintrow <- fnAddNodeFileAndArray(lstrNode) 
    fnPrintCollisionOneNode (lintrow)

当我尝试调用的函数，系统显示该messagem：

这种表达预计将有一个int类型，但这里的类型为“A - > int

有人知道这是什么意思？

来源

2016-07-06 Andressa Siqueira

通常，当您有类似'预计有类型的错误，但此处有类型'这意味着您没有将参数传递给函数。 –

如果你正在学习F＃和函数式编程，你应该避免使用'mutable'。我知道起初很难，但是你应该在开始时避免它，因为它只会减慢你的学习速度，并且它不被认为是功能性的。我使用mutable的唯一时间是当我使用[P/Invoke]（https://msdn.microsoft.com/en-us/library/hh304361（v = vs.100）.aspx） –

有许多重复项：例如[This expression]（http://stackoverflow.com/questions/34321963/this-expression-was-expected-to-have-type-string-int-but-here-has-type-int?s=2|3.7914 ）这意味着某些东西应该是一个数字，而不是一个函数。 – s952163

如果你将鼠标悬停在let fnAddNodeFileAndArray (pstrnode:string) lintRowResult:int =你会发现，类型签名如下：

VAL fnAddNodeFileAndArray：pstrnode：字符串 - > lintRowResult：'A - > INT

这意味着函数接受字符串，返回一个采用lintRowResult的函数，然后返回一个int。因为你没有在lintRowResult中放置paranthesis，所以F＃认为你注解了函数的返回类型，而不是参数的输入类型。也许你想说的话是这样的：

let fnAddNodeFileAndArray (pstrnode:string) (lintRowResult:int) =

这个函数的类型签名不是会变成：

VAL fnAddNodeFileAndArray：pstrnode：字符串 - > lintRowResult：INT - > INT

这是一个函数，它接受一个字符串和一个int，然后返回一个int。所以它有两个参数。现在，如果您转到代码中的倒数第二行：lintrow <- fnAddNodeFileAndArray(lstrNode)您只有一个参数。所以，很可能你就需要写类似： lintrow <- fnAddNodeFileAndArray lstrNode lintRow

现在很明显你fnAddNodeFileAndArray功能可能是只需要一个lstNode的功能，在这种情况下离开关lintRowResult输入参数：
fnAddNodeFileAndArray (pstrnode:string)：

val fnAddNodeFileAndArray：pstrnode：string - > int

您可以看到F＃知道该函数的输出类型。

您应该认真对待@ GuyCoder的评论，关于在任何地方定义mutable。代码读取非常必要，像通过谷歌翻译蟒蛇...你也许发布它在CodeReview它也相当长，包含外部引用和其他错误。通过一个较小的自包含示例，您将拥有更好的运气，请参阅：MCVE

来源

2016-07-06 23:30:24 s952163

f＃ - 这个表达式预计有int类型，但是这里有类型'a - > int

回答

相关问题