Swift 09 function, method, closure 

体系的なstructureと効果的なcodeを作成することが核心部分で、굿
Codeの反服を避けながらprogramをstructingする方法を提供します。

# 九・壱　functionは何ですか
## 壱・甲　
>parameter: `a numerical or other measurable factor (system , statistic)`
Origin ~ modern Latin, from Greek para-` ‘beside’ + metron ‘measure’.`

>argument : `1 - an exchange of diverging or opposite views` `2 - aim of persuading others `
Origin ~  Latin argumentum, from arguere `make clear, prove, accuse`

`parameter` と`argument`はprogram codeがどこでも算術計算が必要すれば、パラメータの値を `Argument`にこの関数で伝達して呼べば、結果値が変換されるのである。
## 壱・乙Methodは何だ
Swift`では`Class`内で`func`宣言たったら、これを`Method`で考えられます。

# 九・弐　Swiftで`func`宣言する方法
## 弐・甲
```swift
func<funcName> (<parameterName>: <parameterType>,
                <parameterName>: <parameterType>) -> <returnResultType> {
//func Codes...
}
```
* funcName: アフリのコード内で、`Function`を`call`する時、`Reference`される名前
* returnResultType: `func`が`Return`する結果のデータターフ。もし`func`がデータを`Return`しなれば`returnResultType`を指定ない。

## 弐・乙　単一表現式での暗黙的`Return`
もし、`func`が単一表現式を持っているなら、`Return` `Syntax`を略する事ができます。
```diff_swift
func buildMessageFor(name: String, count: Int) -> String {
+"\(name), your are customer number \(count)" //no return
}
```
`func`がもし二つの表現式を持っている場合には、`Return`が必要です。
```diff_swift
func buildMessageFor(name: String, count: Int) -> String {
- let uppername = name.uppercased()
- "\(name), your are customer number \(count)" //Compile Error!!
}
```
## 弐・丙 Swift `call`
```swift
<funcName>(<argument1><argument2>)
```
`func`をとして伝達されるそれぞれの`Argument`は`func`がもらうように構成された`Parameter`と一致するべきです。
何の`Value`を`Return`しないsayHelloという名前の`func`を `call`しれぱ...
```swift
sayHello()
```
# 九・参　`return` 
## 参・甲　`return` `Value`処理する
逆に、二つの`Parameter`貰って結果を`Return`するBuildMessengeForという名前の`func`を `call`する為には、次の様なコードを作成することになる
```swift
let message = buildMessageFor(name: "John", count: 100)
```
前の例題には`return`される結果を保存する為に「=」を使えました。
でも、`func`を `call`して`return`された`value`を使わない場合が起ければ
`return` `value`を「 _ 」で 割り当てその`value`を捨てる。
```swift
_ = buildMessageFor(name: "John", count: 100)
```
# 九・肆 Parameter
##　肆・甲 Local `Parameter`とExternal `Parameter`
以前の例題の`func`たちは宣言する時に`func`コード内で`reference`できる名前を構成しました。このように宣言された `Parameter`を `Local Parameter`と言います。
基本的に、`func`の `Parameter`には、 `Local Parameter`と `External Parameter`が割り当います。
 `Parameter`で割り当た`External Parameter`は `Local Parameter`の前で
「 _ 」を使って消える事ができます。
```swift
func buildMessageFor(_ name: String, _ count: Int) -> String{
return "\(name), your are customer number \(count)"
```
他の方法で、`func`宣言部で `Local Parameter`の前で `External Parameter`を宣言すれば簡単に`External Parameter`が追加されます。
```swift
func buildMessageFor(userName name: String, userCount count: Int) -> String{
return "\(name), your are customer number \(count)"
```
その場合には`func`を `call`する時に必ず `External Parameter`を`reference`するべきです。
```swift
let message = buildMessageFor(username: "John", usercount:100)
```
`func`を `call`する時には`Argument`を伝達ために `External Parameter`が使われても`func`の内は `Parameter`を`reference`する時には相変わらず `Local Parameter`の名前がを使われます。

## 肆・乙 `func`で`Default Parameter`宣言する
スイフトは`func`が `call`される時、`Argument`で使う`Value`が戻らない場合で使う`Default Parameter`の`Value`を割り当う事ができます。
```swift
func buildMessageFor(_ name: String = "Customer", count: Int) -> String {
return "\(name), your are customer number \(count)"
}
```
その`func`は　_ name `Argument`を伝達しなくても `call`される事ができます。
```swift
let message = buildMessageFor(count: 100) // _ name  XX But OK
print(message)
```
## 肆・丙　多くの`Value` `Return`する
`value`を`Tuple`で`Wrapping`すると多くな`value`を`func`が `Return`ができます。
```swift
func sizeCovnerter(_ length: Float) ->(yards: Float, centimeters: Float, meters: Float) {
let yards - length * 0.02777778
let centimeters = length * 2.54
let meters = length * 0.0254

return(yards, centimeters, meters)
```
## 肆・丁　 `Variadic Parameter`
> variadic : Taking a variable number of arguments 
commonly used in programming languages like C and C++ through features like the ellipsis (...)

### なぜ使う
アフリのコード内で`func`が `call`される時に受け取る `Parameter`が何個のか知らない場合もあります。スイフトは`Variadic Parameter`を使ってこのような場合を処理できるようにします。
### 意味
`func`が指定されたデータターフの `Parameter`数が 0...?受け取ることを意味します。
### 使い方
.三つ　...で表見します。
 `Parameter`は`Array Object`の形で使うことかできます。
```swift
func displayStrings(_ strings: String...)
{
 for string in strings {
         print(string)
    }
}
displayStrings("one", "two", "three", "four")
```
## 肆・戊　変数の `Parameter`
`func`が受ける全ての `Parameter`は基本に常数として扱われます。
 `Parameter`の`value`を変更したいなら、`Shadow Copy`を必ず作成する必要があります。
```swift
func calcuateArea(length: Float, width: Float) -> Float {
    var length = length
    var width = width
    
    length = length * 2.54
    width = width * 2.54
    return length * width
    
}

print(calcuateArea(length: 10, width: 20))
```

## 肆・己 `func`内の計算は`External Parameter`に営業ない

![Screenshot 2023-10-14 at 8.41.08 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/46984ad0-a0a7-bef4-7f5f-ec2e4ee105f2.png)
![Screenshot 2023-10-14 at 8.14.44 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/6dd01c66-2854-06e4-db79-e3565000a30e.png)

でも、`func`が`Value`を`return`した後でも `Parameter`に対した変更を維持すれば、`func`の`name() -> ...` 内で`in out parameter`で　宣言すべきだ。
これを確認ために
![Screenshot 2023-10-14 at 10.27.33 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/5d6a3eab-e1f3-0811-8a42-4151bb286796.png)

## 肆・庚　データターフ様に取扱可能な`func`　

元々の`func`の名前ではなく、`let = 　`を使えて
```swift
func inchesToFeet (_ inches: Float) -> Float {
    return inches * 0.0833333
}
let toFeet = inchesToFeet
```
元々の`func　<name>`ではなく、`let <name>   `を使って `func`を `call`することができます。

```swift
let result = toFeet(10)
// 0.8333333333
```
此れは　`let = 　`と`var 　　`で、割り当てられた`func`は色んなターフの機能「他の`func`の`argument`で送られると、`returnValue`でも　`Return`されることもあります。
## 肆・辛　`func`の`DataType`
受け取る `Parameter`の`DataType`と`Return`される`DataType`を組み合わせて決定されます。
`float`を `Parameter`で受け取って`float`を結果で`Return`するせいで　`float`になります。
```swift
(Float) -> Float
```
反面、`Int`と`Double`を `Parameter`で受け取って`String`結果を`Return`する`func`は `string`になります。
```swift
(Int, Double) -> String
```
どの`func`が他の`func`を `Parameter`で受け取る為には
 `Parameter`で受け取る`func`の`DataType`を宣言すればいい

```swift
func inchesToFeet (_ inches: Float) -> Float {
    return inches * 0.0833333
}
func inchesToYards (_ inches: Float) -> Float {
    return inches * 0.0277778
}
let toFeet = inchesToFeet
let toYards = inchesToYards
```
この`func`たちを活用ためのあたらしい`func`
```swift
func outputConversion(_ converterFunc: (Float) -> Float, value: Float) {
    let result = converterFunc(value)
    
    print("Result of conversion is \(result)")

outputConversion(toYards, value:10)
outputConversion(toFeet, value:10)
```
この`func`は前の`func`が　(Float) -> Float の場合にだけで行います。
![Screenshot 2023-10-15 at 3.53.01 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/50cb9255-c004-e331-e251-bf163b46cef4.png)
![Screenshot 2023-10-15 at 3.54.31 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/b41fc0cb-6730-e312-7e96-3667530d246c.png)
この`func`を使う目的は、
あらかじめ宣言した`DataType`と一致する`func`が 伝達しなければなりません。

# 九・伍 `Closure`表現式
> closure : (psychological) ability to come to terms with a traumatic or distressing event and find a sense of resolution and peace.

> closure : (mathematic) refers to a property of an operation within a set. An operation is said to have closure if when you perform that operation on elements within the set, the result is also an element of that set. For example, addition has closure in the set of real numbers, because when you add two real numbers, the result is still a real number.
## 伍・甲　`closureExpression`について
`closureExpression` は
```swift
let seyHello = { print("Hellow")}
sayHellow()
```
独立なコードブロックです。
`closureExpression`宣言してそれを　sayHello という`let = 　`で割り当て
`func`を `call`する
`closureExpression`は `Parameter`を受け取て`value`を`Return`する様に構成することもできます。
す八艇は
```swift
let multiply = {(_ val1:Int, _ val2: Int) -> Int in
return val1 * val2
}
let result = multiply(10,20)
```
`ClosureExpression`は名前を持たず、
 `Parameter`と `ReturnType`は( )中で含まれて、`ClosureExpressionCode`の初めを指すため`inKewWord`を使えます。`func`は名前があるClosure 表現式に過ぎないんです。
Swift 5.5で`Structured Concurrency`を導入前に、`ClosureExpression`
`AsyncMethodCall`に対した`completionHandler`を宣言するときにたまに使えます。
つまり、IOSアフリを開発するとき、ある`Task`をバックグラウンドで`Task`させることで
アフリが他の`Task`を続けられる様に`OperatingSystem`でりクエストしなければならない場合がどきどきあります。
その場合にはシステムがアフリに`Task`が完了されることを知らせて、`Method`を `Call`する時宣言された`completionHandler`を `Call`して結果を `Return`
します。
`completionHandler`のコードは主に`ClosureExpression`形で貢献実装されます。
## 伍・乙　`shorthand argument name` 「略式引受名前」
此れは`name() -> ...`で `Parameter`の名前をと`in Keword`を省略される様にします`Argument`を\\$0,\\$1,\\$2などと`Reference`できます。
![Screenshot 2023-10-15 at 8.47.13 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/255838b5-ce5a-5f4f-b4c0-961ac962fbf0.png)

## 伍・丙　`Swift`の`Closure`
コンピュータ工学用語での`Closure`は、`func`や`ClosureExpression`などの独立したコードブロックと、コードブロックの周りにある一つ以上の`var 　`を組み合わせたものを指します。
![Screenshot 2023-10-15 at 9.19.34 PM.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3513806/4f4206cd-4aa6-d7cc-4878-213a8e21718c.png)
`func A`は、`func B`という名前の`func`を`Return`します。
`func B`は内部エリア外の `var counter`に依存しています。
`func A`は`Closure`を `Return`しています。
言い直して、`func B`はcounter `var 　`を持っています。または、閉じ込めているだと言えるので、伝統的なコンピュータ工学用語`Closure`でなされます。

# 要約
`func`、`Closure`そして`ClosureExpression`は独立したコードブロックで、特定`Task`を`Running`するため`Call`される事が慣れる事ができるあり、
コードを`Struct`されて再使用するメカニズムを提供します。