常連

クロージャを使い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を使わないメリットとは？

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

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

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

この

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

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

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

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

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

# 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ではコンパイルエラーになってしまう

下記コードの (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 の効果範囲

# Rubyなら簡単に動かせるコードをRustでも実現したい

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

問題が二つあるので簡単に説明します。まずは記事中「問題のRustのコード」を確認していただきたいのですが、

- `(*self.renderer)()`でクロージャ実行をしたいが共有参照`&mut`が関与しているのが原因なのか`F`のムーブが関与しているのが原因なのか、型サイズが不明なのが原因なのか、クロージャが呼べません。
- ライフタイムの関係でクロージャ内の一時変数がドロップされるのが理由なのか、構造体にそのクロージャを持たせたいのですが上手くできません。(こちらの方が特に問題)

これらを解決したいです。

検証のため問題を再現した最小のRustのコードを以下に用意しました。

もしご存じの方いらっしゃれば教えていただけないでしょうか。

（Rubyでは実行できることを確認したので追記しました。）

## 本題

### 動作するRubyのコード
Rubyでなら同じ問題は起こりません。

```ruby
class Card
  def initialize(renderer)
    @renderer = renderer
  end
  def render
    @renderer[]
  end
end

class Presenter
  def get
    "Message"
  end
end

class App
  def initialize
    @presenter = Presenter.new
    @card = Card.new(->() { "" })
  end
  def setup
    @presenter = Presenter.new
    @card = Card.new(->() { @presenter.get() })
  end
  def update
    puts @card.render # => "Message"と表示される
  end
end

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

main
```

### 問題のRustのコード（検証用）
そしてこちらが問題です。
```rust
struct Presenter;

impl Presenter {
    pub fn get(&self) -> String {
        "Message".to_string()
    }
}

struct Card<'a, F>
where
    F: ?Sized + FnOnce() -> String,
{
    renderer: &'a F,
}

impl<'a, F> Card<'a, F>
where
    F: ?Sized + FnOnce() -> String,
{
    pub fn new(renderer: &'a F) -> Self {
        Self { renderer: renderer }
    }
    pub fn render(&self) -> String {
        (*self.renderer)() // コンパイルエラー
    }
}

struct App<'a> {
    presenter: Presenter,
    card: Card<'a, dyn FnOnce() -> String>,
}

impl<'a> App<'a> {
    pub fn new() -> Self {
        Self {
            presenter: Presenter,
            card: Card::new(&|| "".to_string()),
        }
    }
    pub fn setup(&mut self) {
        self.card = Card::new(&|| self.presenter.get()); // コンパイルエラー
    }
    pub fn update(&mut self) {
        println!("{:?}", self.card.render());
    }
}

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

### エラーメッセージ抜粋
```
error[E0161]: cannot move a value of type F: the size of F cannot be statically determined
  --> src/main.rs:24:9
   |
24 |         (*self.renderer)()
   |         ^^^^^^^^^^^^^^^^

error[E0507]: cannot move out of `*self.renderer` which is behind a shared reference
  --> src/main.rs:24:9
   |
24 |         (*self.renderer)()
   |         ^^^^^^^^^^^^^^^^ move occurs because `*self.renderer` has type `F`, which does not implement the `Copy` trait

error: lifetime may not live long enough
  --> src/main.rs:41:31
   |
40 |     pub fn setup(&mut self) {
   |                  - let's call the lifetime of this reference `'1`
41 |         self.card = Card::new(&|| self.presenter.get());
   |                               ^^^^^^^^^^^^^^^^^^^^^^^^ cast requires that `'1` must outlive `'static`

error[E0716]: temporary value dropped while borrowed
  --> src/main.rs:41:32
   |
33 | impl<'a> App<'a> {
   |      -- lifetime `'a` defined here
...
41 |         self.card = Card::new(&|| self.presenter.get());
   |         -----------------------^^^^^^^^^^^^^^^^^^^^^^^-
   |         |                      |
   |         |                      creates a temporary which is freed while still in use
   |         assignment requires that borrow lasts for `'a`
42 |     }
   |     - temporary value is freed at the end of this statement
```

ご回答のほどよろしくお願いいたします。

【Rust】クロージャ(ラムダ)に絡むコードがRubyなら簡単に動くがRustではコンパイルエラーになるのを解決したい。

### 実現したいこと

```go
func later() func(string) string {
	var store string
	return func(next string) string {
		a := store
		store = next
		return a

func main() {
	b := later()
	fmt.Println(b("あ"))  // => ""
	fmt.Println(b("い"))  // => "あ"
	fmt.Println(b("う"))  // => "い"
}
```

### 知りたいこと

このコードの場合、変数storeがクロージャに属する変数として何らかの形で参照され続ける限り破棄されないという性質を持っているということらしいのですが、どういう仕組みで上記のような結果になるのでしょうかご教授お願いします！



Goのクロージャの性質を理解できない

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

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

```
class a {
  
  function __construct( $contxt ) {
    $this->request_index_parameter = array(***):
    $this->sort( $this->request_index_parameter );
  }

  // ソート
  public function sort ( $param ) {
    uksort( $param, function ( $key1, $key2 ) {
      var_dump( $param );
    });
  }
}
```

↑のようなclassがあり、sort関数で受けた引数をもとにuksortを実行させたいのですがvar_dumpではnullになってしまいます。

■試した事
親のスコープの変数を参照するには無名関数（クロージャ）を使用すると良いという記述があってトライしてみましたが
期待した結果にはならず...

■備考
```ここに言語を入力
PHPver.5.3.3
```