在 F# 中使用函式
簡單的函式定義如下所示：
let f x = x + 1
在上述範例中，函式名稱為 f，引數是類型為 int 的 x，函式主體為 x + 1，而傳回值的類型為 int。
F# 的一個明確特性是函式具有第一級狀態。 您可以使用函式來執行任何可透過其他內建類型值完成的工作，難易程度大致相同。
您可以指定函式值的名稱。
您可以將函式儲存在資料結構中，例如清單中。
您可以在函式呼叫中將函式當做引數傳遞。
您可以從函式呼叫傳回函式。
指定值的名稱
如果函式是第一級值，您要能夠命名它，就像能夠命名整數、字串和其他內建類型一樣。 這在函式程式設計文宣中稱為將識別項繫結至值。 F# 使用 let 繫結將名稱繫結至值：let <identifier> = <value>。 下列程式碼顯示兩個範例。
// Integer and string.
let num = 10
let str = "F#"
命名函式就是如此容易。 下列範例會將識別項 squareIt 繫結至 Lambda 運算式fun n -> n * n 來定義名為 squareIt 的函式。 函式 squareIt 有一個參數 n，並會傳回該參數的平方。
let squareIt = fun n -> n * n
F# 提供下列更精簡的語法，只要鍵入更少內容就能達到相同的結果。
let squareIt2 n = n * n
後續範例大多會使用第一個樣式 let <function-name> = <lambda-expression>，以強調函式宣告與其他實值型別宣告之間的相似性。 不過，所有具名函式也可以使用精簡語法來撰寫。 其中一些範例是以兩種方式撰寫。
將值儲存在資料結構中
第一級值可以儲存在資料結構中。 下列程式碼示範如何將值儲存在清單和元組中。
// Lists.
// Storing integers and strings.
let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
let stringList = [ "one"; "two"; "three" ]
// You cannot mix types in a list. The following declaration causes a
// type-mismatch compiler error.
//let failedList = [ 5; "six" ]
// In F#, functions can be stored in a list, as long as the functions
// have the same signature.
// Function doubleIt has the same signature as squareIt, declared previously.
//let squareIt = fun n -> n * n
let doubleIt = fun n -> 2 * n
// Functions squareIt and doubleIt can be stored together in a list.
let funList = [ squareIt; doubleIt ]
// Function squareIt cannot be stored in a list together with a function
// that has a different signature, such as the following body mass
// index (BMI) calculator.
let BMICalculator = fun ht wt ->
(float wt / float (squareIt ht)) * 703.0
// The following expression causes a type-mismatch compiler error.
//let failedFunList = [ squareIt; BMICalculator ]
// Tuples.
// Integers and strings.
let integerTuple = ( 1, -7 )
let stringTuple = ( "one", "two", "three" )
// A tuple does not require its elements to be of the same type.
let mixedTuple = ( 1, "two", 3.3 )
// Similarly, function elements in tuples can have different signatures.
let funTuple = ( squareIt, BMICalculator )
// Functions can be mixed with integers, strings, and other types in
// a tuple. Identifier num was declared previously.
//let num = 10
let moreMixedTuple = ( num, "two", 3.3, squareIt )
為了確認儲存在元組中的函式名稱實際上會評估為函式，下列範例會使用 fst 和 snd 運算子，從元組 funAndArgTuple 擷取第一個和第二個元素。 元組中的第一個元素是 squareIt，第二個元素是 num。 識別項 num 在上一個範例中已繫結至整數 10，這是 squareIt 函式的有效引數。 第二個運算式會將元組中的第一個元素套用至元組中的第二個元素：squareIt num。
// You can pull a function out of a tuple and apply it. Both squareIt and num
// were defined previously.
let funAndArgTuple = (squareIt, num)
// The following expression applies squareIt to num, returns 100, and
// then displays 100.
System.Console.WriteLine((fst funAndArgTuple)(snd funAndArgTuple))
同樣地，就像識別項 num 和整數 10 可以交替使用，識別項 squareIt 和 Lambda 運算式 fun n -> n * n 也可以交替使用。
// Make a tuple of values instead of identifiers.
let funAndArgTuple2 = ((fun n -> n * n), 10)
// The following expression applies a squaring function to 10, returns
// 100, and then displays 100.
System.Console.WriteLine((fst funAndArgTuple2)(snd funAndArgTuple2))
將值當做引數傳遞
如果值在語言中具有第一級狀態，您可以將其當做引數傳遞至函式。 例如，通常會以引數形式傳遞整數和字串。 下列程式碼顯示在 F# 中以引數形式傳遞整數和字串。
// An integer is passed to squareIt. Both squareIt and num are defined in
// previous examples.
//let num = 10
//let squareIt = fun n -> n * n
System.Console.WriteLine(squareIt num)
// String.
// Function repeatString concatenates a string with itself.
let repeatString = fun s -> s + s
// A string is passed to repeatString. HelloHello is returned and displayed.
let greeting = "Hello"
System.Console.WriteLine(repeatString greeting)
如果函式具有第一級狀態，您要能夠以相同的方式將其當做引數傳遞。 請記住，這是高階函式的第一個特性。
在下列範例中，函式 applyIt 有兩個參數 op 和 arg。 如果您傳送具有一個參數 op 的函式和函式的適當引數 arg，則函式會傳回將 op 套用至 arg 的結果。 在下列範例中，函式引數和整數引數都會以相同的方式傳送，也就是使用其名稱。
// Define the function, again using lambda expression syntax.
let applyIt = fun op arg -> op arg
// Send squareIt for the function, op, and num for the argument you want to
// apply squareIt to, arg. Both squareIt and num are defined in previous
// examples. The result returned and displayed is 100.
System.Console.WriteLine(applyIt squareIt num)
// The following expression shows the concise syntax for the previous function
// definition.
let applyIt2 op arg = op arg
// The following line also displays 100.
System.Console.WriteLine(applyIt2 squareIt num)
將函式當做引數傳送至另一個函式的能力，是函式程式設計語言中常見抽象概念 (例如對應或篩選作業) 的基礎。 例如，對應作業是可擷取計算來供函式共用的高階函式，其會逐步瀏覽清單、對每個元素執行某個動作，然後傳回結果清單。 您可能想要遞增整數清單中的每個元素、取得每個元素的平方，或是將字串清單中的每個元素變更為大寫。 計算中容易出錯的部分是遞迴處理序，其會逐步瀏覽清單，並建置要傳回的結果清單。 對應函式中會擷取該部分。 您只需要為特定應用程式撰寫想個別套用至每個清單元素 (新增、平方、變更大小寫) 的函式。 該函式會當做引數傳送至對應函式，就像在上一個範例中將 squareIt 傳送至 applyIt 一樣。
F# 為大多數集合類型提供對應方法，包括清單、陣列和序列。 下列範例會使用清單。 語法是 List.map <the function> <the list>。
// List integerList was defined previously:
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
// You can send the function argument by name, if an appropriate function
// is available. The following expression uses squareIt.
let squareAll = List.map squareIt integerList
// The following line displays [1; 4; 9; 16; 25; 36; 49]
printfn "%A" squareAll
// Or you can define the action to apply to each list element inline.
// For example, no function that tests for even integers has been defined,
// so the following expression defines the appropriate function inline.
// The function returns true if n is even; otherwise it returns false.
let evenOrNot = List.map (fun n -> n % 2 = 0) integerList
// The following line displays [false; true; false; true; false; true; false]
printfn "%A" evenOrNot
如需詳細資訊，請參閱清單。
從函式呼叫傳回值
最後，如果函式在語言中具有第一級狀態，您要能夠將其傳回作為函式呼叫的值，就像傳回整數和字串等其他類型一樣。
下列函式呼叫會傳回整數並加以顯示。
// Function doubleIt is defined in a previous example.
//let doubleIt = fun n -> 2 * n
System.Console.WriteLine(doubleIt 3)
System.Console.WriteLine(squareIt 4)
下列函式呼叫會傳回字串。
// str is defined in a previous section.
//let str = "F#"
let lowercase = str.ToLower()
下列宣告為內嵌的函式呼叫會傳回布林值。 顯示的值為 True 。
System.Console.WriteLine((fun n -> n % 2 = 1) 15)
傳回函式作為函式呼叫值的能力，是高階函式的第二個特性。 在下列範例中，checkFor 會定義為接受一個引數 item 的函式，並傳回新的函式作為其值。 傳回的函式會接受清單作為其引數 lst，並在 lst 中搜尋 item。 如果 item 存在，則函式會傳回 true。 如果 item 不存在，則函式會傳回 false。 如同上一節，下列程式碼會使用提供的清單函式 List.exists 來搜尋清單。
let checkFor item =
let functionToReturn = fun lst ->
List.exists (fun a -> a = item) lst
functionToReturn
下列程式碼會使用 checkFor 來建立接受一個引數 (清單) 的新函式，並在清單中搜尋 7。
// integerList and stringList were defined earlier.
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
//let stringList = [ "one"; "two"; "three" ]
// The returned function is given the name checkFor7.
let checkFor7 = checkFor 7
// The result displayed when checkFor7 is applied to integerList is True.
System.Console.WriteLine(checkFor7 integerList)
// The following code repeats the process for "seven" in stringList.
let checkForSeven = checkFor "seven"
// The result displayed is False.
System.Console.WriteLine(checkForSeven stringList)
下列範例會使用 F# 中函式的第一級狀態來宣告函式 compose，這會傳回兩個函式引數的組合。
// Function compose takes two arguments. Each argument is a function
// that takes one argument of the same type. The following declaration
// uses lambda expression syntax.
let compose =
fun op1 op2 ->
fun n ->
op1 (op2 n)
// To clarify what you are returning, use a nested let expression:
let compose2 =
fun op1 op2 ->
// Use a let expression to build the function that will be returned.
let funToReturn = fun n ->
op1 (op2 n)
// Then just return it.
funToReturn
// Or, integrating the more concise syntax:
let compose3 op1 op2 =
let funToReturn = fun n ->
op1 (op2 n)
funToReturn
注意
如需較短一點的版本，請參閱下一節＜局部調用函式＞。
下列程式碼會將兩個函式當做引數傳送至 compose，這兩個函式都會接受相同類型的單一引數。 傳回值是兩個函式引數組合的新函式。
// Functions squareIt and doubleIt were defined in a previous example.
let doubleAndSquare = compose squareIt doubleIt
// The following expression doubles 3, squares 6, and returns and
// displays 36.
System.Console.WriteLine(doubleAndSquare 3)
let squareAndDouble = compose doubleIt squareIt
// The following expression squares 3, doubles 9, returns 18, and
// then displays 18.
System.Console.WriteLine(squareAndDouble 3)
注意
F# 提供用於組合函式的兩個運算子 << 和 >>。 例如，let squareAndDouble2 = doubleIt << squareIt 相當於上一個範例中的 let squareAndDouble = compose doubleIt squareIt。
下列範例會傳回函式作為函式呼叫的值，以建立簡單的猜測遊戲。 若要建立遊戲，請呼叫 makeGame，並針對 target 傳送您想要有人猜測的值。 函式 makeGame 的傳回值是接受一個引數 (猜測)，並回報猜測是否正確的函式。
let makeGame target =
// Build a lambda expression that is the function that plays the game.
let game = fun guess ->
if guess = target then
System.Console.WriteLine("You win!")
else
System.Console.WriteLine("Wrong. Try again.")
// Now just return it.
game
下列程式碼會呼叫 makeGame，並針對 target 傳送值 7。 識別項 playGame 會繫結至傳回的 Lambda 運算式。 因此，playGame 是接受 guess 的值作為其唯一引數的函式。
let playGame = makeGame 7
// Send in some guesses.
playGame 2
playGame 9
playGame 7
// Output:
// Wrong. Try again.
// Wrong. Try again.
// You win!
// The following game specifies a character instead of an integer for target.
let alphaGame = makeGame 'q'
alphaGame 'c'
alphaGame 'r'
alphaGame 'j'
alphaGame 'q'
// Output:
// Wrong. Try again.
// Wrong. Try again.
// Wrong. Try again.
// You win!
局部調用函式
上一節中的許多範例都可利用 F# 函式宣告中的隱含「局部調用」來更精簡地撰寫。 局部調用是一種程序，可將具有多個參數的函式轉換成一系列內嵌函式，其中每個函式都有單一參數。 在 F# 中，具有多個參數的函式原本就已局部調用。 例如，上一節中的 compose 可如下所示撰寫為具有三個參數的精簡樣式。
let compose4 op1 op2 n = op1 (op2 n)
不過，結果是一個參數的函式，傳回一個參數的函式，再傳回一個參數的另一個函式，如 compose4curried 中所示。
let compose4curried =
fun op1 ->
fun op2 ->
fun n -> op1 (op2 n)
您可以透過幾種方式來存取此函式。 下列每個範例都會傳回並顯示 18。 您可以在任何範例中將 compose4 取代為 compose4curried。
// Access one layer at a time.
System.Console.WriteLine(((compose4 doubleIt) squareIt) 3)
// Access as in the original compose examples, sending arguments for
// op1 and op2, then applying the resulting function to a value.
System.Console.WriteLine((compose4 doubleIt squareIt) 3)
// Access by sending all three arguments at the same time.
System.Console.WriteLine(compose4 doubleIt squareIt 3)
若要確認函式仍如往常般正常運作，請再次嘗試原始測試案例。
let doubleAndSquare4 = compose4 squareIt doubleIt
// The following expression returns and displays 36.
System.Console.WriteLine(doubleAndSquare4 3)
let squareAndDouble4 = compose4 doubleIt squareIt
// The following expression returns and displays 18.
System.Console.WriteLine(squareAndDouble4 3)
注意
您可以透過在元組中括住參數來限制局部調用。 如需詳細資訊，請參閱參數和引數中的＜參數模式＞。
下列範例會使用隱含局部調用來撰寫 makeGame 的較短版本。 在此格式中，對於 makeGame 如何建構和傳回 game 函式的詳細資料較不明確，但您可以使用原始測試案例來確認結果相同。
let makeGame2 target guess =
if guess = target then
System.Console.WriteLine("You win!")
else
System.Console.WriteLine("Wrong. Try again.")
let playGame2 = makeGame2 7
playGame2 2
playGame2 9
playGame2 7
let alphaGame2 = makeGame2 'q'
alphaGame2 'c'
alphaGame2 'r'
alphaGame2 'j'
alphaGame2 'q'
如需局部調用的詳細資訊，請參閱函式中的＜部分套用引數＞。
識別項和函式定義可互換
先前範例中的變數名稱 num 會評估為整數 10，因此當 num 有效時，10 自然也會有效。 函式識別項及其值也是如此：可以使用函式名稱的任何位置，都可以使用它所繫結的 Lambda 運算式。
下列範例會定義稱為 isNegative 的 Boolean 函式，然後以可互換的方式使用函式的名稱和函式的定義。 接下來的三個範例全都會傳回並顯示 False。
let isNegative = fun n -> n < 0
// This example uses the names of the function argument and the integer
// argument. Identifier num is defined in a previous example.
//let num = 10
System.Console.WriteLine(applyIt isNegative num)
// This example substitutes the value that num is bound to for num, and the
// value that isNegative is bound to for isNegative.
System.Console.WriteLine(applyIt (fun n -> n < 0) 10)
您也可以更進一步地將 applyIt 取代為 applyIt 所繫結的值。
System.Console.WriteLine((fun op arg -> op arg) (fun n -> n < 0) 10)
函式在 F# 中是第一級值
前幾節的範例示範 F# 中的函式滿足 F# 中第一級值的準則：
- 您可以將識別項繫結至函式定義。
let squareIt = fun n -> n * n
- 您可以將函式儲存在資料結構中。
let funTuple2 = ( BMICalculator, fun n -> n * n )
- 您可以將函式當做引數傳遞。
let increments = List.map (fun n -> n + 1) [ 1; 2; 3; 4; 5; 6; 7 ]
- 您可以傳回函式作為函式呼叫的值。
let checkFor item =
let functionToReturn = fun lst ->
List.exists (fun a -> a = item) lst
functionToReturn
如需 F# 的詳細資訊，請參閱 F# 語言參考。
範例
描述
下列程式碼包含本主題中的所有範例。
程式碼
// ** GIVE THE VALUE A NAME **
// Integer and string.
let num = 10
let str = "F#"
let squareIt = fun n -> n * n
let squareIt2 n = n * n
// ** STORE THE VALUE IN A DATA STRUCTURE **
// Lists.
// Storing integers and strings.
let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
let stringList = [ "one"; "two"; "three" ]
// You cannot mix types in a list. The following declaration causes a
// type-mismatch compiler error.
//let failedList = [ 5; "six" ]
// In F#, functions can be stored in a list, as long as the functions
// have the same signature.
// Function doubleIt has the same signature as squareIt, declared previously.
//let squareIt = fun n -> n * n
let doubleIt = fun n -> 2 * n
// Functions squareIt and doubleIt can be stored together in a list.
let funList = [ squareIt; doubleIt ]
// Function squareIt cannot be stored in a list together with a function
// that has a different signature, such as the following body mass
// index (BMI) calculator.
let BMICalculator = fun ht wt ->
(float wt / float (squareIt ht)) * 703.0
// The following expression causes a type-mismatch compiler error.
//let failedFunList = [ squareIt; BMICalculator ]
// Tuples.
// Integers and strings.
let integerTuple = ( 1, -7 )
let stringTuple = ( "one", "two", "three" )
// A tuple does not require its elements to be of the same type.
let mixedTuple = ( 1, "two", 3.3 )
// Similarly, function elements in tuples can have different signatures.
let funTuple = ( squareIt, BMICalculator )
// Functions can be mixed with integers, strings, and other types in
// a tuple. Identifier num was declared previously.
//let num = 10
let moreMixedTuple = ( num, "two", 3.3, squareIt )
// You can pull a function out of a tuple and apply it. Both squareIt and num
// were defined previously.
let funAndArgTuple = (squareIt, num)
// The following expression applies squareIt to num, returns 100, and
// then displays 100.
System.Console.WriteLine((fst funAndArgTuple)(snd funAndArgTuple))
// Make a list of values instead of identifiers.
let funAndArgTuple2 = ((fun n -> n * n), 10)
// The following expression applies a squaring function to 10, returns
// 100, and then displays 100.
System.Console.WriteLine((fst funAndArgTuple2)(snd funAndArgTuple2))
// ** PASS THE VALUE AS AN ARGUMENT **
// An integer is passed to squareIt. Both squareIt and num are defined in
// previous examples.
//let num = 10
//let squareIt = fun n -> n * n
System.Console.WriteLine(squareIt num)
// String.
// Function repeatString concatenates a string with itself.
let repeatString = fun s -> s + s
// A string is passed to repeatString. HelloHello is returned and displayed.
let greeting = "Hello"
System.Console.WriteLine(repeatString greeting)
// Define the function, again using lambda expression syntax.
let applyIt = fun op arg -> op arg
// Send squareIt for the function, op, and num for the argument you want to
// apply squareIt to, arg. Both squareIt and num are defined in previous
// examples. The result returned and displayed is 100.
System.Console.WriteLine(applyIt squareIt num)
// The following expression shows the concise syntax for the previous function
// definition.
let applyIt2 op arg = op arg
// The following line also displays 100.
System.Console.WriteLine(applyIt2 squareIt num)
// List integerList was defined previously:
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
// You can send the function argument by name, if an appropriate function
// is available. The following expression uses squareIt.
let squareAll = List.map squareIt integerList
// The following line displays [1; 4; 9; 16; 25; 36; 49]
printfn "%A" squareAll
// Or you can define the action to apply to each list element inline.
// For example, no function that tests for even integers has been defined,
// so the following expression defines the appropriate function inline.
// The function returns true if n is even; otherwise it returns false.
let evenOrNot = List.map (fun n -> n % 2 = 0) integerList
// The following line displays [false; true; false; true; false; true; false]
printfn "%A" evenOrNot
// ** RETURN THE VALUE FROM A FUNCTION CALL **
// Function doubleIt is defined in a previous example.
//let doubleIt = fun n -> 2 * n
System.Console.WriteLine(doubleIt 3)
System.Console.WriteLine(squareIt 4)
// The following function call returns a string:
// str is defined in a previous section.
//let str = "F#"
let lowercase = str.ToLower()
System.Console.WriteLine((fun n -> n % 2 = 1) 15)
let checkFor item =
let functionToReturn = fun lst ->
List.exists (fun a -> a = item) lst
functionToReturn
// integerList and stringList were defined earlier.
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
//let stringList = [ "one"; "two"; "three" ]
// The returned function is given the name checkFor7.
let checkFor7 = checkFor 7
// The result displayed when checkFor7 is applied to integerList is True.
System.Console.WriteLine(checkFor7 integerList)
// The following code repeats the process for "seven" in stringList.
let checkForSeven = checkFor "seven"
// The result displayed is False.
System.Console.WriteLine(checkForSeven stringList)
// Function compose takes two arguments. Each argument is a function
// that takes one argument of the same type. The following declaration
// uses lambda expression syntax.
let compose =
fun op1 op2 ->
fun n ->
op1 (op2 n)
// To clarify what you are returning, use a nested let expression:
let compose2 =
fun op1 op2 ->
// Use a let expression to build the function that will be returned.
let funToReturn = fun n ->
op1 (op2 n)
// Then just return it.
funToReturn
// Or, integrating the more concise syntax:
let compose3 op1 op2 =
let funToReturn = fun n ->
op1 (op2 n)
funToReturn
// Functions squareIt and doubleIt were defined in a previous example.
let doubleAndSquare = compose squareIt doubleIt
// The following expression doubles 3, squares 6, and returns and
// displays 36.
System.Console.WriteLine(doubleAndSquare 3)
let squareAndDouble = compose doubleIt squareIt
// The following expression squares 3, doubles 9, returns 18, and
// then displays 18.
System.Console.WriteLine(squareAndDouble 3)
let makeGame target =
// Build a lambda expression that is the function that plays the game.
let game = fun guess ->
if guess = target then
System.Console.WriteLine("You win!")
else
System.Console.WriteLine("Wrong. Try again.")
// Now just return it.
game
let playGame = makeGame 7
// Send in some guesses.
playGame 2
playGame 9
playGame 7
// Output:
// Wrong. Try again.
// Wrong. Try again.
// You win!
// The following game specifies a character instead of an integer for target.
let alphaGame = makeGame 'q'
alphaGame 'c'
alphaGame 'r'
alphaGame 'j'
alphaGame 'q'
// Output:
// Wrong. Try again.
// Wrong. Try again.
// Wrong. Try again.
// You win!
// ** CURRIED FUNCTIONS **
let compose4 op1 op2 n = op1 (op2 n)
let compose4curried =
fun op1 ->
fun op2 ->
fun n -> op1 (op2 n)
// Access one layer at a time.
System.Console.WriteLine(((compose4 doubleIt) squareIt) 3)
// Access as in the original compose examples, sending arguments for
// op1 and op2, then applying the resulting function to a value.
System.Console.WriteLine((compose4 doubleIt squareIt) 3)
// Access by sending all three arguments at the same time.
System.Console.WriteLine(compose4 doubleIt squareIt 3)
let doubleAndSquare4 = compose4 squareIt doubleIt
// The following expression returns and displays 36.
System.Console.WriteLine(doubleAndSquare4 3)
let squareAndDouble4 = compose4 doubleIt squareIt
// The following expression returns and displays 18.
System.Console.WriteLine(squareAndDouble4 3)
let makeGame2 target guess =
if guess = target then
System.Console.WriteLine("You win!")
else
System.Console.WriteLine("Wrong. Try again.")
let playGame2 = makeGame2 7
playGame2 2
playGame2 9
playGame2 7
let alphaGame2 = makeGame2 'q'
alphaGame2 'c'
alphaGame2 'r'
alphaGame2 'j'
alphaGame2 'q'
// ** IDENTIFIER AND FUNCTION DEFINITION ARE INTERCHANGEABLE **
let isNegative = fun n -> n < 0
// This example uses the names of the function argument and the integer
// argument. Identifier num is defined in a previous example.
//let num = 10
System.Console.WriteLine(applyIt isNegative num)
// This example substitutes the value that num is bound to for num, and the
// value that isNegative is bound to for isNegative.
System.Console.WriteLine(applyIt (fun n -> n < 0) 10)
System.Console.WriteLine((fun op arg -> op arg) (fun n -> n < 0) 10)
// ** FUNCTIONS ARE FIRST-CLASS VALUES IN F# **
//let squareIt = fun n -> n * n
let funTuple2 = ( BMICalculator, fun n -> n * n )
let increments = List.map (fun n -> n + 1) [ 1; 2; 3; 4; 5; 6; 7 ]
//let checkFor item =
// let functionToReturn = fun lst ->
// List.exists (fun a -> a = item) lst
// functionToReturn
另請參閱
意見反應
即將登場：在 2024 年，我們將逐步淘汰 GitHub 問題作為內容的意見反應機制，並將它取代為新的意見反應系統。 如需詳細資訊，請參閱：https://aka.ms/ContentUserFeedback。
提交並檢視相關的意見反應