常連

PHPにおけるクロージャは`static function()`や`static fn()`といったstaticキーワードを付ける事ができますが、そのstaticの有用性について教えてください。

PHPのリファレンスを見ると下記のように書かれていますが、自分には`$this`が使えるか否か程度にしか思えず、staticで制限することによるメリットが思いつきません。
他にどういった差があるのでしょうか。

https://www.php.net/manual/ja/functions.anonymous.php#functions.anonymous-functions.static
> static を付けて無名関数を宣言することができます。 こうすることで、現在のクラスが無名関数を自動的にバインドすることがなくなります。 オブジェクトも、実行時にはバインドされなくなります。

また、自分が携わっているプロジェクトの既存コードの例に従って、割と考えなしにパフォーマンスの点で有利なのかなと思って、あらゆるクロージャにstaticを付けているのですが、基本的に付けるのが得策なのでしょうか？
ちなみにほぼすべて下記のような使い捨てのクロージャしか存在しません。

```php
$result = array_map(static fn(int $item) => $item * 10, $arr);
```

可能であればstaticを付けるべきケース、そうでないケースについてそれぞれ例を挙げていただけると助かります。

staticなクロージャの有用性について

# Rubyなら簡単に動かせるコードがRustでは通らない

（エラーメッセージの読み方が間違っていたので修正しました。）

こんにちは。Rustでソフトウェアの開発を行なっています。

Rubyならラムダの中でさらに同インスタンスメソッドが呼び出し# (1)および代入# (2)ができます。

```ruby
# Rubyならこう書けば実現できるが…
class Card
  def run(assignor)
    assignor[28]
  end
end

class App
  def assign(value)
    @value = value # (2)
  end
  def setup
    @value = 42
    @card = Card.new
  end
  def update
    @card.run(
      ->(value) { self.assign(value) } # (1)
    )
    puts @value # => 28と表示される
  end
end

def main
  app = App.new
  app.setup
  app.update
end

main
```

## 同様の動作をRustでも実現したい、しかし…
クロージャで同じように同オブジェクトのメソッドを呼び出そうと考えました。

しかしこれはうまくいきません。

```rust
// Rustではコンパイルエラーになる
#[derive(Default)]
pub struct Card;
impl Card {
    pub fn new() -> Self {
        Self
    }
    pub fn run<F>(&self, mut assignor: F)
    where
        F: FnMut(i32),
    {
        assignor(28);
    }
}

#[derive(Default)]
struct App {
    value: i32,
    card: Card,
}
impl App {
    fn assign(&mut self, value: i32) {
        self.value = value;
    }
    pub fn setup(&mut self) {
        self.value = 42;
        self.card = Card::new();
    }
    pub fn update(&mut self) {
        self.card.run(|value| {
            self.assign(value);
        });
        println!("{}", self.value);
    }
}

fn main() {
    let mut app = App::default();
    app.setup();
    app.update();
}
```

## エラーメッセージ抜粋
```
error[E0500]: closure requires unique access to `*self` but it is already borrowed
  --> src/main.rs:29:23
   |
29 |           self.card.run(|value| {
   |           -         --- ^^^^^^^ closure construction occurs here
   |           |         |
   |  _________|         first borrow later used by call
   | |
30 | |             self.assign(value);
   | |             ---- second borrow occurs due to use of `*self` in closure
31 | |         });
   | |__________- borrow occurs here
```

Rustでは二重に借用できないルールがあるようで、コンパイルできませんでした。

Rubyの書き方が非常に便利なため可能であればこれを何とかして実現したいです。

もし解決方法をご存じの方いらっしゃれば、恐縮ですが教えていただけないでしょうか。

よろしくお願いいたします。

【Rust】クロージャ（ラムダ）からメソッドを呼び出す処理は、Rubyなら簡単なのにRustではコンパイルエラーになってしまう

昨日、ここの優秀な方に見てもらったのですが、私の理解が及ばず解決に至っていない問題について質問を立て直しました。お力を借りることはできますでしょうか？
【過去質問】　https://teratail.com/questions/259406
【今やっている事】
ふりがな変換APIを利用したアプリ開発
【どうやっているか】
ViewController（入力後HttpRequestを呼んでいます）→HttpRequest（API取得）→ResultViewController（結果表示）を考えています。
【解決したい事】
下記コードで実行してもAlamofire.requestのところでその中の処理が流れずに、segueを使って値渡しをしてしまうため、結果が表示されるResultViewControllerにnilが渡されてしまいエラーが起こってしまう
【期待値】
Alamofire.requestの処理が通ってからResultViewControllerに値を渡してresultTextViewに表示すること

不明な点などがあれば、追記いたします。よろしくお願いいたします。

```Swift
import UIKit
import Alamofire
import SwiftyJSON

class ViewController: UIViewController,UITextFieldDelegate {

    @IBOutlet weak var inputTextView: UITextField!

    // APIRequestの初期化
    var apiRequest = APIRequest()

    override func viewDidLoad() {
        super.viewDidLoad()

        inputTextView.delegate = self
        initInputText()
    }

    private func initInputText() {
        inputTextView.text = ""
    }

    @IBAction func convertButton(_ sender: UIButton) {
        //キーボードを閉じる
        view.endEditing(true)

        
        // リクエストを渡す時にクロージャも渡し、その内部で書き換えの処理を行う
        // クロージャの処理は completion: の後の {} の中
        apiRequest.HttpRequest(sentence: inputTextView.text!, completion: {
            result in
            // navigationController を使った画面遷移は、performSegue もしくは instantinateViewController と pushViewController を組み合わせて使う

            // segue を使う画面遷移
            self.performSegue(withIdentifier: "nextSegue", sender: result)
        })
    }

    // segue を使って値渡しする場合
    override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
        // 遷移先が ResultViewController の場合
        if let nextVC = segue.destination as? ResultViewController {
            // sender が　String としてダウンキャストできる場合
            if let result = sender as? String {
                // 遷移先のプロパティに値をセットする
                nextVC.result = result
            }
        }
    }
}

public class APIRequest {
    // 関数の引数としてクロージャを取るように設定し、クロージャ内部で目的とするビューに表示させる
    // クロージャは completion: の後に引数として取る
    //    func HttpRequest(sentence: String) {
    func HttpRequest(sentence: String, completion: @escaping (String) -> Void ) {
        let url = URL(string: "https://labs.goo.ne.jp/api/hiragana")!
        let parameters = ["app_id":"適切なAPIキー　https://labs.goo.ne.jp/api/jp/hiragana-translation/　で発行後、入力してください",
                          "sentence":"(sentence)",
                          "output_type":"hiragana"]
   　　　//AlamofireでHTTPリクエスト
        Alamofire.request(url, method: .post, parameters: parameters, encoding: JSONEncoding.default).responseJSON { response in
　　　　　　　//↓ここに処理が流れない
            switch response.result {
            // 処理成功時
            case .success(let data):
                if let result = data as? [String: Any] {
                    //SwiftyJSONを使用してJSON解析
                    let json = JSON(result as Any)
                    let resultString = json["converted"].string
                    // MARK: 変更
                    // ResultVC.showResult(resultString: resultString!)
                    // 上記の方法でビューをインスタンス化しても表示することはできない。
                    // インスタンス化する方法はクロージャで渡された処理に任せる
                    if let resultString = resultString {
                        // クロージャで渡された処理がメインキューで行うべき処理かもしれないので、メインキューで処理する
                        DispatchQueue.main.async {
                            // クロージャの処理
                            completion(resultString)
                        }
                    }

                }
            // 処理失敗時
            case .failure(let error):
                print("error: ", error.localizedDescription)
            }
        }
    }
}

class ResultViewController: UIViewController, UITextFieldDelegate {
    // MARK: 追加
    // 前の画面から渡される変数
    var result: String!

    @IBOutlet weak var resultTextView: UITextField!

    override func viewDidLoad() {
        super.viewDidLoad()
        resultTextView.delegate = self
     
        // ここで showResult を実行する　現在ここにnilが渡ってきてしまっています。
        showResult(resultString: result)
    }

    func showResult(resultString: String) {
        resultTextView?.text = resultString 
        print(resultString)
    }
}

```
ViewController（入力後HttpRequestを呼んでいます）→HttpRequest（裏でAPI取得）→ResultViewController（結果表示）
![ストーリーボード](9bf2a99d3839f7d32e9a2cd97c905f90.png)

Swift クロージャによる画面遷移と値の渡し方について

下記コードの (A)、(B) の部分について、mut の効果範囲に疑問を感じています。
私の Rust に関する知識が浅く、疑問自体をうまく表現できていない状態で大変申し訳ありません。
以下のような考え方で合っているのかどうか、自分ではわからない状態で悩んでいます。
すみませんが、ご教授をいただけると本当にありがたいです。

(A) においては、rect の内容が変更されないから mut は不要。
right_bottom の参照先は書き換わるけれど、right_bottom を指すアドレス自体は変更されないため。

(B) においては、func でキャプチャされる変数が、rect だけでなく rb にも及ぶ。（lt はキャプチャされない）
そのためクロージャ生成時に、rect と rb を含む構造体が生成されて、move_x() 実行時に rb が変更されると判断されて、func に mut が必要となる。

```
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn move_x(&mut self) {
        self.x += 10;
    }	
}

#[derive(Debug)]
struct Rectangle<'a> {
    left_top: Point,
    right_bottom: &'a mut Point,
}

fn main() {
    let lt = Point { x: 1, y: 1 };
    let mut rb = Point { x: 5, y: 5 };

    let rect = Rectangle { left_top: lt, right_bottom: &mut rb };
    // (A) rect に mut が付与されていなくても move_x（）は実行可能
    rect.right_bottom.move_x();
    println!("rect: {:?}", rect);

    // (B) func に mut を付与しないと、move_x（）は実行不可能
    let mut func = || {
        rect.right_bottom.move_x();
    };

    func();
    println!("rect: {:?}", rect);
}
```

Rust のクロージャにおける mut の効果範囲

MDNのクロージャについての記事で、以下のコードについて質問があります。

```ここに言語を入力
function makeFunc() {
  var name = 'Mozilla';
  function displayName() {
    alert(name);
  }
  return displayName;
}

var myFunc = makeFunc();
myFunc();
```

この

```ここに言語を入力
var myFunc = makeFunc();
myFunc();
```

の関数の呼び出し部分を、ただ単にmakeFunc();と記述しても同様の結果が得られると思ったのですが、エラーになってしまいました。

なぜmyFuncに代入する必要があるのでしょうか。

ご回答頂けると幸いです。

関数をconstに代入しないとエラーになる理由

クロージャを使いReturnを使わないメリットとは
SwiftでTwitterクライアントを作ろうとしています。

Qiitaですでに作ってらっしゃる方がいらしたので、参考にしようと思ったのですが

Accountを取得する際や、TimeLineを取得する際、頑なにreturnは使わず、クロージャを使い、CallBackでAccountや、TimeLineを返しています。

実際のソースは下記のようなものです。
```swift
func getAccounts(callback: @escaping ([ACAccount]) -> Void) {
    let accountType: ACAccountType = accountStore.accountType(withAccountTypeIdentifier: ACAccountTypeIdentifierTwitter)
    accountStore.requestAccessToAccounts(with: accountType, options: nil) { (granted: Bool, error: Error?) -> Void in
        guard error == nil else {
            print("error! \(error)")
            return
        }
        guard granted else {
            print("error! Twitterアカウントの利用が許可されていません")
            return
        }

        let accounts = self.accountStore.accounts(with: accountType) as! [ACAccount]
        guard accounts.count != 0 else {
            print("error! 設定画面からアカウントを設定してください")
            return
        }
        print("アカウント取得完了")
        callback(accounts)
    }
}
```

このような場合ですと、処理が追いづらく、可読性が低いのではないか？と疑問に思ったのですが、クロージャを使う理由はどう言ったものがあるのでしょう。

Swiftのクロージャしかわからないのですが、一応、値のキャプチャなどは理解しているつもりです。

ちなみに、参考にさせていただいている記事はこちらです。
こちらの記事を貶めようと思っての投稿ではございませんので、何卒、ご了承ください
http://qiita.com/keisei_1092/items/32a96dbdb6bc394b0e8e#gettimeline

以上、ご回答のほど、よろしくおお願い致します。

クロージャを使ってReturnを使わないメリットとは？

## 質問内容
https://docs.microsoft.com/ja-jp/cpp/cpp/lambda-expressions-in-cpp?view=msvc-160 に記述されている
「C++ 11 以降では、ラムダ式 (多くの場合、 ラムダ と呼ばれます) は、関数に引数として呼び出されるか、引数として渡される匿名関数オブジェクト ( クロージャ) を定義する便利な方法です」
という文章についてなのですが、私がこの通り認識していたところ、他の質問において、クロージャと無名関数は全くの別物だと指摘されてしまいました。
この文章が間違ってるのか、C++が特殊なのか、それとも何も矛盾してないかのどれでしょうか？
それとも方言のようなものでしょうか？

クロージャと無名関数の関係について

現在、Kotlinの勉強をしていてクロージャを理解しようとしているのですが、考え方があっているのか分かりません。

私の考え方では、クロージャとは、クラスのprivateメンバにアクセスできないのと同様に、本来ならアクセスできないスコープ外の変数を、ラムダ式や無名関数でアクセスできるようにする手段、と理解しています。
この考え方だと、クラスでゲッターやpublicなメソッドを使っているのと何ら変わらない気がしています。

クロージャを使うメリットもあまり理解していないので(オブジェクト指向のカプセル化の概念が邪魔してます…)、分かりやすく説明していただけませんか？
よろしくお願いします。