F# int->int=function y->y+1都有效，而让x:int->int=42或让x:int=function y->y+1无效，因为42没有类型int->int，函数y->y+1没有类型int

现在，当您使用快捷语法定义函数时，如

let f（x:ParameterType）：T

，那么最后一个冒号的左边是

f（x:ParameterType）

，而不是

f

。所以你现在说的是

f（x）

的类型（或者换句话说

f

的返回类型），而不是

f

的类型。同样，这个类型应该与

=

后面的任何类型相匹配

---

PS:let f=function x->…（或者就此而言，

let f=fun x->…

）和

let f x=…

完全等效并定义函数。方法是使用

member

关键字定义的，似乎与您的问题无关。

冒号表示剩余内容的类型。因此，当您编写

时，让x:T=…

，您的意思是

x

的类型是

T

。这里的

T

应该与

=

后面的任何内容的类型相匹配。因此，如果这是一个函数，

T

应该是一个兼容的函数类型，如果是其他函数，

T

应该是其他函数类型

例如，

let x:int=42

和

let x:int->int=function y->y+1

都是有效的，而

let x:int->int=42

或

let x:int=function y->y+1

则不是有效的，因为

42

没有类型

int->int

和

function y->y+1

没有类型

int

现在，当您使用快捷语法定义函数时，如

let f（x:ParameterType）：T

，那么最后一个冒号的左边是

f（x:ParameterType）

，而不是

f

。所以你现在说的是

f（x）

的类型（或者换句话说

f

的返回类型），而不是

f

的类型。同样，这个类型应该与

=

后面的任何类型相匹配

PS:let f=function x->…（或者就此而言，

let f=fun x->…

）和

let f x=…

完全等效并定义函数。方法是使用

member

关键字定义的，似乎与您的问题无关

type StateResponse<'state, 'event> = ('state * 'event) -> 'state

// Account * Event -> Account
let update1 : StateResponse<Account,Event> = function
    | account , LoggedIn  credentials ->   account
    | account , Deposited balance     -> { account with Balance=account.Balance + balance }
    | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

// Account ** Doesn't compile**
let update2 : Account = function
    | account , LoggedIn  credentials ->   account
    | account , Deposited balance     -> { account with Balance=account.Balance + balance }
    | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

// Account * Event -> Account
let update3 = function
    | account , LoggedIn  credentials ->   account
    | account , Deposited balance     -> { account with Balance=account.Balance + balance }
    | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

// state:Account * event:Event -> Account
let update4 (state , event) =
    match   state , event with
    | account , LoggedIn  credentials ->   account
    | account , Deposited balance     -> { account with Balance=account.Balance + balance }
    | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

// state:StateResponse<Account,Event> * event:Event -> StateResponse<Account,Event> ** Doesn't compile**
let update5 (state , event) : StateResponse<Account,Event> =
    match   state , event with
    | account , LoggedIn  credentials ->   account
    | account , Deposited balance     -> { account with Balance=account.Balance + balance }
    | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

namespace Domain

module EventSourcing =

    type StateResponse<'state, 'event> = ('state * 'event) -> 'state

module Account =

    open EventSourcing

    type AccountId = AccountId of string
    type FirstName = FirstName of string
    type LastName =  LastName  of string

    type Credentials =   { UserId:string; Password:string }
    type Account = {
         AccountId: AccountId
         FirstName: FirstName
         LastName:  LastName
         Balance:   decimal }

    and Event = 
        | LoggedIn  of Credentials
        | Deposited of balance: decimal
        | Withdrew  of balance: decimal

    (*Functions*)
    let getAccount credentials = {
        AccountId= AccountId "myAccountId"
        FirstName= FirstName "Scott"
        LastName= LastName   "Nimrod"
        Balance= 20000m }

    let update1 : StateResponse<Account,Event> = function
        | account , LoggedIn  credentials ->   account
        | account , Deposited balance     -> { account with Balance=account.Balance + balance }
        | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

    let update2 : Account = function
        | account , LoggedIn  credentials ->   account
        | account , Deposited balance     -> { account with Balance=account.Balance + balance }
        | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

    let update3 = function
        | account , LoggedIn  credentials ->   account
        | account , Deposited balance     -> { account with Balance=account.Balance + balance }
        | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

    let update4 (state , event) =
        match   state , event with
        | account , LoggedIn  credentials ->   account
        | account , Deposited balance     -> { account with Balance=account.Balance + balance }
        | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }

    let update5 (state , event) : StateResponse<Account,Event> =
        match   state , event with
        | account , LoggedIn  credentials ->   account
        | account , Deposited balance     -> { account with Balance=account.Balance + balance }
        | account , Withdrew  balance     -> { account with Balance=account.Balance - balance }