（ @mlubinによると、これは関連する変更ですhttps://github.com/JuliaLang/julia/pull/19324）

Stefanは、この問題を解決する1つの可能性は、 letブロックでのREPLエントリの自動ラッピングであるとここで提案し

しかし、それはあなたがすることができなかったという点で混乱しませんか？

a = 1

その後aを使用しますか？ すべてのトップレベルの割り当てにglobalが挿入されていない限り、私は推測しますか？

動作は、すべてをletブロックでラップするだけではなく、それよりも複雑です。 式内で割り当てられているグローバルをlet-bindしてから、式の最後にあるglobalにlet-bound値を抽出する必要があります。

したがって、 a = 1をa = let a; a = 1; endようなものに変換します。 そして何かのような

for i in 1:2
    before = false
end

これに変わります：

before = let before = before
    for i in 1:2
        before = false
    end
end

率直に言って、私は人々が今このフィードバックをしているだけであることにかなり腹を立てています。 これは10ヶ月間マスターに変更がありました。

私は最近までマスターを非常に閉じてフォローしていなかった罪を犯しているので、このフィードバックは確かに少し遅れています。 プログラマーの懸念以上のもの（ほとんどのforループはライブラリコードの関数内にあります）これは教育の懸念ではないかと思います。 多くの場合、 forループは、関数またはスコープの前に教えられます（もちろん、何が起こっているのかを実際に理解するにはスコープを理解する必要がありますが、教える場合は単純化されることがよくあります）。

ここでは、関数やグローバル変数を説明せずに1から10までの数値を合計する方法を初心者に教えるのは少し難しくなります。

率直に言って、私は人々が今このフィードバックをしているだけであることにかなり腹を立てています。 これは10ヶ月間マスターに変更がありました。

公平を期すために、Julia0.7は13日前にリリースされました。 これは、ほとんどのJuliaユーザーにとって新しい変更です。

率直に言って、私は人々が今このフィードバックをしているだけであることにかなり腹を立てています。 これは変更が10ヶ月間マスターにありました

残念ながら、エッジでの生活を処理できない私たちにとっては、私たちの観点からはまったく新しいものです。

率直に言って、私は人々が今このフィードバックをしているだけであることにかなり腹を立てています。 これは10ヶ月間マスターに変更がありました。

そして、開発部門から離れることを奨励されてきた私たちにとって、「それは私たちの観点からはまったく新しいものです」。

人々がこれをテストしなければならなかった期間についてメタディスカッションをする代わりに、今目前の問題に焦点を合わせるために戻ってください。 今の状態ですので、楽しみにしましょう。

私は最近までマスターを非常に閉じてフォローしていなかった罪を犯しているので、このフィードバックは確かに少し遅れています。 プログラマーの懸念以上のもの（ほとんどのforループはライブラリコードの関数内にあります）これは教育の懸念ではないかと思います。 多くの場合、forループは関数またはスコープの前に教えられます（もちろん、何が起こっているのかを実際に理解するにはスコープを理解する必要がありますが、教える場合は単純化されることがよくあります）。

ここでは、関数やグローバル変数を説明せずに1から10までの数値を合計する方法を初心者に教えるのは少し難しくなります。

これが大きなポイントです。 問題が実際に何であるかを見つけた後、それが実際にほとんど現れないのは驚くべきことです。 野生およびテストでの多くのJuliaコードではそれほど問題ではなく、誤ってグローバルであった多くの変数が明らかになりました（元のPRによるJulia Baseの両方のテストで、ほとんどの場合にこれに気づきました。 DiffEqのテスト）。 ほとんどの場合、微妙に間違った動作は（ループの変更を期待して）得られるものではないようですが、ループで変数を使用できることを期待することは、私が大多数であることがわかったものですこれは、テストスクリプトをv1.0に更新するときに表示されます。 したがって、良い点は、ほとんどの場合、ユーザーにエラーが表示され、修正するのは難しくないということです。

悪い点は、ループ内にglobal xを配置する必要があるのは少し冗長であり、REPLコードも関数コードとは異なることです。 ハード/ソフトローカルスコープには確かにいくつかのエッジケースがあり、これは明らかに説明しやすいため、以前よりも直感的な動作であるかどうかは難しい意見です。 しかし同時に、以前の動作よりもはるかに簡潔な説明がありながら、スコープルールを理解することが重要なエッジケースに簡単に到達できるようになりました。 🤷‍♂️。

私はletブロッキングを使った実験を見たいと思っています。 これにより、「それほど多くのグローバルが必要ではなかった」という側面が維持され、スコープの説明が簡略化されると同時に、REPLコードが関数内部のように動作するようになります（これは私たちが常に望んでいたことのようです）。 または逆に、グローバルとして機能させたい変数を指定させる

global x = 5
for i = 1:5
  println(x+i)
end

明示性を維持するための優れた方法である可能性があり、「グローバルのためにREPLコードが遅い」ことがはるかに明白になります。 欠点は、関数に物を投げ込むのにglobalマーカーが必要ないことです。

しかし、これがどのように現れる傾向があるかを考えると、それは実際にはゲームブレイクやショートッパーではありません。 私はそれをどのワークショップでも言及されるべき疣贅として分類しますが、それが原因でv1.0が使用できないわけではありません。 ただし、この動作の変更が破損として分類されず、v2.0が必要になることを願っています。

REPLが関数内部のように動作する必要があるという考えが好きかどうかはわかりません。 明らかにそうではないので、グローバルスコープのように動作することを期待しています。 私にとって、グローバルスコープのように動作しないREPLは、この問題を引き起こす不一致よりもさらに混乱する可能性があります。

とにかく、少なくとも、ドキュメントはこの問題についてもう少し明確にすべきだと思います。 ドキュメントを何気なく読んでいると、デフォルトでグローバルスコープで動作が発生するようにするには、 localキーワードを使用する必要があると思います。

私はletブロッキングを使った実験を見たいと思っています。 これにより、「それほど多くのグローバルが必要ではなかった」という側面が維持され、スコープの説明が簡略化されると同時に、REPLコードが関数内部のように動作するようになります（これは私たちが常に望んでいたことのようです）。

「REPLは関数の内部と同じです」という場合は、 outerについても考慮する必要があります。

julia> i = 1
1

julia> for outer i = 1:10
       end
ERROR: syntax: no outer variable declaration exists for "for outer"

対：

julia> function f()
          i = 0
          for outer i = 1:10
          end
          return i
       end
f (generic function with 1 method)

julia> f()
10

率直に言って、私は人々が今このフィードバックをしているだけであることにかなり腹を立てています。 これは10ヶ月間マスターに変更がありました。

人々は、インタラクティブな使用や教育のためにマスターを使用していません。パッケージをアップグレードするためにマスターを使用しています。パッケージは、これによる影響が最小限であり、ほとんどが経験豊富なプログラマーによって作成されています。

（私は＃19324でフィードバックを提供した数少ない人の一人でしたが、古い振る舞いについて議論し

これを壊さない方法は、古い動作に戻すことです（理想的には、暗黙のletブロックなどを挿入するのではなく、オプションとしてjulia-syntax.scmの古いコードを復元するだけです）。 REPL。 むしろ、IJuliaのような環境で利用できるようにするには、 include 、 include_string 、およびCore.evalにsoft_global_scope=falseフラグを追加して復元します。古い振る舞い。

（私は＃19324でフィードバックを提供した数少ない人の一人でしたが、古い振る舞いについて議論しました。）

はい、とても感謝しています。 私たちが選んだので、今はそれほど重要ではありません、それを10ヶ月間焼いて、そして今、安定性への長期的なコミットメントでそれをリリースしました。 したがって、今やるべきことは、今後何をすべきかに焦点を当てることだけです。

古い動作と新しい動作のどちらかを選択できるオプションがあるのは興味深いことですが、非常にハッキーな感じがします。 つまり、誰もが信じられないほど混乱していると思われるスコープ動作が発生することがあるだけでなく、常にそれが存在するとは限らず、存在するかどうかはグローバルフラグに依存します。 それはかなり物足りない感じです、私は恐れています。

古い動作と新しい動作のどちらかを選択できるオプションがあるのは興味深いことですが、非常にハッキーな感じがします。

誰かが「unbreakme」ソフトスコープAST変換を実装すると、IJulia、OhMyREPLなどでそれを使用したくなるでしょう。その時点で、デフォルトのREPLが壊れていると見なされるというさらに問題のある状況になります。

それは私が言っていることではありません。 明らかに、これらすべてのコンテキストで同じソリューションを使用する必要があります。 ただし、スコープルールの2つの異なるバリエーションとして実装することは、1セットのスコープルールを使用してコード変換として実装するよりもクリーンではないようです。 しかし、おそらくそれらは機能的に同等です。 ただし、新しいより単純なスコープ規則と、REPLスタイルの入力を受け取り、それを評価する前に変換する変換の観点から説明する方が簡単なようです。

これは、モジュールに存在するグローバルがトップレベルの非関数スコープ内に割り当てられている場合、それらにグローバルとして自動的に注釈を付けることによって式を変換するMeta.globalize(m::Module, expr::Expr)として実行できます。 もちろん、これは古いパーサーが行ったことと同等だと思いますが、自分でMeta.globalize呼び出して、REPLが何を評価するかを確認できるため、もう少し透過的です。

これは、モジュールに存在するグローバルがトップレベルの非関数スコープ内に割り当てられている場合、それらにグローバルとして自動的に注釈を付けることによって式を変換するMeta.globalize(m::Module, expr::Expr)として実行できます。

私は実際に数分前にこのようなものを実装することを検討し始めました。 ただし、 julia-syntax.jlオプションとして実装する方がはるかに簡単なようです。

• 外部AST変換を作成することは可能ですが、多くのトリッキーなコーナーケースがあるようです—基本的にスコープルールを再実装する必要があります—一方で、 julia-syntax.scmそれを正しく行うためのコードはすでにあります。
• 現在include_stringを使用してコードのブロック全体を評価し、最後の式の値を取得するIJuliaのようなものでは、さらに注意が必要です。 式を式ごとに解析するように切り替える必要があるだけでなく、元の行番号を保持するために（エラーメッセージなどのために）いくつかのハッカーが必要になる場合があります。 （ただし、ここでも機能する可能性のある
• include外部ファイルがAST変換によって捕捉されないという人々の場合は言うまでもありません。

ただし、新しいより単純なスコープ規則と、REPLスタイルの入力を受け取り、それを評価する前に変換する変換の観点から説明する方が簡単なようです。

インタラクティブな使用や特定のフラグが付いたinclude場合、ルールの選択が難しいと言うよりも、これが新しいユーザーに説明しやすいのではないかと真剣に疑っています。

globalize(::Module, ast)実装の大まかなドラフトは次のとおりです： https ：

さて、行番号情報を保持するglobalize_include_string関数を実装する方法を理解し、それを私の要点に追加しました。

人々がこのアプローチを好む場合、可能な（非破壊的な）前進の方法：

1. globalizeなどの関数を含むSoftGlobalScope.jlパッケージをリリースします。
2. IJulia（および場合によってはJuno、vscode、OhMyREPL）でSoftGlobalScopeを使用します。
3. SoftGlobalScope関数をREPLstdlibパッケージの将来のリリースにフォールドし、REPLで使用します。

それとも、すぐにREPL.jlにロールインするのが実用的ですか？ 1.0でstdlibの更新がどのように機能するかについては完全にはわかりません。

壊れやすくなるようなものが欠けている場合に備えて、私の実装を見てください。

1.1のREPLのデフォルト以外の機能としてそれを使用することはできませんか？

＃28523と＃28750の複製。 グローバル変数について人々に教えたくないと言う人には、 forループする前に、まず関数を教えることをお勧めします。 とにかく関数はより基本的であり、これはコードが関数で書かれるべきであるという期待を設定するのに役立ちます。 不便さは理解していますが、このスコーピング動作は教育学的な利点に変わる可能性があります。「実際、グローバル変数は、特にループで使用する場合は非常に悪い考えであるため、言語を使用するために後ろ向きに曲がります。」

このためにデフォルト以外の機能をREPLに追加することは、私には問題ないようです。

@JeffBezanson 、私たちの多くは、線形代数や統計などの技術コースで、Matlabなどの代わりにJuliaを使用したいと考えていることを忘れないでください。 これらはプログラミングコースではなく、学生はプログラミングのバックグラウンドを持っていないことがよくあります。 構造化プログラミングを行うことはありません。ほとんどすべてが短いスニペットとグローバル変数を使用してインタラクティブです。

さらに、私が最初に動的言語を使用している理由は、インタラクティブな探索とより統制のとれたプログラミングを流動的に切り替えるためです。 グローバルコンテキストと関数コンテキストで同じコードを使用できないことは、概念のスコープに慣れている人にとっても、その目的を妨げるものであり、CS以外のバックグラウンドを持つ学生にとってはさらに悪いことです。

私たちの多くは、線形代数や統計などの技術コースで、Matlabなどの代わりにJuliaを使用したいと考えていることを忘れないでください。 これらはプログラミングコースではなく、学生はプログラミングのバックグラウンドを持っていないことがよくあります。 構造化プログラミングを行うことはありません。ほとんどすべてが短いスニペットとグローバル変数を使用してインタラクティブです。

私たちJuliaユーザーの多くは（私を含めて）CSのバックグラウンドがまったくありませんが、適切な態度（特に学生にとって）は、私たちのナイーブに対応するために状況を悪化させることを要求するのではなく、学ぶ意欲があるようです。

さて、私はここで何が起こっているのかについての理解が限られているので、この特定の変更が悪化することを必ずしも意味していませんが、これが重大な複雑さであるか、不必要に書くのが過度に簡単になる場合パフォーマンスの悪いコードは、より良い講義例を得るために変更を加える価値がないようです。 物理法則を変更して、新入生に示す静電気の例を実際の生活により適したものにすることはできません。

したがって、パフォーマンスも気にする非CSユーザーとしての私の質問は、これがデフォルトの動作にされた場合、どのように失敗する可能性があるかということです。 問題があるのは文字通りここで見ている種類の例だけですか（私はすでに知っていました）、それとももっと微妙な方法でこれをひどく台無しにする可能性がありますか？

価値のあることとして、コードを囲むスコープに応じて異なる動作をすることは、一般的に望ましくない機能であることに同意します。

コードをインタラクティブに書くのを難しくし、最初のループを書く初心者にあいまいなスコープ規則を理解させ、関数から貼り付けたコードをグローバルスコープで機能させないようにすることは、プログラマーが関数で高速コードを書くのに役立ちません。 ジュリアをインタラクティブに使用するのが難しくなり、初心者にとっては難しくなります。

1.1のREPLのデフォルト以外の機能としてそれを使用することはできませんか？

「unbreakme」オプションをデフォルトにする方が賢明なようです。特に、初心者ユーザーを真っ向から狙うオプションです。 それがデフォルト以外のオプションである場合、正確にそれを最も必要とする人々は、それを有効にしていない（そしてそれが存在することを知らない）人々です。

提案されたREPLモードはinclude edスクリプトに何をしますか？ グローバルステートメントの評価は、REPLモードがアクティブになっているかどうかによって異なりますか？ もしそうなら、IMOこれは1.0の安定性の約束と対立するでしょう。

このようなことをした場合、モジュールがどのように機能するかを判断するのは理にかなっているようです。 したがって、 Mainは「ソフトスコープ」モジュールになりますが、デフォルトでは他のモジュールは「ハードスコープ」モジュールになります。

@stevengjのglobalize関数を使用するようにREPLにモンキーパッチを適用することが可能かどうかを確認することに興味がありましたが、あまり労力をかけなくてもよいようです（かなりハッキーですが）。 要旨をご覧ください。 これは、Juno（またはCore.eval直接呼び出す他のもの）では機能しません。

これを人々に勧めるつもりはありませんが、迅速で汚いデータ分析を行うときに非常に役立ちます。 関数からREPLにコードをコピーして貼り付けて表示できない場合、経験の浅い、しばしば消極的なコーダー（つまり、私の学生）にとっては非常に混乱するため、（よりよく考えられた）ソリューションを非常に望んでいます。それが何をするのか、またその逆も同様です。

julia> a = 0                                                                
0                                                                           

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  
ERROR: UndefVarError: a not defined                                         
Stacktrace:                                                                 
 [1] top-level scope at .\REPL[2]:2 [inlined]                               
 [2] top-level scope at .\none:0                                            

julia> using SoftGlobalScope                                                
[ Info: Precompiling SoftGlobalScope [363c7d7e-a618-11e8-01c4-4f22c151e122] 

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  

julia> a                                                                    
55                                                                          

（ところで：上記はそれが持っていたのとほぼ同じくらいのテストです！）

提案されたREPLモードは含まれているスクリプトに対して何をしますか？

何もない。 基本的に、これはインタラクティブなプロンプトで入力されたコードに対してのみであるという提案です。 ファイルに物を入れ始めるとすぐに、「ハードスコープ」ルールを学ぶ必要があります。 うまくいけば、コードをファイルに入れ始めるときは、関数の使用を開始する必要があります。

プロンプトよりもファイル内のグローバルコードのスコープルールが厳しくなるのは理想的ではありません。 しかし、＃19324とJulia 1.0の安定性の約束を組み合わせると、理想的な選択肢がなくなると思います。

@stevengj ：

@JeffBezanson 、私たちの多くは、線形代数や統計などの技術コースで、Matlabなどの代わりにJuliaを使用したいと考えていることを忘れないでください。 これらはプログラミングコースではなく、学生はプログラミングのバックグラウンドを持っていないことがよくあります。 構造化プログラミングを行うことはありません。ほとんどすべてが短いスニペットとグローバル変数を使用してインタラクティブです。

Matlab / R / ...に以前に触れたことのある学生に、Juliaを使用してコースを教えたことがあるので、この懸念に共感します。 しかし同時に、JuliaをMatlabなどの代替として使用することは実行可能なアプローチではないと思います。DiscourseとStackOverflowに関する質問で何度も示されているように、これは修正と理解が難しいパフォーマンスの落とし穴につながる可能性があります。 Juliaがこれらの他の言語とどのように異なるかを理解するために投資するよりもさらに大きなコストがかかる可能性があります（「このコードをMatlabから翻訳したが、10倍遅い」というトピックの投稿を参照）。

重要な問題はサイレント障害だと思います。 問題自体は理解しやすく、修正も簡単です。 新しい動作を維持することをお勧めしますが、 Main警告を表示します（デフォルトでは、無効にできるはずです）。

私にとって、より大きな問題は、知覚される矛盾です。 つまり、私はジュリアが別の方法で物事を行うことに問題はありませんが、次のようになります。

• 関数から貼り付けたコードがREPLで機能しないのはなぜですか？
• 私が今まで使用した他の言語にはこの動作がありません、そしてそれは採用へのもう一つの障壁です
• forブロックがbeginおよびifブロックと異なる動作をするのはなぜですか？ （ if私はある程度理解していますが、ブロックは[あるべき]ブロックです。）

箇条書き2に関しては、これは、ジュリアをしばらく使用している（そして言語に取り組んでいる）私たちが理解できるよりも大きな問題だと思います。 私のグループにJuliaでコードを書くよう説得することで、私は現在0対7であると言えます。 そのうちの2つは、このforループの問題が原因でしたが、これまでに触れたことがなかったため、説明できませんでした。 残りの部分は、カリスマ性の欠如にチョークで書くことができると思います。

私の好みは、関数からREPLに貼り付けられたコードが関数と同じように動作し、 forループを使用してデータをインタラクティブに分析するときに期待どおりの動作をするようにすることです。 つまり、特別なキーワードなしで指示された場合、外部/グローバル変数を変更します。

ジュリアをMatlabなどの代替として使用することは実行可能なアプローチではないと思います。DiscourseとStackOverflowに関する質問で何度も示されているように、これは修正と理解が困難なパフォーマンスの落とし穴につながる可能性があり、さらに大きなコストがかかる可能性がありますジュリアがこれらの他の言語とどのように違うかを理解することに投資するよりも。

申し訳ありませんが、この議論は私にはばかげています。 私がプログラミングを教えているクラスについて話しているのではありません。 単純な対話型計算の場所があり、CS以外のクラスでは、最初に「栄光の計算機」としてプログラミング言語を紹介するのが一般的です。 Juliaでパフォーマンスコンピューティングを教えることはまったく異なるプロセスですが、すでにJuliaを「計算機」として使用している場合でも問題はありません。

学生に「計算機」としてMatlabを紹介することから始める場合、彼らの最初の本能は船に飛び乗る前にMatlabで可能な限り多くのことを行うことであり、その時点で彼らの悪い習慣があるため、「実際の」プログラミングに移行することははるかに困難です。彼らは根付いており、新しい言語を学ぶことに消極的です。 対照的に、栄光の計算機としてJuliaから始める場合、より本格的なプログラミングを行うときは、はるかに幅広いオプションを利用できます。 すべてを「ベクトル」操作に詰め込むようにトレーニングしたり、正しく実行する前にひどいことを強制したりする必要はありません。

線形代数のコースでジュリアを使うべきではないと言っているのですか？ それとも、線形代数だけでなくコンピュータサイエンスを教える準備ができている場合にのみ使用する必要がありますか？

私は@stevengjに、問題（プログラマー以外の人への指導がはるかに難しくなる）と解決策（REPLとさまざまなIDEで機能するようにする）の両方に同意します。 スクリプトを含めると、Julia 1.0のスコープ規則が適用されますが、それほど心配する必要はありません。「forループを関数に入れてから、関数を呼び出すことができます」クラスを「置くことができる」の前に置くように注意する必要があります。ファイル内のforループと、file "クラスを含めます。

これは、REPLでのインタラクティブなデバッグが必要以上に苦痛にならない（または新しいユーザーを混乱させる）ので、良い妥協のように聞こえますが、スクリプトの通常のコードは厳密なスコープルールに従う必要があり、バグが一部を上書きすることはありません。誤って変数。

線形代数のコースでジュリアを使うべきではないと言っているのですか？ それとも、線形代数だけでなくコンピュータサイエンスを教える準備ができている場合にのみ使用する必要がありますか？

あなたは私が言っていることを誤解しているかもしれません（または私はそれを明確に表現していませんでした）。 私は、CSコース（私が経験したことのない）ではなく、ジュリアを使用してドメイン固有の何かを教えるコース（たとえば、大学院生に数値的方法を教えた）について話していました。

私が言いたかったのは、Juliaと言語X（Matlabの場合もある）の間にある程度の違いがあると予想するのは合理的であるということです。 逆に、これを無視すると問題が発生する可能性があります（実際に発生します）。

個人的に、新しい言語を学ぶとき、私はこれらの問題に早い段階で直面することを好みます。 また、長期的には、他の言語との類似性よりも、言語セマンティクスの単純さと一貫性の方が重要だと思います。 しかし、私はこれらの好みを主観的なものとして認識しており、合理的な人々は異なるものを持つことができます。

（未登録の）パッケージhttps://github.com/stevengj/SoftGlobalScope.jlを作成しました

これが妥当と思われる場合は、先に進んでパッケージを登録し、デフォルトでIJuliaで使用できます（おそらく、JunoなどにPRを送信します）。

私が言いたかったのは、Juliaと言語X（Matlabの可能性がある）の間にある程度の違いを期待するのは合理的であるということです。

明らかに。 「Matlabの代わりにJuliaを使用する」と言っても、JuliaでMatlab構文を教えようとしているわけではなく、以前のMatlabユーザーを特に対象としているわけでもありません。

私はこれらの問題に早い段階で直面することを好みます

Matlab自体との違いについてではありません。 CS以外の学生の前で初めてループを作成するとき、またはCS以外の学生からコードを初めて貼り付けるときは、グローバルスコープとローカルスコープ、および静的分析のためのglobalキーワードの有用性については話したくありません。 REPLに機能して、インタラクティブに試してください。 ループを使って表現しようとしている数学に焦点を当てたいと思います。

Matlabユーザーが期待しているという理由だけで、ここでは誰もソフトインタラクティブスコープについて議論していません。 、「スコープ」のなじみのない概念への長いを狂わせることため、私たちはそれを主張しています。 （経験豊富なユーザーでも、インタラクティブに作業しているときにglobalキーワードを追加しなければならないのはかなり不便です。）

ここで言及されていないもう1つの修正は、「for」でスコープブロックを定義するのをやめることです（関数だけで新しいスコープを作成できます）

@vtjnash 、私はむしろこの議論を前にできること

良い点ですが、これにもimport Future.scope必要です😀

（このモジュール/名前空間/行動効果はすでに予約されている/存在していると思います）

ここでの注意点として、変更は、そのモジュールで以前に評価されたものに関係なく、すべてのグローバルスコープ環境でコードが同じように動作することを保証することでした。 この変更の前は、同じコードを2回実行するか、ファイル内で移動するだけで、（スコープの割り当てが異なるために）まったく異なる回答を得ることができました。

この変更の前は、同じコードを2回実行するか、ファイル内で移動するだけで、（スコープの割り当てが異なるために）まったく異なる回答を得ることができました。

実際にそれについて私が見た苦情の数（ゼロ）は、現在の行動についてあなたが見る（そしてすでに見ている）苦情と混乱の数によって確実に矮小化されています。

この変更の前は、同じコードを2回実行するだけで、（スコープの割り当てが異なるために）まったく異なる回答を得ることができました。

以下のコードで、 aが最初のforループと2番目の

a = 0
for i = 1:5
  a += 1
end

for i = 1:5
  a += 1
end

提案されたREPLモードは含まれているスクリプトに対して何をしますか？

@ mauro3 @stevengj関数（たとえば、 exec("path/to/script.jl") ）の追加は、マイナーバージョンのバンプだけで実行できると思いますか？ また、 exec 'edスクリプトから別のファイルをexec 'に警告し、そこにいくつかの教育メッセージを入れて、 includeを使用するように促すこともできます。

昨夜、この問題に頭を悩ませながら（もう一度）、最善の行動方針を見つけようとして書き留めた考えがいくつかあります。 結論はありませんが、これは問題を非常に明確に示していると思います。 この問題について数年間考えた後、「理想的な解決策」はないと思います。これは、最適ではない選択肢しかない問題の1つである可能性があります。

人々は、グローバルスコープをローカルスコープを囲む面白い種類として素朴に見ています。 これが、グローバルスコープがJulia0.6以前と同じように機能した理由です。

• 外部ローカルスコープがローカル変数を作成し、内部ローカルスコープがそれに割り当てた場合、その割り当てによって外部ローカル変数が更新されます。
• 外部グローバルスコープがグローバル変数を作成し、内部ローカルスコープがそれに割り当てる場合、その割り当ては以前に外部グローバル変数を更新しました。

ただし、主な違いは次のとおりです。

• 設計上、外部ローカル変数が存在するかどうかは、外部ローカルスコープ内の式の出現順序や実行に依存しません。
• ただし、グローバル変数が存在するかどうかは、グローバルスコープで式を一度に1つずつ評価するため、順序に依存することはできません。

さらに、グローバルスコープは非常に長いことが多く、複数のファイルにまたがることはめったにありません。式の意味が他の式に依存しているため、式から任意の距離にあると、「離れた場所での不気味なアクション」効果になり、非常に望ましくありません。 。

この最後の観察結果は、グローバルスコープでforループの2つの異なるバージョンが異なる動作をする理由を示しています。

# file1.jl
for i = 1:5
  a += 1
end

# file2.jl
a = 1



md5-f03fb9fa19e36e95f6b80b96bac9811e



```jl
# main.jl
include("file1.jl")
include("file2.jl")
include("file3.jl")

また、 file1.jlとfile3.jlは同一であり、毎回異なる意味と動作で同じファイルを2回含めることで、例を簡略化できることにも注意してください。

もう1つの問題のあるケースは、長時間実行されるREPLセッションです。 オンラインのどこかから例を試してみませんか？ この例でforループまたは同様の構造のローカル変数に使用しているのと同じ名前のグローバル変数があるため、失敗します。 したがって、混乱を引き起こす可能性があるのは新しい動作だけであるという考えは、間違いなく正確ではありません。 新しい動作がREPLのユーザビリティの問題であることに同意しますが、会話を和らげ、ここで反対側を明確に提示したいと思います。

私の小さな提案は、replの問題を扱っていませんが、言語を非対話的に教えるときに教訓的な目的に役立ちます。少なくとも、Fortranで実行できるように「program」という名前のメインブロックを定義します（これは上記の「let ... end」と同じですが、より自然な表記があります）：

プログラムテスト
..。
終わり

スコープの詳細に立ち入ることなく言語を教え、最終的にその点について話し合うことしかできませんでした。

もう1つの問題のあるケースは、長時間実行されるREPLセッションです。 オンラインのどこかから例を試してみませんか？ この例でforループまたは同様の構造のローカル変数に使用しているのと同じ名前のグローバル変数があるため、失敗します。

動揺しているユーザーから、これに関してメーリングリストの苦情やgithubの問題がいくつ提出されていますか？ ゼロ、私の数では。 どうして？ おそらく、この振る舞いは基本的に人々ないためです。グローバルスコープで作業する場合は、グローバルな状態に依存します。

したがって、混乱を引き起こす可能性があるのは新しい動作だけであるという考えは、間違いなく正確ではありません。

これは誤った等価関係だと思います—ここでは潜在的な混乱のレベルに大きな違いがあります。 Julia 0.6では、あなたの例を数秒で生徒に説明できます。「ああ、このループはここで変更したaに依存しているのを見てください。」 Julia 1.0では、線形代数の講義の最中に、単語を聞いたことがない学生の前で不思議なことにglobalキーワードを入力しなければならない場合、どうなるかを正直に心配しています。 CSの意味での「スコープ」。

数年以内にスコープルールを変更することを真剣に検討する必要があります。

絶対違う。 ループスコープのv0.2より前の世界（＃1571と＃330を参照）に真剣に戻りたいですか？

実際、関数から行ごとのREPLへのコードのコピーと貼り付けを完全にサポートしたことはありません。 したがって、これをそれを機能させる機会と見なすことができます。 具体的には、 forループでは「機能」しましたが、内部関数では機能しませんでした。

x = 0
f(y) = (x=y)

関数内で、 fは最初の行からxを変更します。 REPLではそうではありません。 しかし、SoftGlobalScope.jlのような変換を使用すると、機能する可能性があります。 もちろん、スタンドアロンの関数定義を貼り付けることは機能しないため、デフォルトではオンにしたくないでしょう。 最初に頭に浮かぶのは、行ごとの関数デバッグのためのREPLモードです。

v0.2より前の世界に真剣に戻りたいですか？

いいえ、0.6の世界に戻りたいです。 😉

私はもっ​​と反応していたと思います：

ここで言及されていないもう1つの修正は、スコープブロックを定義するための「for」の作成を単に停止することです。

実際、関数から行ごとのREPLへのコードのコピーと貼り付けを完全にサポートしたことはありません。 したがって、これをそれを機能させる機会と見なすことができます。

私はこの感情に非常に感謝しており、私のユースケースにとっては本当に役に立ちます。 私の見解では、言語のスコープ規則を直接変更するのではなく、REPLを可能な限り有用にすることが重要です。

とは言うものの、この問題について考えれば考えるほど、REPLが何をすべきかについて私が（個人的に）抱いている矛盾する見解を見るようになります。

具体的には、REPLが関数本体のスコープ規則と一致していれば非常に気に入っています。 つまり、変数はグローバルではなくローカルであり、関数から直接コードをコピーして貼り付けるだけで、それが機能することがわかります。 ナイーブな実装は、フォームのlet-blockラッピング（前述のとおり）のようなものになると思います

julia> b = a + 1

に変換されています

let a = _vars[:a]::Float64 # extract the variables used from the backing store
    # Code from the REPL
    b = a + 1
    # Save assigned variables back to the backing store
   _vars[:b] = b
end

適切に（つまり、彼らが何をしているのかを知っている誰かによって）行われると、これは既存のREPLよりも多くの利点があると思います。 1.インタラクティブなデータ分析/計算を使用した以前のワークフローは正常に機能します。 2.基本的な応答が「グローバル変数によるベンチマークを停止する」であるDiscourseへの投稿がはるかに少ない-すべてがローカルであり、うまくいけば高速です！ :) 3.関数本体との間のコピーアンドペーストは、期待どおりに機能します。 4.バッキングストアがある種のDictである場合、 workspace()ような関数は簡単です。 ただそれを片付けなさい。 5.グローバルは明示的になります-特にグローバルであるように要求しない限り、物事はローカルです。 これは私の観点からは大きな利点です。暗黙的にグローバルを作成するのは好きではありません。 非常にマイナーな最後のポイント（そしてこれを追加することを躊躇します！）、これはMatlabの動作と一致し、移行を容易にします-Matlab REPLでは、グローバルとして明示的に注釈が付けられていない限り、すべての変数がローカルのように見えます。

数時間前まで、この話は私には素晴らしいと思いました。 しかし、関数についてのJeffのコメントの後、スタンドアロンの関数定義に貼り付けることと、関数定義はグローバルスコープに入る必要があるため、このアプローチが基本的にそれをどのように防ぐかについて考えました（少なくとも、それはおそらく意図されたものです）。 しかし、それらがローカルスコープ（内部関数）に入ることいた場合はどうなるでしょうか？ 2つの可能性を明確にするための情報はありません。 2つのREPLモードが必要であるように思われます。1つはローカルスコープ、もう1つはグローバルスコープです。 一方では非常に混乱する可能性がありますが（談話の投稿を想像してください...）、他方では非常に役立つ可能性があります。 （新しい機能を導入しているだけなので、両方のREPLモードを使用しても問題はありません:)）

SoftGlobalScope.jlの中間の家に行くことは、最も混乱の少ない妥協案になるかもしれませんが、私の心配は、それが覚えておくべき別のルールのセットにすぎないことです（これはREPLで機能しますが、関数本体/グローバルスコープでは機能しません。逆に）。

長い投稿をお詫びしますが、これは使いやすさにとって重要だと思います（そしてそれは私がそれを熟考するのに役立ちました！）。

動揺しているユーザーから、これに関してメーリングリストの苦情やgithubの問題がいくつ提出されていますか？ ゼロ、私の数では。 どうして？ おそらく、この振る舞いは基本的に人々にとって驚くべきことではないためです。グローバルスコープで作業する場合は、グローバルな状態に依存します。

うーん、あなたは本当にこれについて体系的な研究をしましたか？ 私はそれを逃したに違いない。 それでも、これは、この動作がバグや予期しない結果の原因ではないことを意味するものではありません。 ユーザーがそれを理解した後、それは正しい動作として認識されたため、問題/苦情を促しませんでした。

Julia 1.0では、線形代数の講義の最中に、グローバルキーワードを不思議に入力しなければならない場合にどうするかを正直に心配しています。

私はこの問題に同情します。 コースに必要なeconの学生に簡単なプログラミングを教えたとき、私は通常、関数でコードをラップし、 functionとendをコメントアウトして実行することを行ったり来たりすることを提案しました。グローバルスコープで、彼らは何が起こっているのかを調べることができます。 これは、当時のJuliaでのデバッグインフラストラクチャの欠如をほぼ埋め合わせました。

このアプローチはもはや実行可能ではないようです。 しかし、とにかくそれが本当に正しい方法だったのだろうかと思います。その間に、さまざまなことが大幅に改善されました（＃265が修正され、 Revise.jlと最近Rebugger.jによってワークフロー/デバッグが大幅に改善されました）。

この問題は経験豊富なユーザーをあまり気にしないようです。主な懸念は教育環境での混乱です。 私はまだこれを実験していませんが、代わりに教育へのアプローチを適応させることができるかどうか疑問に思います。たとえば、ループの前に関数を導入し、グローバルスコープでループを回避します。 これらはとにかく良いスタイルの要素であり、学生に利益をもたらすでしょう。

ちょっとした注意：REPLのグローバルスコープを特別に大文字にすると、関数との間でコードをコピーして貼り付けることができますが、別のモジュールのグローバルスコープとの間でコピーを貼り付けることはできません。

代わりに、ループの前に関数を導入したり、グローバルスコープでループを回避したりするなど、教育へのアプローチを適応させることができるでしょうか。

これは、プログラミングの指導に焦点を当てていないクラスではまったく実用的ではありません。 インタラクティブに使用できない場合や、最初にすべての関数を作成する必要がある場合は、クラスでJuliaを使用しない方がよいでしょう。

（そして、それは教育的なだけではありません。グローバルスコープのループはインタラクティブな作業に役立ちます。テクニカルコンピューティング用の動的言語が好きな主な理由の1つは、インタラクティブな探索のための機能です。すべてのコーディングがパフォーマンス指向であるとは限りません。）

何十年にもわたって、人々が古い「ソフト/ハードスコープ」の区別について混乱したり不平を言ったりするスレッドや問題が数十あります。したがって、古い動作について誰も混乱したり不平を言ったりしたことがないと主張するのは...違います。 私はそれらのいくつかを掘り起こすことができましたが、あなたは@stevengjの周りにいたので、あなたはそれらを同じように簡単に掘り起こすことができ、あなたがこれらの不満や会話に気づかなかったか覚えていなかったとは信じられません。

@StefanKarpinski 、私は特に、グローバルループがグローバル状態に依存していると不平を言っている人々に言及しています。 これが悪い行動だったと不平を言った人は誰も覚えていませんし、その例も見つかりません。

割り当てが新しい変数を定義する時期と場所について人々が混乱していることに同意しますが、通常は逆の方向にあります。ローカルスコープが（その逆ではなく）よりグローバルに動作すること、またはbegin区別しないことを望んでいlet 。 IIRC、不満は、グローバルループ内のグローバル変数への割り当てがグローバルを変更するという驚くべき副作用を持っているということではありませんでした。

スコーピングの問題全体は、新しいユーザーを混乱させるものであり、今後もそうなり続けるでしょう。 しかし、紛らわしい部分は、グローバル変数名への割り当てがグローバル状態に影響を与える場合ではありませんでした。 現在の動作はこれを悪化させますが、良くはありません。

@StefanKarpinski ：以前は、ソフト/ハードスコープとの混同は、（予期しない結果を得る人々の）実際的なものではなく、（マニュアルを読む人々の）理論的な性質であったと感じています。 それは間違いなく私にとってのことであり、たとえば、ここでの検索結果た。

一方、この新しい動作は、マニュアルを読むときではなく、REPLを使用するときに人々を混乱させることはありません。 おそらく後者の方が悪いです。

SoftGlobalScope.jlが登録済みパッケージになりました。 私の意図は、少なくとも今学期は、IJuliaでデフォルトで有効にする（オプトアウトする）ことです。

@ mauro3 、あなたの「反例」でさえ、ソフトスコープではなくハードスコープによって混乱している誰かについてです。 0.7でより多くのスコープを「ハード」にすることは、この種の混乱をさらに引き起こすことは確実です。

IJuliaには、デフォルトで変数をローカルdoブロックにするという興味深い可能性があることを指摘しておきます。 つまり、これを1つのブロックで行うと、次のように機能します。

t = 0
for i = 1:n
    t += i
end
t

...そしてtは、この評価ブロック内でのみ表示されます。 外に表示したい場合は、次のようにする必要があります。

global t = 0
for i = 1:n
    global t += i
end
t

また、ブロックがモジュールではなくファイルであるJuliaの同様のアプローチも検討しました。 つまり、トップスコープでt = 0を実行するだけで、グローバルではなくファイルローカルの変数が作成されます。 真のグローバル変数を宣言するには、 global t = 0を記述する必要があります。これは、モジュール全体で表示されます。 おそらくあまりにも奇妙ですが、それは何年にもわたって何度も私に起こりました。

IJuliaには、変数をデフォルトでローカルdoブロックにするという興味深い可能性があります

@StefanKarpinski 、これはさらに混乱を招き、ノートブックの通常の使用方法に反すると思います。 同じ変数が複数のセルで使用/変更されることは一般的であるため、すべてのセル間変数にglobalキーワードを要求することは、私にとっては初心者ではありません。問題よりもスコープの概念についてさらに多くの議論が必要になります。ここで説明してきたforループを使用します。

私たち全員が同意する限り---私たちがそう思われるように---これはほとんどまたは完全に相互作用の問題であると私は思います、そして私たちは前進する方法があります。 これをREPLで特別な場合（IJuliaで行われているように）、唯一の悪いケースは、REPLで何かを開発し、それをトップレベルのスクリプトコードに移動することです。 おそらくそれが関数を導入すべきポイントなので、それほど悪くはないと思います。 REPLと関数本体の間でコードをコピーして貼り付けることは（ほとんど）機能しますが、これでおそらく十分です。

次に、REPL変数を何らかの方法でREPLに対してローカルにすることで、区別をさらに正当化/明確化するオプションもあります。つまり、通常のグローバル変数ではなく、 Main.xとして使用できません。 これは、 @ StefanKarpinskiが上記で提案したものと非常に似てい

実用的な観点から、REPLでこれを「修正」することはできません
教育/プログラマー以外のユーザーにとってのみ重要です。 この振る舞いも
（パーツをコピーして貼り付けることにより）REPLを介したインタラクティブなデバッグを非常に行います
実用的ではありません。 このデバッグモードが望ましい場合があります（
優れたデバッガーと）経験豊富なプログラマーにとっても（そして多くの場合、
動的言語を好む理由）。 もちろん経験者のために
プログラマーは、オプションであることは問題ではありません。 初心者ユーザーの場合は
できればデフォルトです。

@StefanKarpinski
素朴なプログラマーとして、私は実際に何がそんなに悪いのかわかりません。
特に動的な場合に、ローカルスコープを囲む面白い種類としてのグローバルスコープ
言語。 コンパイラの観点からはそうではないことを私は理解しています
必然的に正しい（ジュリアで）が、それは素晴らしく、簡単で便利なモデルです
（ナイーブな）プログラマーのために。 （私はそれが実際にそのように実装されているかもしれないと思う
一部の言語）。
ジュリアはまた、それをプログラマーにそのように提示しているようです。
次の関数関数は、「定義されていません」というエラーを出します。
forループの前にa = 1が設定されている場合は、実行されません。

機能テスト（）
i = 1:10の場合
a = a + i
終わり
a = 1
@show a
終わり

これは、私が完全に誤解しない限り、「
外側のローカル変数は、設計上、次の順序に依存しません。
外側のローカルスコープでの式の出現または実行」。

私は「遠隔作用」を避けることに非常に同意します。
関数/呼び出しスタックでグローバルを使用するための明示的な定義を優先する
レベルであり、個人的にはファイルからロードするようなものが欲しい
独自のスコープであり、グローバル変数を使用するための明示的な定義が必要です。
ループのレベルでは、私にとっては少し遠いですが、
定義/コンテキストは通常​​、かなり近いです。
3つのファイルの例は少し不自然です（そして期待される「ではない」で失敗します
定義済み」エラー）：通常、最初の定義を同じものに入れます
ファイル。
これには実際に不気味な危険があります（そして私はそれに噛まれました
他の言語で）インクルードはグローバルスコープで実行されるため、
他の人に干渉する可能性のあるグローバル変数を誤って定義している
コード。 ただし、ループでグローバルを使用する必要があることは、
この問題。

長時間実行されるREPLセッションへの書き込み：
現在の動作は、非常にまれで簡単に特定できる障害モードに置き換わるものです。
REPLでオンラインの例を実行するため（コピー/貼り付けを見逃している
ループの前の変数の初期定義であり、すでに
以前のものからグローバルに定義された同じ変数）
関数の一部である場合、オンラインの例を正しく実行できます
（どこにでもグローバルを追加せずに）、問題が解決しない場合
そうではありません（グローバルがオンラインコードにすでに存在する場合でも、
既存のグローバル変数の値が間違っています）

私はもっ​​と早くこれに耳を傾けるべきでしたが、少し心配した後、すべてが順調に見えます。

実際、関数から行ごとのREPLへのコードのコピーと貼り付けを完全にサポートしたことはありません...最初に頭に浮かぶのは、行ごとの関数デバッグ用のREPLモードです。

実際、Rebugger（まさにそれです）は、スコープの非推奨である0.7がなく、0.6で動作させることができなかったという理由だけで、1.0で正しく動作します。 ただし、SoftGlobalScope.jlがそれを壊していないように見えることを確認できてうれしいです。 たとえば、 show([1,2,4])十分深く踏み込むと、次のようになります。

show_delim_array(io::IO, itr::Union{SimpleVector, AbstractArray}, op, delim, cl, delim_one) in Base at show.jl:649
  io = IOContext(Base.TTY(RawFD(0x0000000d) open, 0 bytes waiting))
  itr = [1, 2, 4]
  op = [
  delim = ,
  cl = ]
  delim_one = false
  i1 = 1
  l = 3
rebug> eval(softscope(Main, :(<strong i="10">@eval</strong> Base let (io, itr, op, delim, cl, delim_one, i1, l) = Main.Rebugger.getstored("bbf69398-aac5-11e8-1427-0158b103a88c")
       begin
           print(io, op)
           if !(show_circular(io, itr))
               recur_io = IOContext(io, :SHOWN_SET => itr)
               if !(haskey(io, :compact))
                   recur_io = IOContext(recur_io, :compact => true)
               end
               first = true
               i = i1
               if l >= i1
                   while true
                       if !(isassigned(itr, i))
                           print(io, undef_ref_str)
                       else
                           x = itr[i]
                           show(recur_io, x)
                       end
                       i += 1
                       if i > l
                           delim_one && (first && print(io, delim))
                           break
                       end
                       first = false
                       print(io, delim)
                       print(io, ' ')
                   end
               end
           end
           print(io, cl)
       end
       end)))
[1, 2, 4]

したがって、1.0では正常に動作します（ softscope有無にかかわらず）。 0.7では、これを評価すると（ softscope有無にかかわらず）、次のようになります。

┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
[ERROR: invalid redefinition of constant first
Stacktrace:
 [1] top-level scope at ./REBUG:9 [inlined]
 [2] top-level scope at ./none:0
 [3] eval(::Module, ::Any) at ./boot.jl:319
 [4] top-level scope at none:0
 [5] eval at ./boot.jl:319 [inlined]
 [6] eval(::Expr) at ./client.jl:399
 [7] top-level scope at none:0

したがって、0.7 / 1.0は間違いなく一歩前進であり、 softscopeすると、重要な機能を壊すことなく特定の作業が簡単になります。

したがって、最大の懸念は、他のパッケージをタンキングせずにこれを適切にインターセプトする方法です（https://github.com/stevengj/SoftGlobalScope.jl/issues/2）。

@ timholy 、SoftScopeはマクロ呼び出しの引数に触れないため（マクロがどのようにそれを書き換えるかを知る方法がないため）、 :(<strong i="6">@eval</strong> ...)は保護されます。

「かどうか
外側のローカル変数は、設計上、次の順序に依存しません。
外側のローカルスコープでの式の出現または実行」。

（外部）ローカル変数a存在しますが、まだ割り当てられていません。 ループがそれを読み取る前にaに割り当てようとした場合、割り当ては外部にも表示されます。

一般に、変数バインディングの作成とそれに値を割り当てることは別々のステップです。

これのタイムラインは何ですか？ ユーザーの使いやすさが大幅に向上するようです。 そして、1.0が出たJuliaのこの「重要な」時期に、この修正されたできるだけ早く（上記のJeffによって提案された方法で）取得し、新しいJuliaバージョンまたはREPLバージョンにタグを付けることが有利であるように思われます。 （私は確かにこれを修正しないので、このアームチェアのコメントは申し訳ありません！）

@ジェフベザンソン
これは（実装/コンパイラーにとって）真実ですが、素朴なジュリアプログラマーは彼のより単純な概念モデルと異なる振る舞いを見ることができないと主張しようとしました（変数は定義された瞬間に存在し始めます）。 残念ながら、あなたは正しいです、次のコードはエラーを出しませんが、最後にa = 2を省略した場合はエラーを出します
機能テスト（）
i = 1:10の場合
a = 1
終わり
println（a）
a = 2
終わり
残念ながら説明します。動作は理解できますが（以前にコンパイル言語を使用したことがあるため）、それでも混乱を招き、予期しないことがわかります。 スクリプトの経験しかない人やプログラミングに不慣れな人にとって、それはどれほど悪いことでしょう。 また、動作を示すコードをいくつか見つけましたが、便利なアプリケーションが見つかりません（多分あなたはそこで私を助けることができます）

REPLについて：
少なくともREPLでスコープを「通常」に戻すこと（ループにグローバルを追加する必要はない）が優先度が高いことを確信しました。今日REPLでいくつかのことをテストしていて、（再び）噛まれました。それを実現するのに少し時間がかかります。 私がすでにジュリアをフォローしていることを考えると、本当に多くの人が好きで、問題についてこのスレッドをフォローしています、私はそれをショートッパーと呼ぶことさえあります：言語をテストする（ジュリアへの）ニュービーは見つけることができない可能性が非常に高いです問題を解決し、ただあきらめます。

@jeffbezansonと私は両方とも待望の休暇中です（私はこれを読むべきではありません）。 私たちは一週間かそこらで何をすべきかを理解することができます。

@derijkp 、フィードバックは高く評価されていますが、スコーピングルールはより広範な議論や改訂に対応していません。 テーブルにあるのは、特別なケースのインタラクティブな評価だけです。 SoftGlobalScopeパッケージはすでに優れた実験的実装であり、Baseのその部分を作成し、REPLで使用するだけの問題かもしれません。

@derijkp簡単に言うと、変数のスコープが何らかのブロック構造（関数やループの本体など）に対応している方が簡単だと思います。 あなたの提案では、変数のスコープはブロックのサブセットになりますが、これは最終的にはより複雑で混乱を招くと思います---変数のスコープに対応する構文形式を指すことはできません。

はい、これは一部の人々の直感のミスマッチであると私は信じることができます。 ただし、言語を使用してから最初の10分間は、ある程度までしか最適化できません。 本当の問題は、それがどのように機能するかを教える/学ぶのがどれほど難しいか、そしてどのデザインが長期的に時間を節約するか（言語を単純にする、ツールの開発を容易にするなど）ですか？

（REPLの動作の変更に関する上記の多くに同意します）
REPLがこのスタックオーバーフローの質問につながらない方法であるようにしたいと思い
多くの新しい目がジュリアを見ているので、早くするのが最善でしょう

同意します...また、スコープルールは必ずしも変更されるべきではなく、すべてのインタラクティブインターフェイス（つまり、REPL、Jupyter、およびJunoコントロールが入力されます）だけが変更される必要があると思います。

これは、初心者が新しいルールを学ぶことだけではありません。 コードのフラグメントをコピーしてREPL、jupyterなどに貼り付けることができず、関数にも貼り付けることができない場合、それは中級プログラマーにとっても大きな迷惑です。

もちろん、私は他のポスターにも同意します...初心者の場合、関数内で見たコードフラグメントを取得し、Iをスクリプトにコピーし、関数内でコピーしたときに同じ動作をしないと完全に混乱します、juno、repl、jupyterで。 同じ問題に帰着する100のスタック交換の質問があります。 中級のプログラマーは、 letブロックなどでラップする、あらゆる種類の自家製ソリューションを使用することになります。これにより、事態はさらに混乱します。

同じ問題に帰着する100のスタック交換の質問があります。 中級のプログラマーは、 letブロックなどでラップする、あらゆる種類の自家製ソリューションを使用することになります。これにより、事態はさらに混乱します。

可能性はありますが、この段階ではこれは架空のものです（リンクされた質問のOPも、混乱するのではなく、スコープルールの論理的根拠について質問しています）。

また、これを心配しているすべての人の教育経験を尊重しますが、これが教室で大したことになるかどうかは、時が経てばわかることです。

質問者はそれによって混乱しているようです：「これは初心者のジュリアユーザーにとって直感的であるかどうか疑問に思います。私にとっては直感的ではありませんでした...」

質問者はそれによって混乱しているようです：

言うまでもなく、これはスコープのニュアンスを理解するのに十分なプログラミング言語を明確に知っている人です。 これらのトピックを完全に知らないすべてのmatlabタイプのユーザーはどうでしょうか...そしておそらくニュアンスを理解するのに十分な時間を費やすことは決してないでしょう。

おそらく、しかしこの段階ではこれは架空のものです

私はすでにstackoverflowでこれに関連する複数の質問に回答しましたが、主に新規ユーザーによるものであり、実際にはさらに多くの質問に回答しました（最後の質問は、昨日、これをノーゴーと見なしたMatlabユーザーからのものです）。

同じ問題に帰着する100のスタック交換の質問があります。

私の「暇な時間」では、SEの質問にscope 、 scoping 、およびglobal-variablesタグを追加しています。 私は時間の不足のために停止するだけで、それ以上ないからではありません。

トリアージを含む多くの議論の後の結論：BaseにSoftGlobalScopeの線に沿って何かを含め、REPLおよび他のすべてのインタラクティブな評価コンテキストでそれを使用します。 @JeffBezansonは、これが実装される方法は、実際にはソフトスコープが以前に実装された方法と本質的に同じであると指摘しているため、完全に一巡しています。 違いは、モジュールやスクリプトにはスコープの動作がなく、REPLのようなコンテキストでのみ動作することです。 また、ソースの書き換えとしての_explaining_ソフトスコープは、ハードスコープとソフトスコープを区別しようとするよりも明確だと思います（これは、Jeffがどのように説明したかはわかりませんが、指摘するかもしれません）。

これらの2つのステートメントは、少し矛盾しているように見えるため、少し混乱します。

そしてそれをREPLと他のすべてのインタラクティブな評価コンテキストで使用します

[...]スクリプトにはスコープの動作はなく、REPLのようなコンテキストでのみ動作します。

これは、モジュールMainソフトスコープ（REPLプロンプトなど）とハードスコープ（ julia -L script.jl ）がある場合があることを意味しますか？ Main常にソフトスコープを持っていると言っても意味がありませんか？ そして、モジュールはusing SoftGlobalScopeソフトスコープにオプトインできますか？

（私は推測します）スコープルールは後方互換性がないため、スクリプトで変更できません。つまり、1.0用に記述されたコードが1. *バージョンで実行されるという約束を破ることになります。 REPLのスコープに関する同じ問題がスクリプトにも当てはまるというのは正しいです（スクリプトとして実行したときにコードが正しく機能しない理由を完全に失ったナイーブなユーザー）。 大きな非互換性なしにこの問題を解決/軽減する方法は、ソフトスコープ（または代替）を使用するオプション（julia -fプログラムファイルなど）をjuliaコマンドラインに追加し、初心者が行う可能性のある説明/チュートリアルでこのオプションを表示することです。出くわす。
また、いくつかの利点がある可能性のあるソフトスコープの潜在的な代替案もあります（おそらく欠点を見落としていますが）：ファイル（スクリプトと呼ばれる）が常に独自のローカルスコープを導入する場合：スコープルールは、機能し、多くのユーザーの期待に応えます。 また、新しいユーザーのパフォーマンス上の問題の多くが解消されます。
不要なグローバル（グローバルを明示的に定義する必要があります）がなくなり、コードがコンパイルされる可能性があります
（すべてを関数に入れ、グローバルの使用を避けるために、何回言わなければなりませんでしたか？）

私はこれにぶつかったばかりで、正直に言うと完全に困惑していて、他の言語でこれまで見たことがありませんでした。 物事が落ち着いたら、今年後半に大学の上級Rユーザー向けにオプションのJuliaコースを導入する予定です。生徒は、REPLでランダムに入力を開始する0日目にこれをヒットします。 また、 forループがifステートメントとは異なる動作をするという事実は、傷口に塩をこすりつけるだけですが、これはスコープの観点からは論理的かもしれません。 関数内のスコープは、生物学の学生が理解するのに十分に困難です。REPL/スクリプト/ forループ/ ifステートメントで_認識されているにもかかわらず_明白な矛盾を説明する必要があるという考え（それが私たちが話していることだからです）ここについて）地球上の他のすべての言語とは異なる方法で、私は非常に悲しくなります。

下位互換性の約束がなされたことは理解していますが、この作業を_地球上のすべての非csの人（および私が疑うほとんどのcsの人）が期待するように_行うことは、下位互換性の問題というよりはバグ修正のようです-私たちは言っていませんすべてのバグが永遠に再現されるということですか？ REPLの修正は明らかに不可欠なので、これを提案するのは素晴らしいことですが、スクリプトをREPLにコピーできず、同じ動作が元の問題と同じかそれより悪いように見えることを説明する必要があります。

これをバグ修正として扱い、スクリプトとREPLを使用してプッシュすることを検討してください（「古い」動作に切り替えるスイッチがある場合でも）。1.0.1でできるだけ早く実行してください。

私がジュリアを学ぼうとしていた同僚も、これに出くわしました。 最初のステップでグローバル変数とローカル変数の全体を説明しなければならないのは理想的ではありません...

これを「バグ修正」として扱うことは、1.0の安定性契約を破ることになるので、カードにはないと思います。 ただし、 julia -i実行されるスクリプト（つまり「対話型」モード）にsoftscopeを使用することは私には合理的と思われます。

（つまり、フラグ--softscope={yes|no}あり、デフォルトでisinteractiveの値になります。）

スクリプトモードの選択を検討する必要があります。

さらに言えば、「スクリプト」、つまりjulia foo.jlに対してデフォルトで--softscope=yesを設定し、モジュールとincludeに対してのみ「ハード」スコープルールをオンにするのは私にとってはおかしなことではありません。

さらに言えば、「スクリプト」に対してデフォルトで--softscope = yesを使用するのは、私にとってはおかしなことではありません。

それか。 真剣に検討すべきもう1つはJunoです。 人々はコードを介してインタラクティブな開発を行うために<shift-enter>を実行し（特に回帰テストを使用する場合）、後で同じファイルを実行できることを期待することを忘れないでください。 コードが@testsetかどうかは重要ですか（スコープが導入される可能性があると思います）？ @testset場合とAtomの統合を使用しない場合で同じテキストが変更され、 ] test実行と矛盾する場合、ユーザーは非常に混乱します。

最善の解決策は、ハードスコープが単にオプトインのものであり、他のすべての使用法（スクリプト内のincludeを含む）が特に明記しない限りsoftscope使用することであるように私には確かに聞こえます。

地球上の他のすべての言語とは異なります

すべての変数を導入するためにvar x = 0を記述しますか？ それはまたこれを「修正」し、他の言語のようになります。

すべてのバグが永遠に再現されると言っているわけではありません。

それはこれがどのように機能するかではありません。 現在の動作をバグと呼ぶだけでは、必要な言語に変更を加えることはできません。

このためのコマンドラインオプションがあるべきではないと私は心から思っています。 次に、ジュリアコードのすべての部分に、使用するオプションを示すコメントまたは何かを添付する必要があります。 ソースファイル内のある種のパーサーディレクティブは少し優れていますが、それでも固定ルールを持つことはさらに優れています。 たとえば、モジュール内のハードスコープのみが意味をなす場合があります。

教室で人々が見ている躁病、ヒステリー、および大虐殺を回避するのに役立つかもしれないこれの説明をもう一度提供しようと思います：

「」
Juliaには、ローカル変数とグローバル変数の2種類の変数があります。 REPLまたはトップレベルで導入する変数は、他のもの以外ではグローバルです。 関数とループ内に導入された変数はローカルです。 プログラム内のグローバル変数の更新は一般的に悪いので、ループまたは関数内にいてグローバルを更新したい場合は、 global宣言を再度記述して、それについて明示的にする必要があります。
「」

おそらくそれは改善できるでしょう。 提案を歓迎します。 私は知っています、あなたはむしろどんな種類の説明も全く必要としないでしょう。 わかりました。 しかし、それは私にはそれほど悪くはないようです。

このためのコマンドラインオプションがあるべきではないと私は心から思っています。 次に、ジュリアコードのすべての部分に、使用するオプションを示すコメントまたは何かを添付する必要があります。 ソースファイル内のある種のパーサーディレクティブは少し優れていますが、それでも固定ルールを持つことはさらに優れています

同意します。 私には教育とコミュニケーションの頭痛の種のように聞こえます。

たとえば、モジュール内のハードスコープのみが意味をなす場合があります。

私が理解しているのは、IJuliaノートブックからコピーした.jlファイルに短いスクリプト（モジュールではない！）がある場合、そのコードをREPLで直接実行するかshift- Junoに入ると、一貫してソフトスコープとして動作します...しかし、 moduleブロックの代わりにコピーすると、グローバルについて怒鳴りますか？ しかし、そのコードをモジュール内の関数内にコピーすると、機能するはずです。

もしそうなら、それは完全に理にかなっています、非常に教えやすく、首尾一貫しています。 トップレベルのスクリプトは、探索などのためのインタラクティブなインターフェイスですが、そのようなコードをモジュールに配置することは決してありません。 モジュールは、関数で埋める必要があるものであり、非常に慎重にグローバルと見なされます。 それらのルールについて人々に伝えるのは簡単でしょう。

すべての変数を導入するためにvarx = 0を記述しますか？ それはまたこれを「修正」し、他の言語のようになります。

いいえ、私はむしろしたくないです！ しかし、REPLを持つスクリプト言語（ruby、python、Rなど）がそれを行うことはめったになく、Juliav0.6と同じように動作します。

Juliaには、ローカル変数とグローバル変数の2種類の変数があります。 REPLまたはトップレベルで導入する変数は、他のもの以外ではグローバルです。 関数とループ内に導入された変数はローカルです。 プログラム内のグローバル変数の更新は一般的に悪いので、ループまたは関数の内部にいて、グローバルを更新したい場合は、グローバル宣言を再度記述して、それについて明示的にする必要があります。

私はあなたがここで言っていることを完全に理解しています、そして私は（木に触れる！）この間違いを二度と犯しません。 しかし、私が心配している問題全体は私ではありません。 関数内の変数は外部の変数を見ることができず、その逆も同様であると説明すると、スコープを（直接言及せずに）導入するのは比較的簡単であることがわかりました（Rの事実よりも願望ですが）。それ自体はすでに_比較的_高度な概念です。 しかし、これは、スコープが人々に影響を与えるほど複雑なものをリモートで望まない、ここでの学習曲線のはるかに早い段階で発生します...

また、「REPLまたはトップレベルで導入する変数は、他のもの以外ではグローバルである」および「関数およびループ内で導入される変数はローカルである」だけでなく、REPLまたはでのifステートメントの変数でもあることに注意してください。トップレベルはグローバルですが、 @testset変数はローカルです。 「ローカルでもグローバルでも、頑張ってみて、自分で試してみてください」といううさぎの穴に行き着きます。

ただし、 @ jlperlaに同意します。「モジュール内のハードスコープのみが意味をなす可能性がある」という提案は、私にはまったく問題ないようです。 モジュールも十分に高度な概念です...ソフトスコープがREPLとスクリプトで機能する場合、それはまったく問題ありません。

スコープほど複雑なものが人々に影響を与えることは望んでいません...
トップレベルはグローバルですが、 @testset変数はローカルです

私が得ようとしているのは、グローバルとローカルの簡単な説明で初期段階の教育に十分だと感じているということです。「スコープ」という言葉を言う必要すらありません（まったく発生しません）。上記の私の説明で）。 REPLでいくつかの単純な式とループを表示しているだけの場合、テストセットについて人々に教えているわけではなく、言語内のすべてのスコープ動作の完全なリストは必要ありません。

私の唯一のポイントは、この変更により、言語について多くの詳細を前もって教える必要が突然なくなるわけではないということです。 スコープやテストセットなどに関する大部分は無視できますが、グローバルとローカルの単純な線で十分です。

そして、グローバルとローカルの単純な線で十分です。

誰もがすべてのコードを最初から書き始めた世界では、私は完全に同意します。

問題は、範囲だけでなく、取得したコードをコピーして貼り付けた場所の範囲を理解することについても生徒に教える必要があるということです。 関数またはletブロック内のstackexchangeにあるコードをコピーして貼り付ける場合は、それをスキャンして、REPLまたは.jl貼り付ける場合に「グローバル」を追加する場所を見つける必要があることを教える必要があります。

そして、学生はなぜforこのスコープを作成するのかと尋ね始めますが、他のことは心配する必要はありません。

「ローカルでもグローバルでも、頑張ってみて、自分で試してみてください」といううさぎの穴に行き着きます。

ポップクイズ：ジュリア0.6では、 xグローバルまたはローカルです：

for i = 1:10
    x = i
end

答えは、グローバルxが以前に定義されているかどうかに依存するため、知る方法がないということです。 今、あなたはそれがローカルであると確かに言うことができます。

皆さん、この議論はもはや生産的ではないことに焦点を当てています。 ジェフは、REPLでの古い動作が良かったことをよく知っています。 そもそも誰がそれを設計し、実装したと思いますか？ 私たちはすでにインタラクティブな振る舞いを変えることを約束しました。 「スクリプト」がインタラクティブであるかどうかについては、まだ決定を下す必要があります。 「スクリプト」と呼ぶとインタラクティブに聞こえますが、「プログラム」と呼ぶとインタラクティブに聞こえませんが、まったく同じです。 返信は短く建設的なものにし、まだ決定しなければならないことに焦点を当ててください。 これから逸脱したコメントがあると、コメントが非表示になり、スレッドがロックされる可能性があります。

私が持っていたと思ったのですが、「煩わしすぎて」「村人に熊手を出させそう」と却下したのは、非対話型のコンテキストでは、 localまたはglobalが必要になる可能性があるということglobalアノテーション。 これにより、モジュールからのコードがREPLに貼り付けられた場合に同じように機能することが保証されます。 それを「スクリプト」/「プログラム」に適用した場合、同じことがそれらにも当てはまります。

私が最初にJuliaを紹介されたとき（少し前で、Fortranのバックグラウンドを持っていることがほとんどです）、「Juliaは関数レベルでコンパイルされて高速であるため、効率的でなければならないことはすべて関数内で実行する必要があります。 。メインの「プログラム」では、スクリプト言語のように動作します。 そのステートメントを理解せずに計算量が多すぎることをしている人を想像することはできないので、私はそれが十分に公平であることに気づきました。 したがって、関数と同じ表記法と構造を使用するためにメインプログラムでパフォーマンスが犠牲になった場合、これらのスコープ規則を理解して教えようとしてコピーできず、ある場所から別の場所にコードを貼り付けます。

ちなみに、私はまだジュリアの初心者ですが、高校生と大学生に物理システムのシミュレーションの基本を教えるためにそれを選択しました。 そして、私はすでにこの問題が以前のバージョンの「通常の」動作に戻ることを望んでいます。それは私たちにかなりの頭痛の種を与えるからです。

この会話は現在ロックされており、Juliaコミッターのみがコメントできます。

@JeffBezanson 、最初はREPLでのみ、他の場所でオプトインして、この談話スレッドで提案したセマンティクスを実装する計画は何でしょうか？

SoftScope.jlを構文書き換えするのではなく、それを直接下降コード（ julia-syntax.scm ）に入れることを計画しているようです。 または、最初に構文を書き換えて（SoftScopeを提案されたルールに変更し、stdlibに変換して）、後のJuliaリリースの下位コードに入れるのを延期しますか？