From e49d969221d65a9ccda68e574cd3740198977940 Mon Sep 17 00:00:00 2001 From: arata-honda Date: Thu, 25 Nov 2021 00:17:01 +0900 Subject: [PATCH 1/9] Translated the migration guide page into Japanese. --- .../compatibility-classpath.md | 144 +++++++++ .../scala3-migration/compatibility-intro.md | 36 +++ .../compatibility-metaprogramming.md | 87 ++++++ .../scala3-migration/compatibility-runtime.md | 29 ++ .../scala3-migration/compatibility-source.md | 29 ++ .../scala3-migration/external-resources.md | 35 +++ .../incompat-contextual-abstractions.md | 136 +++++++++ .../incompat-dropped-features.md | 222 ++++++++++++++ .../incompat-other-changes.md | 289 ++++++++++++++++++ .../scala3-migration/incompat-syntactic.md | 222 ++++++++++++++ .../scala3-migration/incompat-type-checker.md | 118 +++++++ .../incompat-type-inference.md | 95 ++++++ .../scala3-migration/incompatibility-table.md | 127 ++++++++ .../scala3-migration/options-intro.md | 22 ++ .../scala3-migration/options-lookup.md | 271 ++++++++++++++++ _ja/overviews/scala3-migration/options-new.md | 98 ++++++ .../scala3-migration/plugin-intro.md | 12 + .../scala3-migration/plugin-kind-projector.md | 128 ++++++++ .../scaladoc-settings-compatibility.md | 85 ++++++ .../tooling-migration-mode.md | 63 ++++ .../tooling-syntax-rewriting.md | 220 +++++++++++++ .../scala3-migration/tooling-tour.md | 138 +++++++++ .../scala3-migration/tutorial-intro.md | 22 ++ .../tutorial-macro-cross-building.md | 228 ++++++++++++++ .../scala3-migration/tutorial-macro-mixing.md | 198 ++++++++++++ .../tutorial-prerequisites.md | 129 ++++++++ .../scala3-migration/tutorial-sbt.md | 230 ++++++++++++++ 27 files changed, 3413 insertions(+) create mode 100644 _ja/overviews/scala3-migration/compatibility-classpath.md create mode 100644 _ja/overviews/scala3-migration/compatibility-intro.md create mode 100644 _ja/overviews/scala3-migration/compatibility-metaprogramming.md create mode 100644 _ja/overviews/scala3-migration/compatibility-runtime.md create mode 100644 _ja/overviews/scala3-migration/compatibility-source.md create mode 100644 _ja/overviews/scala3-migration/external-resources.md create mode 100644 _ja/overviews/scala3-migration/incompat-contextual-abstractions.md create mode 100644 _ja/overviews/scala3-migration/incompat-dropped-features.md create mode 100644 _ja/overviews/scala3-migration/incompat-other-changes.md create mode 100644 _ja/overviews/scala3-migration/incompat-syntactic.md create mode 100644 _ja/overviews/scala3-migration/incompat-type-checker.md create mode 100644 _ja/overviews/scala3-migration/incompat-type-inference.md create mode 100644 _ja/overviews/scala3-migration/incompatibility-table.md create mode 100644 _ja/overviews/scala3-migration/options-intro.md create mode 100644 _ja/overviews/scala3-migration/options-lookup.md create mode 100644 _ja/overviews/scala3-migration/options-new.md create mode 100644 _ja/overviews/scala3-migration/plugin-intro.md create mode 100644 _ja/overviews/scala3-migration/plugin-kind-projector.md create mode 100644 _ja/overviews/scala3-migration/scaladoc-settings-compatibility.md create mode 100644 _ja/overviews/scala3-migration/tooling-migration-mode.md create mode 100644 _ja/overviews/scala3-migration/tooling-syntax-rewriting.md create mode 100644 _ja/overviews/scala3-migration/tooling-tour.md create mode 100644 _ja/overviews/scala3-migration/tutorial-intro.md create mode 100644 _ja/overviews/scala3-migration/tutorial-macro-cross-building.md create mode 100644 _ja/overviews/scala3-migration/tutorial-macro-mixing.md create mode 100644 _ja/overviews/scala3-migration/tutorial-prerequisites.md create mode 100644 _ja/overviews/scala3-migration/tutorial-sbt.md diff --git a/_ja/overviews/scala3-migration/compatibility-classpath.md b/_ja/overviews/scala3-migration/compatibility-classpath.md new file mode 100644 index 0000000000..c594649136 --- /dev/null +++ b/_ja/overviews/scala3-migration/compatibility-classpath.md @@ -0,0 +1,144 @@ +--- +title: Classpathレベル +type: section +description: このセクションでは、Scala 2.13とScala 3クラスファイルの互換性について説明しています。 +num: 3 +previous-page: compatibility-source +next-page: compatibility-runtime +language: ja +--- + +コード上で、パブリックな型と構文を利用でき、そしてパブリックメソッドは異なるモジュールやライブラリで定義されています。 +そしてできる限り長く型チェックとして働いて、コンパイルフェーズにてコードの意味的な構成を検証し、クラスファイルに含まれている型や構文やメソッドの重要性を読むことができます。 + +Scala 2ではシグネチャはpickleフォーマットで保存されます。 +Scala 3では少し違っていて、なぜならシグネチャレイアウトよりも多くのTASTyフォーマットに寄り添っているからです。 +しかしながらScala 2.13からScala 3へ移行する目的においては、シグネチャだけでも有効です。 + +## Scala 3 Unpickler + +はじめの良い知らせとしてScala 3のコンパイラはScala 2.13のpickleフォーマットを読み込むことができるということ、すなわち、Scala 2.13によりコンパイルされたモジュールやライブラリに依存したコードの型チェックができるということです。 + +Scala3のUnpicklerは数年間広範囲的にコミュニティビルドによってテストされています。なので使うこと自体は安全です。 + +### Scala 3モジュールはScala 2.13アーティファクトに依存できます + +![Scala 3 module depending on a Scala 2.13 artifact](/resources/images/scala3-migration/compatibility-3-to-213.svg) + +sbtビルドとして、次のように説明できます（sbt 1.5.0以降が必要です）: + +```scala +lazy val foo = project.in(file("foo")) + .settings(scalaVersion := "3.0.0") + .dependsOn(bar) + +lazy val bar = project.in(file("bar")) + .settings(scalaVersion := "2.13.6") +``` + +または、barが公開されたScala 2.13ライブラリである場合は、次のことができます。: + +```scala +lazy val foo = project.in(file("foo")) + .settings( + scalaVersion := "3.0.0", + libraryDependencies += ("org.bar" %% "bar" % "1.0.0").cross(CrossVersion.for3Use2_13) + ) +``` + +sbtで `CrossVersion.for3Use2_13`を使用して、 `bar_3`の代わりに`bar_2.13`を解決します。 + +### スタンダードライブラリ + +1つ目のノート例はScala 2.13ライブラリです。 +Scala 2.13ライブラリがScala 3用の公式スタンダードライブラリとして確かに決定しています。 + +スタンダードライブラリは自動的にビルドツールに与えられることを覚えておきましょう、なので手動的に設定する必要はありません。 + +## Scala 2.13のTASTy読み取り機能 + +2つ目の良い知らせはscala 2.13.4からリリースされたTASTy読み取り機能がScala 3ライブラリで使えるということです。 + +> TASTy読み取り機能は非常に新しいものです。そのため、`-Ytasty-reader` フラグの下でのみ使用できます。 + +### サポートされている機能 + +TASTy読み取り機能は、すべての従来の言語機能に加えて、次の新しい機能をサポートします。: +- [Enumerations]({% link _scala3-reference/enums/enums.md %}) +- [Intersection Types]({% link _scala3-reference/new-types/intersection-types.md %}) +- [Opaque Type Aliases]({% link _scala3-reference/other-new-features/opaques.md %}) +- [Type Lambdas]({% link _scala3-reference/new-types/type-lambdas.md %}) +- [Contextual Abstractions]({% link _scala3-reference/contextual.md %}) (new syntax) +- [Open Classes]({% link _scala3-reference/other-new-features/open-classes.md %}) (and inheritance of super traits) +- [Export Clauses]({% link _scala3-reference/other-new-features/export.md %}) + +限定的にサポートしているもの。: +- [Top-Level Definitions]({% link _scala3-reference/dropped-features/package-objects.md %}) +- [Extension Methods]({% link _scala3-reference/contextual/extension-methods.md %}) + +よりエキゾチックな機能はサポートされていません。: +- [Context Functions]({% link _scala3-reference/contextual/context-functions.md %}) +- [Polymorphic Function Types]({% link _scala3-reference/new-types/polymorphic-function-types.md %}) +- [Trait Parameters]({% link _scala3-reference/other-new-features/trait-parameters.md %}) +- `@static` Annotation +- `@alpha` Annotation +- [Functions and Tuples larger than 22 parameters]({% link _scala3-reference/dropped-features/limit22.md %}) +- [Match Types]({% link _scala3-reference/new-types/match-types.md %}) +- [Union Types]({% link _scala3-reference/new-types/union-types.md %}) +- [Multiversal Equality]({% link _scala3-reference/contextual/multiversal-equality.md %}) (unless explicit) +- [Inline]({% link _scala3-reference/metaprogramming/inline.md %}) (including Scala 3 macros) +- [Kind Polymorphism]({% link _scala3-reference/other-new-features/kind-polymorphism.md %}) (the `scala.AnyKind` upper bound) + +### Scala 2.13モジュールScala 3アーティファクトに依存できます + +`-Ytasty-reader`でTASTyリーダーを有効にすることで、Scala 2.13モジュールはScala 3アーティファクトに依存できます。 + +![Scala 2 module depending on a Scala 3 artifact](/resources/images/scala3-migration/compatibility-213-to-3.svg) + +sbtビルドとして、次のように説明できます。: + +```scala +lazy val foo = project.in.file("foo") + .settings( + scalaVersion := "2.13.6", + scalacOptions += "-Ytasty-reader" + ) + .dependsOn(bar) + +lazy val bar = project.in(file("bar")) + .settings(scalaVersion := "3.0.0") +``` + +または、`bar`が公開されたScala 3ライブラリの場合: + +```scala +lazy val foo = project.in.file("foo") + .settings( + scalaVersion := "2.13.6", + scalacOptions += "-Ytasty-reader", + libraryDependencies += ("org.bar" %% "bar" % "1.0.0").cross(CrossVersion.for2_13Use3) + ) +``` + +`CrossVersion.for2_13Use3`と同様に、sbtで `CrossVersion.for3Use2_13`を使用して、`bar_2.13`ではなく`bar_3`を解決します。 + +## 相互運用性の概要 + +要するに、下位、上位互換性があり、そしてそれにより**移行が段階的に行うことが可能になるのです**。 + +ライブラリの依存関係がまだ移植されてない場合（マクロライブラリを除く）でも、一度にScalaアプリケーションの一つのモジュールを移植することができます。 + +移行期間中、Scala 2.13モジュール間で、Scala 3モジュールを持つことができます。 + +![Sandwich pattern](/resources/images/scala3-migration/compatibility-sandwich.svg) + +これはできるだけ長くすべてのライブラリが単一バイナリバージョンを解決できるように許しておます: `lib-foo_3` と `lib-bar_2.13` を同じクラスパスに持つことができますが、`lib-foo_3` と `lib-foo_2.13`を含めることはできません. + +この逆のパターン、すなわち2.13モジュールが中央にある場合でも可能です。 + +> #### ライブラリメンテナンスの免責事項 +> +> 公開されているライブラリの中でScala 2.13とScala 3間の相互運用性を使うことは一般的にエンドユーザにとっては安全ではないです。 +> +> 何をしているか正確に知らない限り、Scala 2.13に依存するScala 3のライブラリを公開することはおすすめできないです（Scala-libraryは除く）し逆も然りです. +> 理由としては、ライブラリユーザがクラスパス内の同じfooライブラリの中の競合するバージョン`foo_2.13`, `foo_3`で終わるのを防ぐためで、この問題は場合によっては解決することができません。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/compatibility-intro.md b/_ja/overviews/scala3-migration/compatibility-intro.md new file mode 100644 index 0000000000..4ed49d659c --- /dev/null +++ b/_ja/overviews/scala3-migration/compatibility-intro.md @@ -0,0 +1,36 @@ +--- +title: 互換性リファレンス +type: chapter +description: この章ではScala 2.13とScala 3の互換性について説明しています。 +num: 1 +previous-page: +next-page: compatibility-source +language: ja +--- + +Scala 3はScalaエコシステムにおける互換性に関して革新的なものであり、全Scalaプログラマの日々の経験を大きく向上させるでしょう。 +この新しい互換性の時代は移行から始まります。 + +Scala 2からScala 3に映ることは大きな急速進歩であります。 +Scalaはピカピカの新しいコンパイラで、言語のコアな基礎部分の完全なる再デザインを踏まえています。まだ、Scala 2.12からScala 2.13への移行のときよりは、ハードじゃないことを主張したいです。 + +Scala 2.13とScala 3の間での相互互換性のおかげで一層シンプルになりました。 + +この章では2つのバージョン差異における互換性の詳細について語る。 +ここでは、下記に従う疑問についての答えを見つけることができるでしょう。: + +**[Sourceレベル](compatibility-source.html)** +- Scala 3は異なる言語？ +- Scala 2.13プロジェクトをScala 3に変換するのはどれくらいハード? + +**[Classpathレベル](compatibility-classpath.html)** +- Scala 3ではScala 2.13のライブラリを使えるの？ +- 逆に、Scala 3のライブラリをScala 2.13で使えるの？ + +**[Runtime](compatibility-runtime.html)** +- 本番環境においてScala 3プログラムを安全にデプロイできるの? +- Scala 2.13とくらべてScala 3はどれくらいはやいの？ + +**[メタプログラミング](compatibility-metaprogramming.html)** +- 所有してるScala 2.13プロジェクトはScala 2のマクロ機能のリプレイスによって影響は出るのでしょうか？ +- どうやったら、所有するScala 2.13マクロライブラリをScala 3にうつせるの？ diff --git a/_ja/overviews/scala3-migration/compatibility-metaprogramming.md b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md new file mode 100644 index 0000000000..14ed94a061 --- /dev/null +++ b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md @@ -0,0 +1,87 @@ +--- +title: メタプログラミング +type: section +description: このセクションではメタプログラミングの移行について議論します。 +num: 5 +previous-page: compatibility-runtime +next-page: tooling-tour +language: ja +--- + +マクロを呼ぶメソッドはマクロ展開と呼ばれるコンパイラフェーズ中に実行され、プログラムの一部である抽象的なシンタックスツリーを生成します。 + +Scala 2.13のマクロAPIはScala 2.13コンパイラの内部と密接に関連しています。 +それゆえ、Scala 3コンパイラではScala 2.13マクロを展開することはできないのです。 + +対象的に、Scala 3ではメタプログラミングの新たで原理的なアプローチを導入しており、安定性のために設計されています。 +Scala 3マクロとそしてそのインラインメソッドは通常、Scala 3コンパイラの将来のバージョンと互換性があります。 +これは異論のない改善ですが、新しいメタプログラミング機能を使用して、すべてのScala 2.13マクロをゼロから書き直す必要があるということも意味しています。 + +## マクロの依存 + +Scala 3のモジュールはマクロ定義が含まれているScala 2.13アーティファクトに依存することができますがコンパイラはそれらのマクロを展開することはできないでしょう。 +シンプルにエラーとして帰ってきます。 + +{% highlight text %} + -- Error: /src/main/scala/example/Example.scala:10:45 + 10 | val documentFormat = Json.format[Document] + | ^ + |Scala 2 macro cannot be used in Scala 3. See https://dotty.epfl.ch/docs/reference/dropped-features/macros.html + |To turn this error into a warning, pass -Xignore-scala2-macros to the compiler +{% endhighlight %} + +`-Xignore-scala2-macros` を使うことはコードの型チェックに役立つだけではなく、未完成なクラスファイルを生成します。 + +あなたのプロジェクトでこのエラーが出た時、あなたは次第にマクロアーティファクトのScala 3コンパイルバージョンを上げるほか選択肢がなくなるでしょう + +## マクロエコシステムの移行 + +実験的ではありながら、ScalaコミュニティはScala 2マクロ機能を複数の方法で大きく適用させてきました。: コード生成, 最適化, 人間工学的なDSL... + +大部分のエコシステムは現在Scala 2.13マクロにより定義されている外部ライブラリに依存しています。 +それらのライブラリの識別や移植はエコシステムを前に動かすキーとなるでしょう。 + +[このページ](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html)にたくさんのオープンソースの移行状態が可視化されています。. + +## マクロの再記述 + +この新しいメタプログラミング機能は完全にScala 2と異なります。 +構成としては: +- [インラインメソッド][inline] +- [コンパイル時間のオペレーション][compiletime] +- [マクロ][macros] +- [クォーテッドコード][quotes] +- [抽象的シンタックスツリーを超えた反映 (AST)][reflection] + +マクロを再実装する前に次のことを自問する必要があります。: +- `インライン`と`scala.compiletime`を使用してロジックの再実装できますか? +- シンプルかつ安全にマクロ展開ができるか? +- ASTにアクセスすることが本当に必要なことですか? +- 返却型として[マッチタイプ](/scala3/reference/new-types/match-types.html) を利用しますか? + +あなたは全ての新メタプログラミング概念を [Macro Tutorial][scala3-macros]を読むことで学ぶことができます。 + +## マクロライブラリのクロスビルド + +素晴らしいマクロライブラリを書き終わると、Scala 2.13とScala 3の中で利用可能になります。 +ここで２つの異なるアプローチがあり、伝統的なクロスビルド技術と、より最新の合成マクロ技術があります。 +あなたは下記のチュートリアルを読むことでそれを学ぶことができます。: +- [Cross-Building a Macro Library](tutorial-macro-cross-building.html) +- [Mixing Scala 2.13 and Scala 3 Macros](tutorial-macro-mixing.html) + +## 追加のリソース + +Blog posts and talks: +- [Macros: The Plan For Scala 3](https://www.scala-lang.org/blog/2018/04/30/in-a-nutshell.html) +- [Scala Days - Metaprogramming in Dotty](https://www.youtube.com/watch?v=ZfDS_gJyPTc) + +Early-adopter projects: +- [XML Interpolator](https://github.com/dotty-staging/xml-interpolator/tree/master) +- [Shapeless 3](https://github.com/dotty-staging/shapeless/tree/shapeless-3) + +[inline]: {% link _overviews/scala3-macros/tutorial/inline.md %} +[compiletime]: {% link _overviews/scala3-macros/tutorial/compiletime.md %} +[macros]: {% link _overviews/scala3-macros/tutorial/macros.md %} +[quotes]: {% link _overviews/scala3-macros/tutorial/quotes.md %} +[reflection]: {% link _overviews/scala3-macros/tutorial/reflection.md %} +[scala3-macros]: {% link _overviews/scala3-macros/tutorial/index.md %} diff --git a/_ja/overviews/scala3-migration/compatibility-runtime.md b/_ja/overviews/scala3-migration/compatibility-runtime.md new file mode 100644 index 0000000000..5272de3974 --- /dev/null +++ b/_ja/overviews/scala3-migration/compatibility-runtime.md @@ -0,0 +1,29 @@ +--- +title: Runtime +type: section +description: このセクションではScala 3のランタイム時の特性について記述しています。 +num: 4 +previous-page: compatibility-classpath +next-page: compatibility-metaprogramming +language: ja +--- + +Scala 2.13とScala 3は同じアプリケーションバイナリインターフェイス(ABI)を共有します。 + +> ABIはバイトコード上、またはScala.js IRでScalaコードを表現しているものです。 +> ABIはランタイムにおけるScalaプログラムの振る舞いを決めます。 + +Scala 2.13とScala 3の混ざった同一ソースコードをコンパイルすると、とても似ているバイトコードを生成します。 +違いとしてはいくつかの機能が変更されたことで、lazy valの初期化インスタンスが向上しています。 + +ABIの共有によりScala 2.13とScala 3ファイルを同じJVMクラスによりロードできるようになります。 +同様に、Scala 2.13ファイルとScala 3 `sjsir` ファイルは、Scala.jsリンカーによってリンクできます。 + +更に、ランタイム時の突発的なふるまいから我々を守ってくれます。 +そして、Scala 2.13からScala 3の移行で、ランタイム時時のクラッシュとパフォーマンスを安全にしてくれます。 + +まずはじめに、Scalaプログラムの実行時の特性を確認することは、Scala 2.13と比較してScala 3では良くも悪くもありません。 +しかしながら、いくつかの新しい機能があなたの課題に関して選択肢を与えてくれるでしょう。: +- [Opaque Type Aliases](http://dotty.epfl.ch/docs/reference/other-new-features/opaques.html) +- [Inline Methods](http://dotty.epfl.ch/docs/reference/metaprogramming/inline.html) +- [@threadUnsafe annotation](http://dotty.epfl.ch/docs/reference/other-new-features/threadUnsafe-annotation.html) diff --git a/_ja/overviews/scala3-migration/compatibility-source.md b/_ja/overviews/scala3-migration/compatibility-source.md new file mode 100644 index 0000000000..a60e54f6c7 --- /dev/null +++ b/_ja/overviews/scala3-migration/compatibility-source.md @@ -0,0 +1,29 @@ +--- +title: Sourceレベル +type: section +description: このセクションでは、Scala 2.13とScala3ソース間の互換性レベルについて説明しています。 +num: 2 +previous-page: compatibility-intro +next-page: compatibility-classpath +language: ja +--- + +Scala 3はScala 2のバージョン向上したものです。 + +新たなシンタクスにもかかわらず、Scala 2.13の大部分はまだ有効です。 +すべてではありませんが、一部の構成は単純化、制限、または完全に削除されています。 +しかしながらこれらの決定は正当な理由で、適切な回避策が可能であるように注意して作成されています。 + +一般的に、全ての非互換性に対する簡単なクロスコンパイルソリューションがあり、そしてそれはScala 2.13からScala 3へ簡単かつスムーズに移行します。 +非互換性のコーパスは [非互換性テーブル](incompatibility-table.html)に。 + +ただし例外があり、そしてそれは従来のScala 2のマクロをリプレイスした新しいメタプログラミングフレームワークです。 +詳細説明に関しては、この章の終わりの[メタプログラミング](compatibility-metaprogramming.html)のセクションにあります。 + +メタプログラミングはおいておいて、Scala 2.13ソースコードはかなり簡単にScala 3に移植できます。 +移行が完了するとすぐに、あなたはScala 2にはないScala 3のパワフルな機能を使えるようになるでしょう。 +Scala 2.13のすべてのものがコンパイルできるというわけではないというのが欠点ではあります。 +しかしながら驚くことに、この新しいScala 3のアーティファクトはScala 2.13の依存関係として使用できます。 + +詳細に説明するように、下位互換性と上位互換性があります。 +これはScala言語の歴史におけるブレイクスルーです。 diff --git a/_ja/overviews/scala3-migration/external-resources.md b/_ja/overviews/scala3-migration/external-resources.md new file mode 100644 index 0000000000..565751c136 --- /dev/null +++ b/_ja/overviews/scala3-migration/external-resources.md @@ -0,0 +1,35 @@ +--- +title: 外部リソース +type: section +description: このセクションでは、Scala 3への移行に関する外部リソースを一覧表示します。 +num: 27 +previous-page: plugin-kind-projector +next-page: +language: ja +--- + +## コース + +### Lunatechの[_Moving from Scala 2 to Scala 3_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course) + +Scala 3の最新情報を検討している方や、既存のScala 2アプリケーションをScala 3に移行することを検討している開発者であればLunatechの [_"Moving from Scala 2 to Scala 3"_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course)コースはget startedするのに良いです。 + +このコースでは、単一モジュールのAkka TypedSudokuソルバーを約10ステップのシリーズで移行する方法について説明します。以下のScala 3機能の実用化について説明します。: + +- 新しい制御構造のシンタックス +- インデントベースのシンタックス +- Scala 3コンパイラによるシンタックス書き換え +- トップレベルの定義 +- パラメータのアンタプル化 +- コンテキスト抽象化: + - 拡張メソッドの新しいシンタックス + - 与えられたインスタンスと使用している条項 +- 列挙型とエクスポート句 +- IntersectionとUnion型 +- Opaque型のエイリアス +- Multiversal Equality + +## 発表 + +- [Scala 3: Python 3 or Easiest Upgrade Ever?](https://www.youtube.com/watch?v=jWJ5A1irH_E) by Daniel Spiewak (Weehawken-Lang) +- [Taste the difference with Scala 3: Migrating the ecosystem and more](https://www.youtube.com/watch?v=YQmVrUdx8TU) by Jamie Thompson (f(by) 2020) diff --git a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md new file mode 100644 index 0000000000..f1e18f8768 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md @@ -0,0 +1,136 @@ +--- +title: コンテキスト抽象化 +type: section +description: この章ではコンテキスト抽象化の再設計に伴うすべての非互換性に関して詳細化します。 +num: 17 +previous-page: incompat-dropped-features +next-page: incompat-other-changes +language: ja +--- + +[コンテキスト抽象化]({% link _scala3-reference/contextual.md %})の再設計にはいくつかの非互換性をもたらします。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibiltiy| +|--- |--- |--- |--- |--- | +|[Type of implicit def](#type-of-implicit-definition)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| +|[Implicit views](#implicit-views)||||**Possible**| +|[View bounds](#view-bounds)|Deprecation|||| +|[Ambiguous conversion on `A` and `=> A`](#ambiguous-conversion-on-a-and--a)||||| + +## 暗黙的定義の型 + +暗黙的定義の型 (`val` や`def`) はScala 3では明示的に与える必要があります。 +これらを推論することはできなくなりました。 + +[ohze/scala-rewrites](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes) のリポジトリのScalafixルールで`ExplicitImplicitTypes`と名付けられているものでは、自動的に見逃してる型のアノテーションを付けてくれます。 + +## Implicit Views + +Scala 3では、`implicit val ev: A => B`のような形のimplicit関数値からの暗黙的型変換をサポートしなくなりました。 + +以下のコードは現在無効になります。: + +```scala +trait Pretty { + val print: String +} + +def pretty[A](a: A)(implicit ev: A => Pretty): String = + a.print // Error: value print is not a member of A +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html)これらのケースについてWARNINGを出してくれまが、直すことはできません。 + +この非互換性により、ランタイム時の非互換性を引き起こし、プログラムが破損する可能性があることに注意してください。 +実際、コンパイラはより広いスコープで別の暗黙的変換を見つけることができます。 +これにより、ランタイム時の望んでいない動作が発生します。 + +この例は、次の場合を示しています。: + +```scala +trait Pretty { + val print: String +} + +implicit def anyPretty(any: Any): Pretty = new Pretty { val print = "any" } + +def pretty[A](a: A)(implicit ev: A => Pretty): String = + a.print // always print "any" +``` + +解決される変換は、コンパイラのモードによって異なります。: + - `-source:3.0-migration`: `ev`変換を行います。 + - `-source:3.0`: `ev`変換の実行はできませんが、`anyPretty`は実行できます。ただこれは望ましくありません。 + +簡単な修正の一つとしては、正しい変換を明示的に提供することです。: + +{% highlight diff %} +def pretty[A](a: A)(implicit ev: A => Pretty): String = +- a.print ++ ev(a).print +{% endhighlight %} + +## View Bounds + +View Boundsは長い間非推奨担っていましたがScala 2.13では未だサポートされています。 +Scala 3ではコンパイルできないです。 + +```scala +def foo[A <% Long](a: A): Long = a +``` + +この例では下記のエラーを取得します。: + +{% highlight text %} +-- Error: src/main/scala/view-bound.scala:2:12 +2 | def foo[A <% Long](a: A): Long = a + | ^ + | view bounds `<%' are deprecated, use a context bound `:' instead +{% endhighlight %} + +このメッセージはcontext boundをview boundsの代わりに使うよう提案していますが、メソッドのシグネチャが変更してしまうでしょう。 +おそらくバイナリ互換性を維持するほうがより簡単で安全でしょう。 +そのため、暗黙的変換を宣言して明示的に呼び出す必要があります。 + +上記の[Implicit Views](#implicit-views)で説明した通り、実行時の非互換性により落ちる可能性があることに気をつけましょう。 + +{% highlight diff %} +-def foo[A <% Long](a: A): Long = a ++def foo[A](a: A)(implicit ev: A => Long): Long = ev(a) +{% endhighlight %} + +## `A`と`=> A`でのあいまいな変換 + +Scala 2.13では`A`での暗黙的変換が`=> A`での暗黙的変換より優先されてます。 +Scala3ではそうではなく、あいまい変換に繋がります。 + +以下に例示します。: + +```scala +implicit def boolFoo(bool: Boolean): Foo = ??? +implicit def lazyBoolFoo(lazyBool: => Boolean): Foo = ??? + +true.foo() +``` + +Scala 2.13のコンパイラは`boolFoo`変換を選択しますがScala 3コンパイラはコンパイル失敗します。 + +{% highlight text %} +-- Error: src/main/scala/ambiguous-conversion.scala:4:19 +9 | true.foo() + | ^^^^ + |Found: (true : Boolean) + |Required: ?{ foo: ? } + |Note that implicit extension methods cannot be applied because they are ambiguous; + |both method boolFoo in object Foo and method lazyBoolFoo in object Foo provide an extension method `foo` on (true : Boolean) +{% endhighlight %} + +一時的な解決策としては、明示的に変換を書き換えることです。 + +{% highlight diff %} +implicit def boolFoo(bool: Boolean): Foo = ??? +implicit def lazyBoolFoo(lazyBool: => Boolean): Foo = ??? + +-true.foo() ++boolFoo(true).foo() +{% endhighlight %} diff --git a/_ja/overviews/scala3-migration/incompat-dropped-features.md b/_ja/overviews/scala3-migration/incompat-dropped-features.md new file mode 100644 index 0000000000..5542220e03 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-dropped-features.md @@ -0,0 +1,222 @@ +--- +title: 廃止された機能 +type: section +description: この章ではすべての廃止された機能について詳細化します +num: 16 +previous-page: incompat-syntactic +next-page: incompat-contextual-abstractions +language: ja +--- + +一部の機能は言語の簡略化のため削除しました。 +殆どの変更は、[Scala 3 migration compilation](tooling-migration-mode.html)中に自動的に処理できることに注意してください。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| +|--- |--- |--- |--- | +|[Symbol literals](#symbol-literals)|Deprecation|✅|| +|[`do`-`while` construct](#do-while-construct)||✅|| +|[Auto-application](#auto-application)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| +|[Value eta-expansion](#value-eta-expansion)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[`any2stringadd` conversion](#any2stringadd-conversion)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| +|[Early initializer](#early-initializer)|Deprecation||| +|[Existential type](#existential-type)|Feature warning||| + +## シンボリックリテラル + +シンボリックリテラル構文はScala 2.13では非推奨とされていましたがScala 3で廃止されました。 +しかし、`scala.Symbol` クラスは引き続き存在するため、各文字列リテラルを`Symbol`のアプリケーションで安全に置き換えすることができます。 + +このコードはScala 3ではコンパイルできません。: + +```scala +val values: Map[Symbol, Int] = Map('abc -> 1) + +val abc = values('abc) // Migration Warning: symbol literal 'abc is no longer supported +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードは以下のように書き換えられます。: + +{% highlight diff %} +val values: Map[Symbol, Int] = Map(Symbol("abc") -> 1) + +-val abc = values('abc) ++val abc = values(Symbol("abc")) +{% endhighlight %} + +`Symbol`クラスは変換期では非常に便利ではありますが、`scala-library`のfuture バージョンでは非推奨になりやがて廃止されることに注意してください。 +2番目のステップとして、`Symbol`を使用するたびに、プレーンな文字列リテラル`"abc"` または、カスタム専用クラスに置き換えすることをおすすめします。 + +## `do`-`while` 構造 + +`do` の予約後は[新しい制御構文]({% link _scala3-reference/other-new-features/control-syntax.md %})で従来と異なる意味を持つようになりました。 + +この混乱を防ぐため、伝統的な`do while ()`構造は廃止します。 +それと等価である`while ({ ; }) ()`を使うことをおすすめします。そして、それはクロスコンパイルできます。またScala 3のシンタックスでは、`while { ; } do ()`のようになります。 + +Scala 3ではこのコードはコンパイルできません。 + +```scala +do { // Migration Warning: `do while ` is no longer supported + i += 1 +} while (f(i) == 0) +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。 + +```scala +while ({ { + i += 1 +} ; f(i) == 0}) () +``` + +## 自動適用 + +自動適用は`def toInt(): Int`のような空の親メソッドを呼ぶときに呼び出すシンタックスです。 +Scala 2.13で非推奨になり、Scala 3で削除されました。 + +Scala 3ではこのコードは無効です。: + +```scala +object Hello { + def message(): String = "Hello" +} + +println(Hello.message) // Migration Warning: method message must be called with () argument +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。: + +{% highlight diff %} +object Hello { + def message(): String = "Hello" +} + +-println(Hello.message) ++println(Hello.message()) +{% endhighlight %} + +自動適用は、Scala 3ドキュメンテーションの[このページ](/scala3/reference/dropped-features/auto-apply.html)でも詳細がカバーされています + +## Eta展開の値 + +Scala 3では[自動的なEta展開](/scala3/reference/changed-features/eta-expansion-spec.html)を導入しており、これにより、シンタックス`m _`を評価するメソッドが非推奨になります。 +さらにScala 3では、値をnull関数に拡張することはできなくなりました。 + +したがって、このコードはScala 3では無効です。: + +```scala +val x = 1 +val f: () => Int = x _ // Migration Warning: The syntax ` _` is no longer supported; +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。: + +{% highlight diff %} +val x = 1 +-val f: () => Int = x _ ++val f: () => Int = (() => x) +{% endhighlight %} + +## `any2stringadd` 変換 + +implicit `Predef.any2stringadd` 変換はScala 2.13で非推奨となり、Scala 3では廃止されます。 + +これらのコードはコンパイルできません。 + +```scala +val str = new AnyRef + "foo" // Error: value + is not a member of Object +``` + +この`String`への変換は必ず明示的に`String.valueOf`などで適用する必要があります。 + +{% highlight diff %} +-val str = new AnyRef + "foo" ++val str = String.valueOf(new AnyRef) + "foo" +{% endhighlight %} + +この書き換えは[`scala/scala-rewrites`](https://index.scala-lang.org/scala/scala-rewrites/scala-rewrites/0.1.2?target=_2.13)にあるScalafixルールの`fix.scala213.Any2StringAdd`により適用できます。 + +## 先行初期化 + +先行初期化はScala 2.13では非推奨となり、Scala 3では廃止されます。 +まれに使われいましたが、その殆どがScala3で現在サポートされている[Trait parameters](/scala3/reference/other-new-features/trait-parameters.html)の不足を補うためのものです。 + +そういうわけで、以下のコードはコンパイルできません。 + +```scala +trait Bar { + val name: String + val size: Int = name.size +} + +object Foo extends { + val name = "Foo" +} with Bar +``` + +Scala 3コンパイラでは2つのエラーを出します。: + +{% highlight text %} +-- Error: src/main/scala/early-initializer.scala:6:19 +6 |object Foo extends { + | ^ + | `extends` must be followed by at least one parent +{% endhighlight %} + +{% highlight text %} +-- [E009] Syntax Error: src/main/scala/early-initializer.scala:8:2 +8 |} with Bar + | ^^^^ + | Early definitions are not supported; use trait parameters instead +{% endhighlight %} + +トレイトパラメータを以下のように使うことが提案されています: + +```scala +trait Bar(name: String) { + val size: Int = name.size +} + +object Foo extends Bar("Foo") +``` + +Scala 2.13でトレイトパラメータは使用できないので、これはクロスコンパイルできません。 +もしクロスコンパイル方法が必要であれば、初期化された`val`と`var`をコンストラクタパラメータとして運ぶような中間クラスを使用します。 + +```scala +abstract class BarEarlyInit(val name: String) extends Bar + +object Foo extends BarEarlyInit("Foo") +``` + +このクラスのケースでは、次のように固定値の2次コンストラクタを使用することもできます: + +```scala +class Fizz private (val name: String) extends Bar { + def this() = this("Fizz") +} +``` + +## 存在型 + +存在型は[廃止された機能](/scala3/reference/dropped-features/existential-types.html)で、以下のコードは無効です。 + +```scala +def foo: List[Class[T]] forSome { type T } // Error: Existential types are no longer supported +``` + +> 存在型はScala 2.13の実験的な機能で、`import scala.language.existentials`するか、コンパイラフラグとして`-language:existentials`を設定することにより、明示的に有効にする必要があります。 + +提案された解決策として、依存型を運ぶ方を導入することです。: + +```scala +trait Bar { + type T + val value: List[Class[T]] +} + +def foo: Bar +``` + +常に可能であるとは限りませんが、ワイルドカード引数、 `_` または `?`を使用するほうが簡単な場合が多いのです。 +例えば、`List[T] forSome { type T }`を`List[?]`に置き換えることができます。 diff --git a/_ja/overviews/scala3-migration/incompat-other-changes.md b/_ja/overviews/scala3-migration/incompat-other-changes.md new file mode 100644 index 0000000000..563f4a905e --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-other-changes.md @@ -0,0 +1,289 @@ +--- +title: その他変更された機能 +type: section +description: この章では機能変更に伴い生じたすべての非互換性に関して詳細化します。 +num: 18 +previous-page: incompat-contextual-abstractions +next-page: incompat-type-checker +language: ja +--- + +その他の機能は言語をより簡単、安全、または一貫性のあるものにするために簡略化または制限されています。 + +|Incompatibility|Scala 3 Migration Rewrite| +|--- |--- | +|[Inheritance shadowing](#inheritance-shadowing)|✅| +|[Non-private constructor in private class](#non-private-constructor-in-private-class)|Migration Warning| +|[Abstract override](#abstract-override)|| +|[Case class companion](#case-class-companion)|| +|[Explicit call to unapply](#explicit-call-to-unapply)|| +|[Invisible bean property](#invisible-bean-property)|| +|[`=>T` as type argument](#-t-as-type-argument)|| +|[Wildcard type argument](#wildcard-type-argument)|| + +## 継承シャドウイング + +親クラスまたはトレイトからの継承されたメンバーは外部スコープで定義された識別子をシャドウイングすることができます。 +このパターンのことを継承シャドウイングと呼びます。 + +```scala +object B { + val x = 1 + class C extends A { + println(x) + } +} +``` + +例として、以下のコードを与えてみます。Cの中にある単項式`x`は`x`のメンバー定義を外部クラス`B`から参照することができ、また親クラス`A`の`x`のメンバー定義しても参照できます。 +どちらの参照かは`A`の定義に進むまでわかりません。 + +これはエラーが発生しやすいことで知られています。 + +そのため、Scala3では、親クラス`A`に実際にメンバー`x`がある場合、コンパイラは曖昧性解消を必要とします。 + +これにより、次のコードがコンパイルされなくなります。 + +```scala +class A { + val x = 2 +} + +object B { + val x = 1 + class C extends A { + println(x) + } +} +``` + +{% highlight text %} +-- [E049] Reference Error: src/main/scala/inheritance-shadowing.scala:9:14 +9 | println(x) + | ^ + | Reference to x is ambiguous, + | it is both defined in object B + | and inherited subsequently in class C +{% endhighlight %} + +[Scala 3移行コンパイル](tooling-migration-mode.html) は`println(x)` を`println(this.x)`に置き換えることで自動的に曖昧性解消を行います。 + +## プライベートクラスのNon privateなコンストラクタ + +Scala 3ではプライベートクラスのコンストラクタはプライベートである必要があります。 + +例としては、次のようになります。: + +```scala +package foo + +private class Bar private[foo] () {} +``` + +エラーメッセージはこのようになります。: +``` +-- Error: /home/piquerez/scalacenter/scala-3-migration-guide/incompat/access-modifier/src/main/scala-2.13/access-modifier.scala:4:19 +4 | private class Bar private[foo] () + | ^ + | non-private constructor Bar in class Bar refers to private class Bar + | in its type signature (): foo.Foo.Bar +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html) では自動的には書き換えが行われずWARNINGが与えられます。 + +クラスはプライベートであるため、この解決策としてはコンストラクタをプライベートにすることです。 + +## 抽象オーバーライド + +Scala 3では、抽象defでdefをオーバーライドすると、サブクラスはdef抽象を考慮しますが、Scala 2では具象とみなされていました。 + +次のコードでは、`C`の`bar`メソッドはScala 2.13コンパイラでは具象であるとみなされていますが、Scala 3コンパイラでは抽象的であるとみなされてるため、次のエラーが発生します。 + +```scala +trait A { + def bar(x: Int): Int = x + 3 +} + +trait B extends A { + def bar(x: Int): Int +} + +class C extends B // Error: def bar(x: Int): Int は定義されていませんので、class C は抽象である必要があります +``` + +この振る舞いは[Dotty issue #4770](https://github.com/lampepfl/dotty/issues/4770)で決定しました。 + +簡単な修正は、抽象defを削除することです。 +これは、実際にはScala 2では効果がなかったためです。 + +## ケースクラスコンパニオン + +ケースクラスのコンパニオンオブジェクトは`Function{0-23}`の特性を拡張しなくなりました。 +特に、これらのメソッドは継承しなくなりました。: `tupled`, `curried`, `andThen`, `compose`... + +例として、このコードは無効になります。: + +```scala +case class Foo(x: Int, b: Boolean) + +Foo.curried(1)(true) +Foo.tupled((2, false)) +``` + +クロスコンパイルによるソリューションはメソッド`Foo.apply`を明示的にEta展開することです。 + +{% highlight diff %} +-Foo.curried(1)(true) ++(Foo.apply _).curried(1)(true) + +-Foo.tupled((2, false)) ++(Foo.apply _).tupled((2, false)) +{% endhighlight %} + +パフォーマンス上の理由から、中間間数値を導入することもできます。 + +```scala +val fooCtr: (Int, Boolean) => Foo = (x, b) => Foo(x, b) + +fooCtr.curried(1)(true) +fooCtr.tupled((2, false)) +``` +## 明示的な`unapply`の呼び出し + +Scalaにおいて、ケースクラスには自動生成された抽象メソッドがあり、コンパニオンオブジェクトで`unapply`と呼ばれます。 +Scala 2.13とScala 3間でシグネチャが変わりました。 + +新しいシグネチャは、オプションがありません(参照として新しい[Pattern Matching](/scala3/reference/changed-features/pattern-matching.html)) 、これにより、`unapply`が明示的に呼び出されたときに非互換性が発生します。 + +この問題は、Scalaバージョン間でシグネチャが同じ状態のユーザが定義したエクストラクタには影響しないことに注意してください。 + +次のケースクラス定義があるとします。: + +```scala +case class Location(lat: Double, long: Double) +``` + +Scala 2.13コンパイラでは `unapply` メソッドを生成します : + +```scala +object Location { + def unapply(location: Location): Option[(Double, Double)] = Some((location.lat, location.long)) +} +``` + +一方でScala 3コンパイラでは以下のようにメソッドが生成されます: + +```scala +object Location { + def unapply(location: Location): Location = location +} +``` + +その結果、次のコードはコンパイルされなくなります。 + +```scala +def tuple(location: Location): (Int, Int) = { + Location.unapply(location).get // [E008] Not Found Error: value get is not a member of Location +} +``` + +考えられる解決策は、パターンバインディングを使用することです。: + +{% highlight diff %} +def tuple(location: Location): (Int, Int) = { +- Location.unapply(location).get ++ val Location(lat, lon) = location ++ (lat, lon) +} +{% endhighlight %} + +## 見えないビーンプロパティ + +`BeanProperty`アノテーションにより生成されたgetterとsetterメソッドは、主なユースケースがJavaフレームワークと相互運用性があるため、Scala 3では表示されなくなりました。 + +例として下記に示します。: + +```scala +class Pojo() { + @BeanProperty var fooBar: String = "" +} + +val pojo = new Pojo() + +pojo.setFooBar("hello") // [E008] Not Found Error: value setFooBar is not a member of Pojo + +println(pojo.getFooBar()) // [E008] Not Found Error: value getFooBar is not a member of Pojo +``` + +解決策は、より慣用的な`pojo.fooBar` getterとsetter呼び出すことです。 + +{% highlight diff %} +val pojo = new Pojo() + +-pojo.setFooBar("hello") ++pojo.fooBar = "hello" + +-println(pojo.getFooBar()) ++println(pojo.fooBar) +{% endhighlight %} + +## 型パラメータとしての`=> T` + +この`=> T`ようなフォームでは型パラメータへの引数として使用できなくなりました。 + +この決定はScala3ソースコードの[コメント](https://github.com/lampepfl/dotty/blob/0f1a23e008148f76fd0a1c2991b991e1dad600e8/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala#L144-L152)で説明しています。 + +例として、`Int => (=> Int) => Int`の関数は、型パラメータ`T2`に`=> Int` を割り当てるため、カリー化なしのメソッドにわたすことはできません。 + +``` +-- [E134] Type Mismatch Error: src/main/scala/by-name-param-type-infer.scala:3:41 +3 | val g: (Int, => Int) => Int = Function.uncurried(f) + | ^^^^^^^^^^^^^^^^^^ + |None of the overloaded alternatives of method uncurried in object Function with types + | [T1, T2, T3, T4, T5, R] + | (f: T1 => T2 => T3 => T4 => T5 => R): (T1, T2, T3, T4, T5) => R + | [T1, T2, T3, T4, R](f: T1 => T2 => T3 => T4 => R): (T1, T2, T3, T4) => R + | [T1, T2, T3, R](f: T1 => T2 => T3 => R): (T1, T2, T3) => R + | [T1, T2, R](f: T1 => T2 => R): (T1, T2) => R + |match arguments ((Test.f : Int => (=> Int) => Int)) +``` + +この解決策は状況に依存します。例として、いずれかを行うことができます。: + - 適切なシグネチャを使用して、独自の`カリー化してない`メソッドを定義します。 + - `カリー化していない`実装をローカルでインライン化する。 + +## 型引数のワイルドカード + +Scala 3ではワイルドカードの引数より種類の多い抽象型メンバーへの適用は減らすことができません。 + +この例では、コンパイルされません。 + +```scala +trait Example { + type Foo[A] + + def f(foo: Foo[_]): Unit // [E043] Type Error: unreducible application of higher-kinded type Example.this.Foo to wildcard arguments +} +``` + +型パラメータを使うことで修正できます。: + +{% highlight diff %} +-def f(foo: Foo[_]): Unit ++def f[A](foo: Foo[A]): Unit +{% endhighlight %} + +しかし、簡単な解決策では`Foo`が自身を型パラメータとして使われるときはうまくいきません。 + +```scala +def g(foos: Seq[Foo[_]]): Unit +``` + +このようなケースでは、`Foo`の周りをラップするクラスを使います。: + +{% highlight diff %} ++class FooWrapper[A](foo: Foo[A]) + +-def g(foos: Seq[Foo[_]]): Unit ++def g(foos: Seq[FooWrapper[_]]): Unit +{% endhighlight %} diff --git a/_ja/overviews/scala3-migration/incompat-syntactic.md b/_ja/overviews/scala3-migration/incompat-syntactic.md new file mode 100644 index 0000000000..f30f2a7b66 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-syntactic.md @@ -0,0 +1,222 @@ +--- +title: シンタックスの変更 +type: section +description: この章ではシンタックス変更に伴い生じたすべての非互換性について詳細化します +num: 15 +previous-page: incompatibility-table +next-page: incompat-dropped-features +language: ja +--- + +Scala 3では括弧がオプションナルなシンタックスと新しい制御構造のシンタックスが導入されています。 +これには、既存のシンタックスに最小限の制限があります。 + +他のシンタックスの変更は、意外性を減らし、一貫性を高めることを目的としています。 + +殆どの変更は、[Scala 3移行コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意してください。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| +|--- |--- |--- |--- |--- | +|[Restricted keywords](#restricted-keywords)||✅|| +|[Procedure syntax](#procedure-syntax)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[Parentheses around lambda parameter](#parentheses-around-lambda-parameter)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| +|[Open brace indentation for passing an argument](#open-brace-indentation-for-passing-an-argument)||✅|| +|[Wrong indentation](#wrong-indentation)|||| +|[`_` as a type parameter](#_-as-a-type-parameter)|||| +|[`+` and `-` as type parameters](#-and---as-type-parameters)|||| + +## 制限された予約語 + +Scala 3予約語(キーワード)のリストは[ここ](https://dotty.epfl.ch/docs/internals/syntax.html#keywords)で見ることができます。 +一般的な予約語を識別子として使用することはできませんが、半予約語は制限されていません。 + +Scala 2.13からScala 3への移行に関しては、新しい一般的な予約語の一部分のみが問題になります。 +それらは下記に列挙されています。: +- `enum` +- `export` +- `given` +- `then` +- `=>>` +- `?=>` + +次のコードはScala 2.13でコンパイルできますが、Scala 3ではコンパイルできません。 + +```scala +object given { // Error: given is now a keyword + val enum = ??? // Error: enum is now a keyword + + println(enum) // Error: enum is now a keyword +} +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のようにコードが書き直されてます。: + +{% highlight diff %} +-object given { ++object `given` { +- val enum = ??? ++ val `enum` = ??? + +- println(enum) ++ println(`enum`) +} +{% endhighlight %} + +## 手続き型構文 + +手続き型構文はしばらくの間非推奨になり、Scala 3では削除されました。 +次のコードは現在使用できません。: + +```scala +object Bar { + def print() { // Error: Procedure syntax no longer supported; `: Unit =` should be inserted here + println("bar") + } +} +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わります。 + +{% highlight diff %} +object Bar { +- def print() { ++ def print(): Unit = { + println("bar") + } +} +{% endhighlight %} + +## Lambdaパラメータを囲む括弧 + +パラメータの型が続く場合、Lambdaのパラメータを括弧で囲む必要があります。 +次のコードは無効です。 + +```scala +val f = { x: Int => x * x } // Error: parentheses are required around the parameter of a lambda +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わります: + +{% highlight diff %} +-val f = { x: Int => x * x } ++val f = { (x: Int) => x * x } +{% endhighlight %} + +## 引数を渡すための括弧のインデント + +Scala 2では改行を中括弧で囲むことで、新しい行の後に引数を渡すことができます。 +このスタイルのコーディングは有効ですが、[Scala style guide](https://docs.scala-lang.org/style) では推奨されておらず、Scala 3ではサポートされなくなりました。 + +このシンタックスは現在無効です。: +```scala +test("my test") +{ // Error: This opening brace will start a new statement in Scala 3. + assert(1 == 1) +} +``` + +[Scala 3移行コンパイル](tooling-migration-mode.html)ではブロックの最初の行をインデントします。 + +{% highlight diff %} +test("my test") +-{ ++ { + assert(1 == 1) +} +{% endhighlight %} + +この移行ルールは、改行の後に型を絞り込むなど、他のパターンに適用されます。 + +{% highlight diff %} +type Bar = Foo +- { ++ { + def bar(): Int +} +{% endhighlight %} + +望ましい解決策は次のように書くことです: + +{% highlight diff %} +-test("my test") +-{ ++test("my test") { + assert(1 == 1) +} +{% endhighlight %} + +## 間違ったインデント + +Scala 3コンパイラは現状正しいインデントを求めます。 +次のコードは、Scala 2.13ではコンパイルできたものですが、インデントを理由にコンパイルできないようになっています。 + +```scala +def bar: (Int, Int) = { + val foo = 1.0 + val bar = foo // [E050] Type Error: value foo does not take parameters + (1, 1) +} // [E007] Type Mismatch Error: Found Unit, Required (Int, Int) +``` + +このインデントは必ず修正しなければなりません。 + +{% highlight diff %} +def bar: (Int, Int) = { + val foo = 1.0 + val bar = foo +- (1, 1) ++ (1, 1) +} +{% endhighlight %} + +これらのエラーは[scalafmt](https://scalameta.org/scalafmt/) や [IntelliJ Scala formatter](https://www.jetbrains.com/help/idea/reformat-and-rearrange-code.html)などのScalaフォーマットツールを使えば防ぐことができます。 +これらのフォーマットツールはプロジェクトのコードスタイル全体を変更する可能性があるので注意してください。 + +## 型パラメータとしての`_` + +Scala 2仕様で特段言及されたことがない場合でも、型パラメータとして`_`はScala 2.13では許容されていました。 +これは[fastparse](https://index.scala-lang.org/lihaoyi/fastparse)のAPIで、コンテキストバインドと組み合わせて使用され、implicit パラメータを宣言します。 + + +```scala +def foo[_: Foo]: Unit = ??? +``` + +ここに、ワイルドカード記号としてではなく型パラメータとしての`_`と`Foo[_]`のimplictパラメータをとる`foo`メソッドがあります。 + +Martin Odersky このパターンを"scalacコンパイラのバグの巧妙な悪用"([ソース](https://www.reddit.com/r/scala/comments/fczcvo/mysterious_context_bounds_in_fastparse_2/fjecokn/))として説明していました。 + +Scala 3コンパイラはこのパターンを許容しません。: + +{% highlight text %} +-- [E040] Syntax Error: src/main/scala/anonymous-type-param.scala:4:10 +4 | def foo[_: Foo]: Unit = () + | ^ + | an identifier expected, but '_' found +{% endhighlight %} + +解決方法としては、例えば、`T`のように有効な固有名詞を型パラメータとして与えることです。 +このやり方ではバイナリ互換性は崩れないでしょう。 + +{% highlight diff %} +-def foo[_: Foo]: Unit = ??? ++def foo[T: Foo]: Unit = ??? +{% endhighlight %} + +## 型パラメータとしての`+` と `-` + +Scala 3の型パラメータとしては`+` と `-` は有効ではありません、なぜならこれらは変位指定のアノテーションとしての予約語だからです。 + +`def foo[+]` や `def foo[-]` は書くことができません。 + +{% highlight text %} +-- Error: src/main/scala/type-param-identifier.scala:2:10 +2 | def foo[+]: + + | ^ + | no `+/-` variance annotation allowed here +{% endhighlight %} + +解決方法としては、例えば、`T`のように有効な固有名詞を型パラメータとして与えることです。 + +しかしながら、`+` と `-` は一般的に有効な型識別子です。 +`type +`とは書くことができます。 diff --git a/_ja/overviews/scala3-migration/incompat-type-checker.md b/_ja/overviews/scala3-migration/incompat-type-checker.md new file mode 100644 index 0000000000..9f02f67849 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-type-checker.md @@ -0,0 +1,118 @@ +--- +title: 型チェッカー +type: section +description: この章では型チェッカーの不具合修正について詳細化します +num: 19 +previous-page: incompat-other-changes +next-page: incompat-type-inference +language: ja +--- + +Scala 2.13の型チェッカーは一部の特定のケースでは挙動がおかしいです。 +これにより、予期しない場所で予期しないランタイム時エラーなどが発生する可能性があります。 +Scala 3はより強力な理論的基盤に基づいており、型チェッカーのこれらの不健全なバグは修正されました。 + +## 分散チェックの不具合修正 + +Scala 2では、デフォルトのパラメータと内部クラスは分散チェックの対象ではありません。 +Scala 3リポジトリでのこの[テスト](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/tests/neg/variances.scala)で示されているように、健全ではなく、ランタイム時エラーを引き起こす可能性があります。 + +Scala3コンパイラは以下のコードを許容していません。 + +```scala +class Foo[-A](x: List[A]) { + def f[B](y: List[B] = x): Unit = ??? +} + +class Outer[+A](x: A) { + class Inner(y: A) +} +``` + +{% highlight text %} +-- Error: src/main/scala/variance.scala:2:8 +2 | def f[B](y: List[B] = x): Unit = y + | ^^^^^^^^^^^^^^^^^ + |contravariant type A occurs in covariant position in type [B] => List[A] of method f$default$1 +-- Error: src/main/scala/variance.scala:6:14 +6 | class Inner(y: A) + | ^^^^ + |covariant type A occurs in contravariant position in type A of parameter y +{% endhighlight %} + +この種類のそれぞれの問題は特定のケアが必要です。 +あなたはケース・バイ・ケースで選択的に解決方法をトライことができます。: +- 型`A`の内部変数を作る +- 型パラメータ`B`の上位、または下位境界を追加する +- 新しいオーバーロードメソッドを追加する + +例では、2つの解決策を選択できます。: + +{% highlight diff %} +class Foo[-A](x: List[A]) { +- def f[B](y: List[B] = x): Unit = ??? ++ def f[B](y: List[B]): Unit = ??? ++ def f(): Unit = f(x) +} + +class Outer[+A](x: A) { +- class Inner(y: A) ++ class Inner[B >: A](y: B) +} +{% endhighlight %} + +また、一時的な解決策ですが、`uncheckedVariance` アノテーションを使用することもできます。: + +{% highlight diff %} +class Outer[+A](x: A) { +- class Inner(y: A) ++ class Inner(y: A @uncheckedVariance) +} +{% endhighlight %} + +## パターンマッチングの不具合修正 + +Scala3ではいくつかのパターンマッチによるバグを修正しました、 +これはタイプチェックの意味的に間違ったmatch式を防ぎます + +たとえば、`combineReq`のmatch式は、Scala 2.13でコンパイルできますが、Scala3ではコンパイルできません。 + +```scala +trait Request +case class Fetch[A](ids: Set[A]) extends Request + +object Request { + def combineFetch[A](x: Fetch[A], y: Fetch[A]): Fetch[A] = Fetch(x.ids ++ y.ids) + + def combineReq(x: Request, y: Request): Request = { + (x, y) match { + case (x @ Fetch(_), y @ Fetch(_)) => combineFetch(x, y) + } + } +} +``` + +エラーメッセージは次のようになります: + +{% highlight text %} +-- [E007] Type Mismatch Error: src/main/scala/pattern-match.scala:9:59 +9 | case (x @ Fetch(_), y @ Fetch(_)) => combineFetch(x, y) + | ^ + | Found: (y : Fetch[A$2]) + | Required: Fetch[A$1] +{% endhighlight %} + +これは`x`と`y`が同じタイプのパラメータ`A`を持っているという証拠にはなりません。 + +Scala 2から、明らかに間違っているコードを見つけるのに便利な改善です。 +この非互換性を解決するには、コンパイラがチェックできる解決策を見つけるようにすることです。 +ただし、必ずしも簡単なわけではなく、時には不可能な場合もあり、その場合、コードはランタイム時に失敗する可能性があります。 + +この例では、`A`が両方の型引数の共通の親であると宣言することにより、`x`と`y`の制約を緩和すること示します。 +これにより、コンパイラはコードを正常に型チェックします。 + +```scala +def combineFetch[A](x: Fetch[_ <: A], y: Fetch[_ <: A]): Fetch[A] = Fetch(x.ids ++ y.ids) +``` + +一般的であり安全ではない別の解決策としてはキャストすることです。 diff --git a/_ja/overviews/scala3-migration/incompat-type-inference.md b/_ja/overviews/scala3-migration/incompat-type-inference.md new file mode 100644 index 0000000000..922635e256 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompat-type-inference.md @@ -0,0 +1,95 @@ +--- +title: 型推論 +type: section +description: この章では新しい型推論アルゴリズムにより生じる非互換性に関して詳細化します +num: 20 +previous-page: incompat-type-checker +next-page: options-intro +language: ja +--- + +型インタフェースに伴うルールの内部的変更による、2つの非互換性についてこのページでは説明します。 + +他の非互換性に関しては型インタフェースのアルゴリズムの書き換えにより生じてしまいます。 +新しいアルゴリズムは古いやつよりも良いのですが、一部Scala 2.13で成功していたものが落ちてしまうときがあります。: + +> 明示的にメソッドやパブリックな変数に対して返り値の型を書くことは常に良い習慣であります。 +> 推測される型が異なる場合があるため、ライブラリのパブリックAPIがScalaバージョンにより変更されるのを防ぎます。 +> +> これはScalafixの[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)のルールを使用してScala3の移行前に行うことができます。 + +## オーバーライドしたメソッドの返り値の型 + +Scala 3でオーバーライドメソッドの返却値の型はベースメソッドからの継承により推論されますが、Scala 2.13では、オーバーライドメソッドの左側から推測されます。 + +```scala +class Parent { + def foo: Foo = new Foo +} + +class Child extends Parent { + override def foo = new RichFoo(super.foo) +} +``` + +この例では、Scala 2.13では`Child#foo`メソッドは`RichFoo`を返却しますが、Scala 3では`Foo`を返却します。 +以下に示すように、コンパイラエラーが発生する可能性があります。 + +```scala +class Foo + +class RichFoo(foo: Foo) extends Foo { + def show: String = "" +} + +class Parent { + def foo: Foo = new Foo +} + +class Child extends Parent { + override def foo = new RichFoo(super.foo) +} + +(new Child).foo.show // Scala 3 error: value show is not a member of Foo +``` + +In some rare cases involving implicit conversions and runtime casting it could even cause a runtime failure. + +The solution is to make the return type of the override method explicit: + +{% highlight diff %} +class Child extends Parent { +- override def foo = new RichFoo(super.foo) ++ override def foo: RichFoo = new RichFoo(super.foo) +} +{% endhighlight %} + +## リフレクションの型 + +Scala 2のリフレクションの呼び出しは削除され、より広範な[プログラマティック構造型](/scala3/reference/changed-features/structural-types.html)に置き換えられています。 + +Scala 3は`scala.language.reflectiveCalls`がインポートされている場所ならどこでも`scala.reflect.Selectable.reflectiveSelectable`を利用可能にすることで、Scala 2のリフレクションの呼び出しを模倣することができます。 +ただし、Scala 3コンパイラーはデフォルトでは構造型を推測しないため、コンパイルに失敗します。: + +```scala +import scala.language.reflectiveCalls + +val foo = new { + def bar: Unit = ??? +} + +foo.bar // Error: value bar is not a member of Object +``` + +簡単な解決策は、構造タイプを明示的に書き留めておくことです。 + +{% highlight diff %} +import scala.language.reflectiveCalls + +- val foo = new { ++ val foo: { def bar: Unit } = new { + def bar: Unit = ??? +} + +foo.bar +{% endhighlight %} diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md new file mode 100644 index 0000000000..9cace32a94 --- /dev/null +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -0,0 +1,127 @@ +--- +title: 非互換性テーブル +type: chapter +description: この章ではScala 2.13とScala 3間の全ての既知な非互換性をリスト化します +num: 14 +previous-page: tooling-syntax-rewriting +next-page: incompat-syntactic +language: ja +--- + +非互換性とは、Scala 2.13でコンパイルできるがScala 3ではなできないコードの一部のことです。 +コードベースの移行には、ソースコードの全ての非互換性を見つけて修正することが含まれています。 +極稀に、我々はランタイム時の非互換性に遭遇します：動作が異なるコードの一部です。 + +このページでは我々は既知の非互換性の分類を提案します。 +それぞれの非互換性は以下のように説明されています。: + - 詳細な説明と提案された解決策へのリンクを含む名前 + - Scala 2.13コンパイラが非推奨または機能WARNINGを発するかどうか + - 非互換性に関しての[Scala 3移行](tooling-migration-mode.html)ルールの存在 + - 非互換性に関して修正できるScalafixルールの存在 + +> #### Scala2.13の非推奨と機能WARNING +> 2.13コンパイルを`-source:3`で実行すると非互換性のコードを見つけます。 + +> #### Scala 3移行とScalafixリライトの比較 +> Scala3移行モードはすぐに使用できます。 +> それに対して、Scalafixは手動でインストールして構成する必要があるツールです。 +> ただし、Scalafixには独自の利点があります。: +> - Scala 2.13で動く +> - 一度に1つずつ適用することができる個々のルールで構成されている +> - カスタムルールの追加により拡張が容易である + +### シンタックスの変更 + +いくつかの古い構文はサポートされていないです。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| +|--- |--- |--- |--- |--- | +|[Restricted keywords](incompat-syntactic.html#restricted-keywords)||✅|| +|[Procedure syntax](incompat-syntactic.html#procedure-syntax)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[Parentheses around lambda parameter](incompat-syntactic.html#parentheses-around-lambda-parameter)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| +|[Open brace indentation for passing an argument](incompat-syntactic.html#open-brace-indentation-for-passing-an-argument)||✅|| +|[Wrong indentation](incompat-syntactic.html#wrong-indentation)|||| +|[`_` as a type parameter](incompat-syntactic.html#_-as-a-type-parameter)|||| +|[`+` and `-` as type parameters](incompat-syntactic.html#-and---as-type-parameters)|||| + +### 機能の削除 + +いくつかの機能は言語を簡単にするために削除されています。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| +|--- |--- |--- |--- | +|[Symbol literals](incompat-dropped-features.html#symbol-literals)|Deprecation|✅|| +|[`do`-`while` construct](incompat-dropped-features.html#do-while-construct)||✅|| +|[Auto-application](incompat-dropped-features.html#auto-application)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| +|[Value eta-expansion](incompat-dropped-features.html#value-eta-expansion)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[`any2stringadd` conversion](incompat-dropped-features.html#any2stringadd-conversion)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| +|[Early initializer](incompat-dropped-features.html#early-initializer)|Deprecation||| +|[Existential type](incompat-dropped-features.html#existential-type)|Feature warning||| + +### コンテキストの抽象化 + +[コンテキストの抽象化]({% link _scala3-reference/contextual.md %})の再設計は明確に定義された非互換性が発生します。 + +|Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibility| +|--- |--- |--- |--- |--- | +|[Type of implicit def](incompat-contextual-abstractions.html#type-of-implicit-definition)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| +|[Implicit views](incompat-contextual-abstractions.html#implicit-views)||||**Possible**| +|[View bounds](incompat-contextual-abstractions.html#view-bounds)|Deprecation|||| +|[Ambiguous conversion on `A` and `=> A`](incompat-contextual-abstractions.html#ambiguous-conversion-on-a-and--a)||||| + +さらに、暗黙の解決ルールを変更して、より便利で意外なものにならないようにしました。 +新しいルールについては[ここ](/scala3/reference/changed-features/implicit-resolution.html)に説明しています。 + +これらの変更により、Scala 3コンパイラーは、既存のScala 2.13コードのいくつかの暗黙的なパラメーターの解決に失敗する可能性があります。 + +### その他の変更した機能 + +他のいくつかの機能は、言語をより簡単に、より安全に、またはより一貫性のあるものにするために簡略化または制限されています。 + +|Incompatibility|Scala 3 Migration Rewrite| +|--- |--- | +|[Inheritance shadowing](incompat-other-changes.html#inheritance-shadowing)|✅| +|[Non-private constructor in private class](incompat-other-changes.html#non-private-constructor-in-private-class)|Migration Warning| +|[Abstract override](incompat-other-changes.html#abstract-override)|| +|[Case class companion](incompat-other-changes.html#case-class-companion)|| +|[Explicit call to unapply](incompat-other-changes.html#explicit-call-to-unapply)|| +|[Invisible bean property](incompat-other-changes.html#invisible-bean-property)|| +|[`=>T` as type argument](incompat-other-changes.html#-t-as-type-argument)|| +|[Wildcard type argument](incompat-other-changes.html#wildcard-type-argument)|| + +### 型チェッカー + +Scala 2.13の型チェッカーはある特定のケースに関して解決できないです。 +これは思いもしない驚異的なランタイム時エラーを導いてしまいます。 +Scala 3は強力で理論的な基盤に基づいているため、型チェッカーのこれらの不健全なバグが修正されました。 + +|Incompatibility| +|--- | +|[Variance checks](incompat-type-checker.html#unsoundness-fixes-in-variance-checks)| +|[Pattern matching](incompat-type-checker.html#unsoundness-fixes-in-pattern-matching)| + +### 型推論 + +いくつかの固有の型推論のルールはScala 2.13とScala 3の間で変更されました + +|Incompatibility| +|--- | +|[Return type of override method](incompat-type-inference.html#return-type-of-an-override-method)| +|[Reflective type](incompat-type-inference.html#reflective-type)| + +また、型推論アルゴリズムは全体的な再設計を行い改善されました。 +この根本的な変更により、いくつかの非互換性が生じます。: +- 別の型で推測することがあります +- 新しい型チェックエラーが表示される場合があります + +> すべてのパブリックな値とメソッドの結果の型を明示的に記述することは良い習慣です。 +> この習慣は、推測されるタイプが異なり、ライブラリのパブリックAPIがScalaバージョンで変更されるのを防ぎます。 +> +> これは、Scalafixの[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)ルールを使用して、Scala3の移行前に行うことができます. + +### マクロ + +Scala 3コンパイラはScala 2.13マクロを展開することはできません。 +このような状況では、新しいScala 3メタプログラミング機能を使用して、Scala 2.13マクロを再実装する必要があります。 + +[メタプログラミング](compatibility-metaprogramming.html) のページに戻れば新しいメタプログラミング機能について学ぶことができます diff --git a/_ja/overviews/scala3-migration/options-intro.md b/_ja/overviews/scala3-migration/options-intro.md new file mode 100644 index 0000000000..5a502fcaed --- /dev/null +++ b/_ja/overviews/scala3-migration/options-intro.md @@ -0,0 +1,22 @@ +--- +title: コンパイラオプション +type: chapter +description: この章ではScala 2.13とScala 3間のコンパイラオプションの違いについて示します +num: 21 +previous-page: incompat-type-inference +next-page: options-lookup +language: ja +--- + +Scala 3コンパイラは0から書き直されたため、Scala 2.13コンパイラと同じオプションは提供されません。 +別の名前で利用できるオプションもあれば、まだ実装されていないオプションもあります。 + +Scala 2.13プロジェクトをScala 3に移植した時、コンパイラオプションのリストを適用させる必要があるでしょう +適用させるために[ルックアップテーブル](options-lookup.html)を参照してください。 + +> 利用できないオプションをScala 3コンパイラーに渡しても、失敗することはありません。 +> WARNINGを出力し、指定したオプションを無視します。 + +[新しいコンパイラオプション](options-new.html)のページで、Scala 2.13にはないScala 3の新しいオプションを見つけることができます。 + +scaladoc設定のリファレンスとScala2scaladocとの互換性については、[ScaladocについてScala2とScala3間における互換性設定](scaladoc-settings-compatibility.html)ページをご覧ください。 diff --git a/_ja/overviews/scala3-migration/options-lookup.md b/_ja/overviews/scala3-migration/options-lookup.md new file mode 100644 index 0000000000..750d0dd987 --- /dev/null +++ b/_ja/overviews/scala3-migration/options-lookup.md @@ -0,0 +1,271 @@ +--- +title: コンパイラオプションのルックアップテーブル +type: section +description: このセクションではコンパイラオプションのルックアップテーブルが含まれています +num: 22 +previous-page: options-intro +next-page: options-new +language: ja +--- + +コンパイラオプションは、Scala 2.13の名前に従って分類および順序付けしています。 +各Scala 2.13オプションは、Scala 3でのステータスを関連付けています。 + +| Status | Meaning | +|-|-| +| | Scala 3で利用可能です | +| `` | ``に変名しました | +| | 3.0.0では利用できませんが後から追加でしょう | + +> 現状の比較に関しては2.13.4と3.0.0-M3で比較しています。 + +## 基本設定 + +| 2.13.x | 3.0.x | +|-|-| +| `-Dproperty=value` | | +| `-J` | | +| `-P::` || +| `-V` | | +| `-W` | | +| `-X` || +| `-Y` || +| `-bootclasspath` || +| `-classpath` || +| `-d` || +| `-dependencyfile` | | +| `-deprecation` || +| `-encoding` || +| `-explaintypes` | `-explain-types` | +| `-extdirs` || +| `-feature` || +| `-g` | | +| `-help` || +| `-javabootclasspath` || +| `-javaextdirs` || +| `-language` || +| `-no-specialization` | | +| `-nobootcp` | | +| `-nowarn` || +| `-opt` | | +| `-opt-inline-from` | | +| `-opt-warnings` | | +| `-optimize` | | +| `-print` || +| `-release` || +| `-rootdir` | | +| `-sourcepath` || +| `-target` | `-Xtarget` | +| `-toolcp` | | +| `-unchecked` || +| `-uniqid` || +| `-usejavacp` || +| `-usemanifestc` | | +| `-verbose` || +| `-version` || + +## 拡張設定 + +| 2.13.x | 3.0.x | +|-|-| +| `-X` || +| `-Xcheckinit` | `-Ycheck-init` | +| `-Xdev` | | +| `-Xdisable-assertions` | | +| `-Xelide-below` | | +| `-Xexperimental` | | +| `-Xfuture` | | +| `-Xgenerate-phase-graph` | | +| `-Xjline` | | +| `-Xlint:deprecation` | `-deprecation` | +| `-Xlint:` | | +| `-Xlog-implicit-conversion` | | +| `-Xlog-implicits` | | +| `-Xlog-reflective-calls` | | +| `-Xmacro-settings` | | +| `-Xmain-class` | | +| `-Xmaxerrs` | | +| `-Xmaxwarns` | | +| `-Xmigration` || +| `-Xmixin-force-forwarders` || +| `-Xno-forwarders` || +| `-Xno-patmat-analysis` | | +| `-Xnojline` | | +| `-Xplugin` || +| `-Xplugin-disable` || +| `-Xplugin-list` || +| `-Xplugin-require` || +| `-Xpluginsdir` || +| `-Xprint-args` | | +| `-Xprompt` || +| `-Xreporter` | | +| `-Xresident` | | +| `-Xscript` | | +| `-Xshow-class ` | | +| `-Xshow-object ` | | +| `-Xsource` | `-source` | +| `-Xsource-reader` | | +| `-Xverify` | `-Xverify-signatures` | +| `-Xxml` | | + +## プライベート設定 + +| 2.13.x | 3.0.x | +|-|-| +| `-Ybackend-parallelism` | | +| `-Ybackend-worker-queue` | | +| `-Ybreak-cycles` | | +| `-Ycache-macro-class-loader` | | +| `-Ycache-plugin-class-loader` | | +| `-Ycheck` || +| `-Ycompact-trees` | | +| `-Ydelambdafy` | | +| `-Ydump-classes` || +| `-Ygen-asmp` | | +| `-Yhot-statistics` | | +| `-Yide-debug` | | +| `-Yimports` | | +| `-Yissue-debug` | | +| `-Yjar-compression-level` | | +| `-YjarFactory` | | +| `-Ymacro-debug-lite` | | +| `-Ymacro-debug-verbose` | | +| `-Ymacro-annotations` | | +| `-Ymacro-classpath` | | +| `-Ymacro-expand` | | +| `-Ymacro-global-fresh-names` | | +| `-Yno-completion` | | +| `-Yno-flat-classpath-cache` | | +| `-Yno-generic-signatures` || +| `-Yno-imports` || +| `-Yno-predef` || +| `-Yopt-inline-heuristics` | | +| `-Yopt-log-inline ` | | +| `-Yopt-trace ` | | +| `-Ypatmat-debug` | | +| `-Ypatmat-exhaust-depth` | | +| `-Ypos-debug` | | +| `-Ypresentation-any-thread` | | +| `-Ypresentation-debug` | | +| `-Ypresentation-delay` | | +| `-Ypresentation-locate-source-file` | | +| `-Ypresentation-log` | | +| `-Ypresentation-strict` | | +| `-Ypresentation-verbose` | | +| `-Yprint-trees` | | +| `-Yprofile-destination` || +| `-Yprofile-enabled` || +| `-Yprofile-trace` | | +| `-Yquasiquote-debug` | | +| `-Yrangepos` | | +| `-Yrecursion` | | +| `-Yreify-copypaste` | | +| `-Yreify-debug` | | +| `-Yrepl-class-based` | | +| `-Yrepl-outdir` | | +| `-Yrepl-use-magic-imports` | | +| `-Yresolve-term-conflict` || +| `-Yscriptrunner` | | +| `-Yskip` || +| `-Yshow:` | | +| `-Yshow-member-pos ` | | +| `-Yshow-symkinds` | | +| `-Yshow-symowners` | | +| `-Yshow-syms` | | +| `-Ystatistics ` | | +| `-Ystop-after` || +| `-Ystop-before` || +| `-Ytyper-debug` | | +| `-Yvalidate-pos` | | +| `-Ywarn-dead-code` | | +| `-Ywarn-numeric-widen` | | +| `-Ywarn-unused:` | | +| `-Ywarn-value-discard` | | + +## 詳細設定 + +2.13では詳細設定が導入されていました。 +その殆どに関してScala 3ではまだ実装されていません。 + +| 2.13.x | 3.0.x | +|-|-| +| `-Vbrowse:` | | +| `-Vdebug-tasty` | | +| `-Vdoc` | | +| `-Vfree-terms` | | +| `-Vfree-types` | | +| `-Vhot-statistics`| | +| `-Vide`| | +| `-Vimplicit-conversions`| | +| `-Vimplicits`| | +| `-Vinline ` | | +| `-Vissue`| | +| `-Vmacro` | | +| `-Vmacro-lite` | | +| `-Vopt ` | | +| `-Vpatmat` | | +| `-Vpos`| | +| `-Vprint:` | `-Xprint:` | +| `-Vphases` | `-Xshow-phases` | +| `-Vclasspath` | `-Ylog-classpath` | +| `-Vlog:` | `-Ylog:`| +| `-Vdebug` | `-Ydebug` | +| `-Vprint-args ` | | +| `-Vprint-pos` | `-Yprint-pos` | +| `-Vprint-types` | `-Xprint-types` | +| `-Vquasiquote` | | +| `-Vreflective-calls` | | +| `-Vreify` | | +| `-Vshow:` | | +| `-Vshow-class ` | | +| `-Vshow-member-pos ` | | +| `-Vshow-object ` | | +| `-Vshow-symkinds` | | +| `-Vshow-symowners` | | +| `-Vstatistics ` | | +| `-Vsymbols` | | +| `-Vtyper` | | + +## Warning設定 + +Warningの設定は2.13で導入されていました。 +その殆どに関してScala 3ではまだ実装されていません。 + +| 2.13.x | 3.0.x | +|-|-| +| `-Wconf` | | +| `-Wdead-code` | | +| `-Werror` | `-Xfatal-warnings` | +| `-Wextra-implicit` | | +| `-Wmacros:` | | +| `-Wnumeric-widen` | | +| `-Woctal-literal` | | +| `-Wunused:` | | +| `-Wvalue-discard`| | +| `-Wself-implicit` | | + +## コンパイラプラグイン + +いくつかの便利なScala 2.13コンパイラプラグインはScala 3コンパイラに同梱されています。 +いくつかの新しいネイティブオプションを使用して、有効にできます。 + +### Scala.js + +| 2.13.x | 3.0.x | +|-|-| +| `-Xplugin:scalajs-compiler_.jar` | `-scalajs` | +| `-P:scalajs:genStaticForwardersForNonTopLevelObjects` | `-scalajs-genStaticForwardersForNonTopLevelObjects` | +| `-P:scalajs:mapSourceURI`| `-scalajs-mapSourceURI`| + +### SemanticDB + +| 2.13.x | 3.0.x | +|-|-| +| `-Xplugin:semanticdb-scalac_.jar`| `-Xsemanticdb` | +| `-P:semanticdb:targetroot:` | `-semanticdb-target:` | + +### Kind-Projector + +| 2.13.x | 3.0.x | +|-|-| +| `-Xplugin:kind-projector_.jar` | `-Ykind-projector` | diff --git a/_ja/overviews/scala3-migration/options-new.md b/_ja/overviews/scala3-migration/options-new.md new file mode 100644 index 0000000000..3b7be35db6 --- /dev/null +++ b/_ja/overviews/scala3-migration/options-new.md @@ -0,0 +1,98 @@ +--- +title: 新しいコンパイラオプション +type: section +description: この章ではScala 3の全ての新しいコンパイラオプションをリスト化します +num: 23 +previous-page: options-lookup +next-page: scaladoc-settings-compatibility +language: ja +--- + +現在のページには、Scala 3.0.xで追加されたオプションのみが含まれています。 + +## 基本設定 + +| 3.0.x | description | +|-|-| +| `-color` | 出力の色付け Default: always. | +| `-doc-snapshot` | 現在のDottyのバージョン用のドキュメントのスナップショットを生成します| +| `-explain` | エラーの詳細を説明します。 | +| `-from-tasty` | TASTyファイルのクラスコンパイル. 引数は .tasty または .jar ファイル. | +| `-indent` | -rewriteと一緒に使います, 重要なインデントのために可能な場合は {...} シンタックスを削除します。 | +| `-new-syntax` | 制御式に `then` と `do` が必要になります。 | +| `-no-indent` | クラシックな {...} シンタックスが必要で, インデントは重要ではないです | +| `-old-syntax` | 条件の周りに`(...)`が必要です。 | +| `-pagewidth` | ページ幅の設定 Default: 80. | +| `-print-lines` | ソースコードの行数を表示します。 | +| `-print-tasty` | 生のTASTyを表示します。 | +| `-project` | プロジェクトの名前。 | +| `-project-logo` | プロジェクトロゴ (in /imagesにある)を含めます。 | +| `-project-url` | プロジェクトのリポジトリ | +| `-project-version` | プロジェクトの現行バージョン | +| `-rewrite` | `...-migration` ソースバージョンと組み合わせて使用​​する場合, ソースを最新バージョンに移行させます。 | +| `-siteroot` | ドキュメントを生成する静的ファイルを含むディレクトリ Default: ./docs. | +| `-sourceroot` | ワークスペースのルートディレクトリを指定します。 Default: .. | + +## 拡張設定 + +| 3.0.x | description | +|-|-| +| `-Xignore-scala2-macros` | Scala 2マクロを呼び出すコードをコンパイルするときのエラーを無視しますがランタイム時に失敗するでしょう。 | +| `-Ximport-suggestion-timeout` | エラーが報告されたときにインポート候補を検索するためのタイムアウト（ミリ秒単位）。 | +| `-Xmax-inlined-trees` | インラインツリーの最大数。 Default: 2000000 | +| `-Xmax-inlines` | 連続するインラインの最大数。 Default: 32. | +| `-Xprint-diff` | 前回のプリント出力以降に変更されたツリーの部分をプリント出力します。 | +| `-Xprint-diff-del` | 削除された部分を含め、最後のプリント出力した以降に変更されたツリーの部分をプリント出力します。 | +| `-Xprint-inline` | インライン化されたコードがどこから来たのかを示します。 | +| `-Xprint-suspension` | マクロがコンパイルされるまでコードが一時停止されるタイミングを表示します。 | +| `-Xrepl-disable-display` | REPLで定義を表示しません。 | +| `-Xwiki-syntax` | ScaladocでWiki構文を使用するScala2の動作を保持します。 | + +## プライベート設定 + +| 3.0.x | description | +|-|-| +| `-Ycheck-all-patmat` | すべてのパターンマッチング（アルゴリズムのテストに使用）の網羅性と冗長性を確認します。| +| `-Ycheck-mods` | シンボルとその定義ツリーに修正が同期していることを確認します。 | +| `-Ycheck-reentrant` | コンパイルされたプログラムに、グローバルルートからアクセスできる変数が含まれていないことを確認します。 | +| `-Ycook-comments` | コメントを調整します（型チェック `@ usecase`など） | +| `-Ydebug-error` | エラーが検出されたときにスタックトレースをプリント出力します。 | +| `-Ydebug-flags` | 定義のすべてのフラグをプリント出力します。 | +| `-Ydebug-missing-refs` | 必要なシンボルが欠落している場合は、スタックトレースにプリント出力します。 | +| `-Ydebug-names` | 名前の内部表現を表示します。 | +| `-Ydebug-pos` | スパンを含む完全なソース位置を表示します。 | +| `-Ydebug-trace` | トレースのコアオプションです。 | +| `-Ydebug-tree-with-id` | 指定されたIDのツリーが作成されたときに、スタックトレースをプリント出力します。 Default: -2147483648. | +| `-Ydebug-type-error` | TypeErrorがキャッチされたときにスタックトレースをプリント出力します | +| `-Ydetailed-stats` | 詳細な内部コンパイラ統計を表示します（別途Stats.enabledをtrueに設定する必要があります）。 | +| `-YdisableFlatCpCaching` | コンパイラインスタンス間でjarからのクラスパス要素のフラットクラスパス表現をキャッシュさせません。 | +| `-Ydrop-comments` | ソースファイルをスキャンするときにコメントを削除します。 | +| `-Ydump-sbt-inc` | コンパイルされたすべてのfoo.scalaについて、foo.incでsbtインクリメンタルコンパイルに使用されるAPI表現と依存関係をプリント出力します。これは-Yforce-sbt-phasesを意味します。 | +| `-Yerased-terms` | 消去された用語の使用を許可します。 | +| `-Yexplain-lowlevel` | タイプエラーを説明するときは、タイプを下位レベルで表示します。　| +| `-Yexplicit-nulls` | 参照型をNULL不可にします。null許容型は、ユニオンで表すことができます。: e.g. String|Null. | +| `-Yforce-sbt-phases` | デバッグ用で、コンパイラがsbtの外部で実行されている場合でも、インクリメンタルコンパイル（ExtractDependenciesおよびExtractAPI）します。 | +| `-Yfrom-tasty-ignore-list` | -from-tastyの使用時にロードされないjarファイル内の `tasty`ファイルのリストを指定 | +| `-Yindent-colons` | 行末のコロンがインデントブロックを開始できるようにします。 | +| `-Yinstrument` | 割り当てとクロージャーの作成をカウントするインストルメンテーションコードを追加します。 | +| `-Yinstrument-defs` | メソッド呼び出しをカウントするインストルメンテーションコードを追加します。 -Yinstrumentも設定する必要があります。 | +| `-Yno-decode-stacktraces` | トリガー操作にデコードする代わりに、生のStackOverflowスタックトレースを実行します | +| `-Yno-deep-subtypes` | 深いサブタイプの呼び出しスタックで例外をスローします。 | +| `-Yno-double-bindings` | 名前付き型が2回バインドされていないことをアサートします（プログラムにエラーがない場合にのみ有効にする必要があります）。 | +| `-Yno-kind-polymorphism` | 種類のポリモーフィズムを無効にします。 | +| `-Yno-patmat-opt` | すべてのパターンマッチングの最適化を無効にします。 | +| `-Yplain-printer` | Pretty-printを使用してきれいにプリント出力します。 | +| `-Yprint-debug` | ツリーのプリント出力時に, デバッグ用にその他の便利な情報を出力します。 | +| `-Yprint-debug-owners` | ツリーのプリント出力時に, 定義の所有者をプリント出力します。 | +| `-Yprint-pos` | ツリーの場所を表示します。 | +| `-Yprint-pos-syms` | シンボル定義の場所を表示します。 | +| `-Yprint-syms` | ツリーをプリント出力する場合、ツリー内の対応する情報ではなく、シンボルで情報をプリント出力します | +| `-Yrequire-targetName` | @targetNameアノテーションなしで定義しているのがあればWARNINGします。 | +| `-Yretain-trees` | ClassSymbol＃treeからアクセス可能なトップレベルクラスのツリーを保持します。 | +| `-Yscala2-unpickler` | Scala2シンボルをどこから取得できるかを制御します。"always", "never", またはクラスパスのどれかを指定できます。 Default: always. | +| `-Yshow-print-errors` | ツリーのプリント出力時に投げられる例外を抑制しないようにします。 | +| `-Yshow-suppressed-errors` | 通常は抑制されている後続のエラーとWARNINGを表示します. | +| `-Yshow-tree-ids` | デバッグ出力ですべてのツリーノードに一意にタグを付けます。 | +| `-Yshow-var-bounds` | 型変数とその境界をプリント出力します。 | +| `-Ytest-pickler` | 関数的なpicklingにおける自己テスト; -Ystop-after:picklerと一緒に使われるべきです。 | +| `-Yunsound-match-types` | 不健全なmatchタイプの削減アルゴリズムを使用します。| diff --git a/_ja/overviews/scala3-migration/plugin-intro.md b/_ja/overviews/scala3-migration/plugin-intro.md new file mode 100644 index 0000000000..66ffd08110 --- /dev/null +++ b/_ja/overviews/scala3-migration/plugin-intro.md @@ -0,0 +1,12 @@ +--- +title: コンパイラプラグイン +type: chapter +description: このセクションではScala 2コンパイラプラグインを用いて移行する方法を示します +num: 25 +previous-page: options-new +next-page: plugin-kind-projector +language: ja +--- + +Scala 3には、以前のコンパイラプラグインにより提供されていた、いくつかの機能が含まれています。 +この章では、使用している特定のコンパイラプラグインをScala3に移行する方法について詳しく説明します。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/plugin-kind-projector.md b/_ja/overviews/scala3-migration/plugin-kind-projector.md new file mode 100644 index 0000000000..dc73f20c15 --- /dev/null +++ b/_ja/overviews/scala3-migration/plugin-kind-projector.md @@ -0,0 +1,128 @@ +--- +title: Kind Projector移行 +type: section +description: このセクションではkind-projector pluginからScala 3のkind-projectorシンタックスに移行する方法を示します +num: 26 +previous-page: plugin-intro +next-page: external-resources +language: ja +--- + +将来的には、Scala3は型ラムダのプレースホルダーに `_`アンダースコア記号を使用する予定です---アンダースコアは現在（通常の）用語レベルのラムダのプレースホルダーに使用されているのと同じです。 + +新しい型ラムダのシンタックスはデフォルトでは有効になっていません。有効にするには、コンパイラフラグ `-Ykind-projector：underscores`を使用します。 アンダースコアの型ラムダを有効にすると、ワイルドカードとしての `_`の使用が無効になり、`?`記号を使用してのみワイルドカードを書き込むことができるということに注意してください。 + +アンダースコアの型ラムダを使用しながらScala 2とScala 3のプロジェクトをクロスコンパイルする場合は、 [kind-projector](https://github.com/typelevel/kind-projector) バージョンで`0.13.0`以上から開始することができ、Scala 2 バージョンは `2.13.6`と `2.12.14`が必要です。 +有効にするには、コンパイラフラグ `-Xsource:3 -P:kind-projector:underscore-placeholders` をビルドに追加します。 +Scala 3と同様、この設定によりワイルドカードとしての `_`の使用が無効になりますが、フラグ`-Xsource:3`を使用すると、`?`記号に置き換えることができます。 + +次の `sbt`構成は、新しいシンタックスでクロスコンパイルするための正しいフラグを設定します。 + +```scala +ThisBuild / scalacOptions ++= { + CrossVersion.partialVersion(scalaVersion.value) match { + case Some((3, _)) => Seq("-Ykind-projector:underscores") + case Some((2, 13)) | Some((2, 12)) => Seq("-Xsource:3", "-P:kind-projector:underscore-placeholders")) + } +} +``` + +## 新しいシンタックスの移行 + +既存のkind-projector対応コードで型ラムダにアンダースコアを使用するには、`*` または `?` を用いている型ラムダのプレースホルダを`_`に置き換えます。 + +次に、`?`記号を使用するには、ワイルドカードとしての`_`のすべての使用方法を書き直す必要があります。 + +たとえば、次のワイルドカードの使用方法をあげます: + +```scala +def getWidget(widgets: Set[_ <: Widget], name: String): Option[Widget] = widgets.find(_.name == name) +``` + +必ず書き直します: + +```scala +def getWidget(widgets: Set[? <: Widget], name: String): Option[Widget] = widgets.find(_.name == name) +``` + +そしてkind-projectorの`*`プレースホルダを使用します: + +```scala +Tuple2[*, Double] // equivalent to: type R[A] = Tuple2[A, Double] +Either[Int, +*] // equivalent to: type R[+A] = Either[Int, A] +Function2[-*, Long, +*] // equivalent to: type R[-A, +B] = Function2[A, Long, B] +``` + +必ず書き直す必要があります: + +```scala +Tuple2[_, Double] // equivalent to: type R[A] = Tuple2[A, Double] +Either[Int, +_] // equivalent to: type R[+A] = Either[Int, A] +Function2[-_, Long, +_] // equivalent to: type R[-A, +B] = Function2[A, Long, B] +``` + +## 既存コードのコンパイル + +アンダースコアの型ラムダに移行しなくても、ほとんどを変更せずにScala 3でコンパイルできる可能性があります。 + +`-Ykind-projector`フラグを使用して`*`ベースの型ラムダのサポートを有効にします (アンダースコアの型ラムダを有効にしないで)、次のフォームがコンパイルされます。: + +```scala +Tuple2[*, Double] // equivalent to: type R[A] = Tuple2[A, Double] +Either[Int, +*] // equivalent to: type R[+A] = Either[Int, A] +Function2[-*, Long, +*] // equivalent to: type R[-A, +B] = Function2[A, Long, B] +``` + +## 非互換性構造の再記述 + +Scala 3の`-Ykind-projector` と `-Ykind-projector:underscores` は、`kind-projector`シンタックスの部分集合のみを実装し、それ以外は特に実装しません。: + +* より種類の多い型ラムダのプレースホルダ +* より種類の多い名前付き型ラムダパラメーター +* `Lambda`予約後(`λ`はまだサポートされています) + +次のすべてのフォームを書き直す必要があります: + +```scala +// classic +EitherT[*[_], Int, *] // equivalent to: type R[F[_], B] = EitherT[F, Int, B] +// underscores +EitherT[_[_], Int, _] // equivalent to: type R[F[_], B] = EitherT[F, Int, B] +// named λ +λ[(F[_], A) => EitherT[F, Int, A]] +// named Lambda +Lambda[(F[_], A) => EitherT[F, Int, A]] +``` + +Scala 3とクロスコンパイルするための次の形式にします: + +```scala +type MyLambda[F[_], A] = EitherT[F, Int, A] +MyLambda +``` + +また、クロスコンパイルする必要がない場合は、Scala 3の[Native Type Lambdas](https://dotty.epfl.ch/docs/reference/new-types/type-lambdas.html) を使用することができます。: + +```scala +[F[_], A] =>> EitherT[F, Int, A] +``` + +`Lambda`の場合、次のフォームを書き直す必要があります: + +```scala +Lambda[(`+E`, `+A`) => Either[E, A]] +``` + +クロスコンパイルするには以下に書く必要があります: + +```scala +λ[(`+E`, `+A`) => Either[E, A]] +``` + +または、Scala 3の型ラムダの代わりに以下を使います: + +```scala +[E, A] =>> Either[E, A] +``` + +Note: Scala 3の型ラムダは、パラメーターに`-`または`+`の分散マーカーを必要としなくなりました。これらは推測されるようになりました。 diff --git a/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md new file mode 100644 index 0000000000..b761ab3f4d --- /dev/null +++ b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md @@ -0,0 +1,85 @@ +--- +title: Scala2とScala3間のScaladoc設定の互換性 +type: section +description: この章ではScala 2とScala 3の全てのscaladocオプションをリスト化し、両者の関係性について説明します +num: 24 +previous-page: options-new +next-page: plugin-intro +language: ja +--- + +現在のページには、scaladoc設定のステータスが記載されています。関連するGithub issueは[discussion](https://github.com/lampepfl/dotty/issues/11907)で見つけることができます。 + + +| Scala2 | Scala3 | Description | Comment | Is implemented? +| ------------- | ------------- | --- | --- | --- | +| -doc-format | _ | Selects in which format documentation is rendered. | Actually, old scaladoc supports only html, so it is in some way consistent with new scaladoc, which provides only html | | +| -doc-title | -project | The overall name of the Scaladoc site | Aliased in [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| -doc-version | -project-version | | Aliased in [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| -doc-footer | -project-footer | A footer on every Scaladoc page, by default the EPFL/Lightbend copyright notice. Can be overridden with a custom footer. | Fixed by [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| -doc-no-compile | _ | A directory containing sources which should be parsed for docstrings without compiling (e.g. AnyRef.scala) | We don't need this as we have completely different approach to that issue using -Ydocument-synthetic-types flag for synthetic types | | +| -doc-source-url | -source-links | A URL pattern used to link to the source file, with some variables supported... | Scala3 implementation provides richer syntax. You can find migration steps below this [table](#source-links). | | +| -doc-external-doc | -external-mappings | Links describing locations of external dependencies' documentations. | Scala3 implementation provides richer syntax. You can find migration steps below this [table](#external-mappings). | | +| -jdk-api-doc-base | -external-mappings | URL used to link Java API references. | You can specify jdk via -external-mappings since they are generalized setting. You can find migration steps below this [table](#external-mappings) | | +| -doc-generator | _ | The fully qualified name of a doclet class, which will be used to generate the documentation. | We don't need this in Scala3 | | +| -doc-root-content | -doc-root-content | The file from which the root package documentation should be imported. | | | +| -implicits | _ | | We don't need this in Scala3 - Contextual extension methods are always documented in Scala 3 | | +| -implicits-debug | _ | | We don't need this in Scala3 | | +| -implicits-show-all | _ | | We don't need this in Scala3 | | +| -implicits-sound-shadowing | _ | | We don't need this in Scala3 | | +| -implicits-hide | _ | | We don't need this in Scala3 | | +| -diagrams | _ | | We don't need this in Scala3 | | +| -diagrams-debug | _ | | We don't need this in Scala3 | | +| -diagrams-dot-path | _ | | We don't need this in Scala3 | | +| -diagrams-max-classes | _ | | We don't need this in Scala3 | | +| -diagrams-max-implicits | _ | | We don't need this in Scala3 | | +| -diagrams-dot-timeout | _ | | We don't need this in Scala3 | | +| -diagrams-dot-restart | _ | | We don't need this in Scala3 | | +| -author | -author | | Fixed by [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| -raw-output | _ | | We don't need this in Scala3 | | +| -no-prefixes | _ | | We don't need this in Scala3 | | +| -skip-packages | -skip-packages | | | | +| -no-link-warnings | _ | | Not implemented yet | | +| -expand-all-types | _ | | Setting has been removed | | +| -groups | -groups | | | | +| -no-java-comments | _ | | We don't need this in Scala3 | | +| -doc-canonical-base-url | -doc-canonical-base-url | A base URL to use as prefix and add `canonical` URLs to all pages. The canonical URL may be used by search engines to choose the URL that you want people to see in search results. If unset no canonical URLs are generated. | Fixed by [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| -private | -private | Show all types and members. Unless specified, show only public and protected types and members. | Fixed by [#11965](https://github.com/lampepfl/dotty/issues/11965) | | +| _ | -siteroot | | We don't backport it to old scaladoc | N/A | +| _ | -project-logo | | Should we backport it to the old scaladoc? | N/A | +| _ | -comment-syntax | | We don't backport it to the old scaladoc | N/A | +| _ | -revision | | Should we backport it to the old scaladoc? | N/A | +| _ | -social-links | | Should we backport it to the old scaladoc? | N/A | +| _ | -skip-by-id | | We don't backport it to the old scaladoc | N/A | +| _ | -skip-by-regex | | We don't backport it to the old scaladoc | N/A | +| _ | -snippet-compiler-args | | We don't backport it to the old scaladoc | N/A | +| _ | -Ydocument-synthetic-types | Documents intrinsic types e. g. Any, Nothing. Setting is useful only for stdlib | | | + +## Source links + +Source linksgithubやbitbucketなどのリモートリポジトリにあるソースコードを指すために使用されます。 +うまくいけば、新しいシンタックスは古いシンタックスのほぼ上位集合になります。 +Hopefully, the new syntax is almost superset of the old syntax. +新しいscaladocシンタックスに移行するために, これらの変数が使われていないことを確認してください: +`€{TPL_OWNER}` や `€{FILE_PATH_EXT}`。 それ以外の場合は、他の`variables`を使用してソースリンクを書き換える必要があります。 +または、新しい変数を使用することもできます。より詳しくは[dotty docs](https://dotty.epfl.ch/docs/usage/scaladoc/settings.html)に記述されています。 +新しいシンタックスでは、ソースが特定のURLに一致するように、ファイルパスのプレフィックスを指定できます。異なるディレクトリまたは異なるリポジトリに散在しています。 + + +## 外部マッピング + +この設定は、javadoc/scaladocの古い設定を一般化したものです。 + +外部マッピングの例は以下のようになります: +``` +-external-mappings:.*scala.*::scaladoc3::https://scala-lang.org/api/3.x/,.*java.*::javadoc::https://docs.oracle.com/javase/8/docs/api/ +``` + +マッピングの形式は '\::\[scaladoc3|scaladoc|javadoc]::\'です。 例に示すように、コンマで区切って複数のマッピングを指定できます。 + +古い構文は次のとおりです。: +- scaladocの場合 - `prefix#url` +- javadocの場合 - URLのみ + +fq名に一致する正規表現を取得し(javadocの場合、`java.*`のようにワイルドカードにすることができます), ダブルコロン`::`を使用して3つの利用可能なドキュメント形式のいずれかと連結し、もう一度`::`を追加して、URLを指定する必要があります。 +外部ドキュメントがホストされている場所です。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/tooling-migration-mode.md b/_ja/overviews/scala3-migration/tooling-migration-mode.md new file mode 100644 index 0000000000..fef293858c --- /dev/null +++ b/_ja/overviews/scala3-migration/tooling-migration-mode.md @@ -0,0 +1,63 @@ +--- +title: Scala 3移行モード +type: chapter +description: このセクションではScala 3コンパイラの移行モードについて記述します +num: 7 +previous-page: tooling-tour +next-page: tutorial-intro +language: ja +--- + +Scala 3 のコンパイラは移行を簡単にするためのいくつかの便利なutilitiesを提供します。 + +`scalac` を試すとそれらのutilitiesを垣間見ることができます: + +> `scalac` は実行可能なScalaコンパイラであり、[Github](https://github.com/lampepfl/dotty/releases/)からダウンロードできます。 +> +> また、Coursierと`cs install scala3-compiler`を用いることでインストールすることもでき、その場合は`scalac`は別名`scala3-compiler`となります。 + +{% highlight text %} +$ scalac +Usage: scalac +where possible standard options include: + +... +-explain Explain errors in more detail. +-explain-types Explain type errors in more detail. +... +-rewrite When used in conjunction with a `...-migration` source version, rewrites sources to migrate to new version. +... +-source source version + Default: 3.0. + Choices: 3.0, future, 3.0-migration, future-migration. +... +{% endhighlight %} + +## 移行モード + +`-source:3.0-migration` オプションは除去された機能の多くを許容し、エラーの代わりにWARNINGを出力します。 +各WARNINGは非推奨のコードに関して、クロスコンパイルに対応するコードを安全に書き換えられることを強く示しています。 + +我々はこれを **Scala 3 migration compilation**とよんでいます. + +## 自動再記述 + +一度マイグレーションモードでコンパイルすると、ほとんど全てのWARNINGはコンパイラによって自動的に解決されます。 +これを行うためには、再度コンパイルする必要があり、今回は、 `-source:3.0-migration` と　`-rewrite` オプションを使います。 + +> コンパイラがコードを変更することに注意してください！ 安全を目的としています。 +> しかしながら、コンパイラによって適用された差分を出力し、必要ならばもとに戻せるように初期状態をコミットしておくことをおすすめします。 + +> #### 良い知らせ +> - rewriteはもしコードコンパイルにエラーが有った場合は適用されません。 +> - 適用するルールを自身で決めることはできなく、コンパイラがその全てを担います。 + +[非互換性テーブル](incompatibility-table.html) を参考に、Scala 3 migration rewritesのリストを確認することができます。 + +## エラーの説明 + +`-source:3.0-migration` モードはたくさんの変更を処理できますが、全てではありません。 +コンパイラは`-explain` および `-explain-types` オプションを呼び出すときに、残りのエラーの詳細について与えてくれます。 + +> `-explain` および `-explain-types` オプションは、移行に限定されません。 +> 一般に、Scala 3での学習とコーディングを支援します。 diff --git a/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md b/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md new file mode 100644 index 0000000000..2f48ddb081 --- /dev/null +++ b/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md @@ -0,0 +1,220 @@ +--- +title: Scala 3 シンタックスの書き換え +type: chapter +description: このセクションではScala 3のシンタックス書き換え機能について説明します +num: 13 +previous-page: tutorial-macro-mixing +next-page: incompatibility-table +language: ja +--- + +Scala 3では新しい制御構文と重要なインデント構文でScala言語のシンタックスが拡張されています。 +どちらもオプションであるため、Scala 2コードスタイルはScala 3でも完全に有効です。 + +制御構造の新しいシンタックスにより、括弧を囲まずに、`if`式の条件、`while`ループの条件、または`for`式のジェネレータを記述することができます。 + +重要なインデント構文として、クラスとメソッドの本体、`if`式、`match`式など、多くの場合に中括弧は不要となります。 +完全な説明はScala3リファレンスウェブサイトの[オプションナルな中括弧](https://docs.scala-lang.org/scala3/reference/other-new-features/indentation.html) ページにあります。 + +既存のScalaコードを手動で新しい構文に変換するのは面倒で、エラーが発生しやすくなります。 +この章では、コンパイラを使用して、コードを従来のScala 2スタイルから新しいコードスタイルに、またはその逆について、自動的に書き換える方法を示します。 + +## シンタックス書き換えオプション + +目的を達成することが可能になるコンパイラオプションを見ましょう。 +コマンドラインで`scalac`と入力するだけで、自由に使用できる全てのオプションが出力されます。 +ここでは5つのオプションを使用します。: + +{% highlight text %} +$ scalac +Usage: scalac +where possible standard options include: +... +-indent Allow significant indentation +... +-new-syntax Require `then` and `do` in control expressions. +-no-indent Require classical {...} syntax, indentation is not significant. +... +-old-syntax Require `(...)` around conditions. +... +-rewrite When used in conjunction with a `...-migration` source version, + rewrites sources to migrate to new version. +... + +{% endhighlight %} + +最初の4つのオプションはそれぞれ、特定の構文に対応しています。: + +| Syntax | Option | +| - | - | +| New Control Structures | `-new-syntax` | +| Old Control Structures | `-old-syntax` | + +| Syntax | Compiler Option | +|-|-| +| Significant Indentation | `-indent` | +| Classical Braces | `-noindent` | + + +さらに詳しく説明するように、これらのオプションを`-rewrite` オプションと組み合わせて使用すると、特定の構文への変換を自動的にできます。 +小さな例を使って、このオプションがどのように機能するか見てみましょう。 + +## 新しいシンタックスの書き換え + +Scala 2スタイルで書かれたコードを下記に示します。 + +```scala +case class State(n: Int, minValue: Int, maxValue: Int) { + + def inc: State = + if (n == maxValue) + this + else + this.copy(n = n + 1) + + def printAll: Unit = { + println("Printing all") + for { + i <- minValue to maxValue + j <- 0 to n + } println(i + j) + } +} +``` + +我々は２つのステップで自動的に新しい構文に移動させることが可能です。: まずはじめに、`-new-syntax -rewrite`オプションで新しい構文に、そして、重要なインデントに関しては`-indent -rewrite`を書きます。 + +> `-indent` オプションは既存の制御構文上では動きません。 +> なので、2つのステップを正しい順序で実行するようにしてください。 + +> 残念ながら、コンパイラは両方の手順を同時に適用することはできません。: `-indent -new-syntax -rewrite`. + +### 新しい制御構文 + +scalacのリストに追加することで `-new-syntax -rewrite` オプションを使う事ができます。 + +```scala +// build.sbt +scalacOptions ++= Seq("-new-syntax", "-rewrite") +``` + +コンパイル後のコードは、以下のような結果に見えるでしょう: + +```scala +case class State(n: Int, minValue: Int, maxValue: Int) { + + def inc: State = + if n == maxValue then + this + else + this.copy(n = n + 1) + + def printAll: Unit = { + println("Printing all") + for + i <- minValue to maxValue + j <- 0 to n + do println(i + j) + } +} +``` + +`n == maxValue` を囲む括弧と`i <- minValue to maxValue` 及び `j <- 0 to n` ジェネレーターを囲む中括弧が表示されなくなったことに注意してください。 + +### 重要なインデント構文 + +最初の書き換えの後、重要なインデント構文を使用して、残りの中括弧を削除できます。 +これを行うには、`-indent` オプションを`-rewrite`オプションと組み合わせて使用します。 +この組み合わせで、さらなるバージョンに導きます: + +```scala +case class State(n: Int, minValue: Int, maxValue: Int): + + def inc: State = + if n == maxValue then + this + else + this.copy(n = n + 1) + + def printAll: Unit = + println("Printing all") + for + i <- minValue to maxValue + j <- 0 to n + do println(i + j) +``` + +## 従来のシンタックスに切り戻す + +コードサンプルの最新の状態から始めて、従来の状態に戻すことができます。 + +新しい制御構文を維持しながら、中括弧を使用してコードを書き直してみましょう。 +`-no-indent -rewrite`オプションを使用してコンパイルすると、次の結果が得られます。: + +```scala +case class State(n: Int, minValue: Int, maxValue: Int) { + + def inc: State = + if n == maxValue then + this + else + this.copy(n = n + 1) + + def printAll: Unit = { + println("Printing all") + for { + i <- minValue to maxValue + j <- 0 to n + } + do println(i + j) + } +} +``` + +`-old-syntax -rewrite`を使用してもう1度書き換えを適用すると、元のScala2スタイルのコードに戻ります。 + +```scala +case class State(n: Int, minValue: Int, maxValue: Int) { + + def inc: State = + if (n == maxValue) + this + else + this.copy(n = n + 1) + + def printAll: Unit = { + println("Printing all") + for { + i <- minValue to maxValue + j <- 0 to n + } + println(i + j) + } +} +``` + +この最後の書き直しで、完全に一周しました。 + +> #### 構文バージョンを循環するときにフォーマットが失われる +> +> [scalafmt](https://scalameta.org/scalafmt)などのフォーマットツールを使用してカスタムフォーマットをコードに適用するとき、異なるScala 3シンタックス変位で行ったり来たりすると、循環するときに差分が生じる可能性があります。 + +## 特定の構文の適用 + +古い構文と新しい構文を単一のコードベースに混在させることができます。 +けれども読みやすさが低下し、コードの保守が難しくなるため、おすすめはしません。 +よりよいアプローチは一つのスタイルを選択し、コードベース全体に一貫して適用することです。 + +`-no-indent`, `-new-syntax` と `-old-syntax` をスタンドアロンオプションとして使用して、一貫した構文を適用できます。 + +たとえば、 `-new-syntax`オプションを使用すると、コンパイラは、`if`条件を囲む括弧を検出するとエラーを発行します。 + +{% highlight text %} +-- Error: /home/piquerez/scalacenter/syntax/example.scala:6:7 ------------------ +6 | if (n == maxValue) + | ^^^^^^^^^^^^^^^ + |This construct is not allowed under -new-syntax. + |This construct can be rewritten automatically under -new-syntax -rewrite -source 3.0-migration. +{% endhighlight %} + +> `-indent` シンタックスは常にオプショナルです、コンパイラによって強制することはできません diff --git a/_ja/overviews/scala3-migration/tooling-tour.md b/_ja/overviews/scala3-migration/tooling-tour.md new file mode 100644 index 0000000000..8f66865f1e --- /dev/null +++ b/_ja/overviews/scala3-migration/tooling-tour.md @@ -0,0 +1,138 @@ +--- +title: 移行ツールのツアー +type: chapter +description: この章は移行ツールのエコシステムのツアーです +num: 6 +previous-page: compatibility-metaprogramming +next-page: tooling-migration-mode +language: ja +--- + +## Scalaコンパイラ + +移行に関して、簡単でスムーズになるように、事前に2つのコンパイラが準備されています。 + +### Scala 2.13コンパイラ + +Scala 2.13コンパイラは `-Xsource:3`をサポートしています。これは、いくつかのScala 3のシンタックスや振る舞いを可能とするオプションです。: +- ほとんどの非推奨の構文はエラーを生成する。 +- 中置演算子":"は、複数行の式の途中で行を開始できる。 +- Implicit searchと過負荷問題の解決は、特異性のチェック時にScala 3が共変性を扱う処理に従います。 + +`-Xsource:3`オプションは、早期の移行を促進することを目的としています。 + +### Scala 3コンパイラ + +#### 移行モード + +同様にScala 3コンパイラには`-source:3.0-migration` オプションが付いています。 +このモードから、Scala 2.13のシンタックスのいくつかを許容し、変更に関する説明をWarningとして出してくれます。 + +それ以上に、`-rewrite`を使うことで自動的にコードにパッチを当ててくれます。 + +上記については[Scala 3移行モード](tooling-migration-mode.html) ページで学ぶことができます。 + +#### シンタックス書き換え + +一度あなたのコードをScala3でコンパイルすると、[シンタックス書き換え](tooling-syntax-rewriting.html) オプションを使うことで新しくオプションであるScala 3シンタックスに変換されます。 + +## ビルドツール + +### sbt + +> sbt 1.4は`sbt-dotty` プラグインを必要としています。 +> しかし1.5以降では必要なくなりました + +sbt 1.5はScala 3をサポートしており、全ての共通タスクと設定は同じように動くことを目的としています。 +多くのプラグインも確実に同じように動くべきです。 + +移行のヘルプとして、sbt 1.5が紹介している新たなScala 3のクロスバージョンがこちらです: + +```scala +// Scala 3でScala 2.13ライブラリを使用する +libraryDependency += ("org.foo" %% "foo" % "1.0.0").cross(CrossVersion.for3Use2_13) + +// Scala 2.13でScala 3ライブラリを使用する +libraryDependency += ("org.bar" %% "bar" % "1.0.0").cross(CrossVersion.for2_13Use3) +``` + +### Mill + +[Mill](https://github.com/com-lihaoyi/mill) 0.9.x からScala 3をサポートしています。 + +### Maven + +Scala 3 サポートに関しては [scala-maven-plugin](https://github.com/davidB/scala-maven-plugin)がもう間もなく出てくるでしょう. + +## コードエディターとIDE + +### Metals + +[Metals](https://scalameta.org/metals/) VSコード、Vim， Emacs， SbulimeTextやEclips上で動くScala言語サーバーです。 + +Scala 3 はすでにMetalsによって大変良くサポートされています。 +いくつかの新しいシンタックス変更や新機能といったマイナーアップデートは時期にでてきます。 + +### IntelliJ IDEA + +InteliJ用のScalaプラグインはScala3用の予備サポートが含まれています。 +本格的なサポートはJetBrainのチームよって行われています。 + +## フォーマットツール + +### Scalafmt + +[Scalafmt](https://scalameta.org/scalafmt/) v3.0.0-RC3 はScala 2.13とScala 3の両方サポートしています。 + +Scala 3 フォーマットを利用可能にするために、`.scalafmt.conf`ファイルに `runner.dialect = scala3`をセットしなければならないです。 + +もし、あなたが選択的に設定したい場合は`fileOverride` 設定が可能です。: + +```conf +//.scalafmt.conf +fileOverride { + "glob:**/scala-3*/**" { + runner.dialect = scala3 + } +} +``` + +## 移行ツール + +### Scalafix + +[Scalafix](https://scalacenter.github.io/scalafix/) はScala用のリファクタリングツールです。 +一度書いてしまえば、Scala 2.13上で実行されます。 +しかし、Scala 3にジャンプする前にコードを準備しておくと便利です。 + +[Incompatibility Table](incompatibility-table.html) は既存のScalafixルールで修正できる非互換性が表示されています。 +これまでのところ、関連するルールは以下のとおりです。 +- [手続きシンタックス](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html) +- [明示的な結果の型](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html) +- Eta-Expansion値: `fix.scala213.ExplicitNullaryEtaExpansion` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala) +- Lambdaパラメータのまわりの括弧: `fix.scala213.ParensAroundLambda` in [ohze/scala-rewrites](https://github.com/ohze/scala-rewrites/blob/dotty/rewrites/src/main/scala/fix/scala213/ParensAroundLambda.scala) +- Auto Application: `fix.scala213.ExplicitNonNullaryApply` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala) +- `any2stringadd` 変換: `fix.scala213.Any2StringAdd` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala) + +`sbt-scalafix` プラグインを使用して、これらのルールをsbtに適用できます。 +これらは、以下で説明する `sbt-scala3-migrate` でも内部的に使用されます。 + +### Scala 3移行プラグイン + +[Scala 3移行](https://github.com/scalacenter/scala3-migrate) は移行期間中にアシストしてくれるsbt pluginがあります。 + +そのプロセスは段階的なアプローチで下記のようになっています: +- ライブラリの依存関係の移行: + Scala 3で利用可能なバージョンが有るかどうか、ライブラリ依存関係ごとにチェックします. +- Scalaのコンパイルオプション(`scalacOptions`)の移行: + Scala 2のいくつかのコンパイラのオプションは除去されたか、名前が変更した、もしくはそのままのものがあります。 + このステップはあなたのプロジェクトのコンパイラのオプションに適用させるのに役立ちます。 +- シンタックスの移行: + このステップはシンタックスの非推奨を修正するためにScalafixや既存ルールに依存します。 +- 型を明示してコードを移行: + Scala 3はあたらしい型インタフェースのアルゴリズムをもっており、Scala 2の推論とはわずかに異なります。 + 最後のステップでは、ランタイム時の動作を変更せずにプロジェクトをScala 3でコンパイルできるように、型の最小セットを明示します。 + +## Scaladex + +[Scaladex](https://index.scala-lang.org/)のScala 3のオープンソースライブラリのリストをチェックしてください diff --git a/_ja/overviews/scala3-migration/tutorial-intro.md b/_ja/overviews/scala3-migration/tutorial-intro.md new file mode 100644 index 0000000000..564ac0d0eb --- /dev/null +++ b/_ja/overviews/scala3-migration/tutorial-intro.md @@ -0,0 +1,22 @@ +--- +title: 移行チュートリアル +type: chapter +description: この章はScala 2.13 projectをScala 3へ移行するチュートリアルを含みます +num: 8 +previous-page: tooling-migration-mode +next-page: tutorial-prerequisites +language: ja +--- + +Scala 3の移植の準備をしましょう！ + +最初のステップはプロジェクトの[前提条件](tutorial-prerequisites.html)を満たしていることを確認することです。 +次に、あなたが移行ワークフローについて[sbtプロジェクトの移行](tutorial-sbt.html) で学ぶことができます。 + +> **sbtを使ってない？** +> +> ワークフローが非常に似ていることから、[sbtプロジェクトの移行](tutorial-sbt.html)で学ぶことを強く助言します。 +> その前に、ビルドツールがScala 3対応しているバージョンか確認してください。 + + +[Cross-Building a Macro Library](tutorial-macro-cross-building.html) と [Mixing Scala 2.13 and Scala 3 Macros](tutorial-macro-mixing.html) ではScala 2マクロライブラリの移植をするための特別なチュートリアルです。 diff --git a/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md b/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md new file mode 100644 index 0000000000..ec229d213e --- /dev/null +++ b/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md @@ -0,0 +1,228 @@ +--- +title: マクロライブラリのクロスビルド +type: section +description: このセクションはマクロライブラリのクロスビルド方法について示します +num: 11 +previous-page: tutorial-sbt +next-page: tutorial-macro-mixing +language: ja +--- + +マクロライブラリは0から再実装しなければなりません。 + +開始する前に[sbtプロジェクトの移行](tutorial-sbt.html)チュートリアルに記載しているScala3移行について理解しておく必要があります。 +このチュートリアルの目的としては、既存のScala 2.13のマクロライブラリをクロスビルドしScala 3とScala 2.13の両方で使用するためことです。 + +代替手法としてはマクロミクシングは[次のチュートリアル](tutorial-macro-mixing.html)で説明します。 +両方のソリューションを読んで、ニーズに最適な手法を選択することをおすすめします。 + +## 導入 + +このチュートリアルを例証するために、最小限のマクロライブラリの定義を下記で考えます。 + +```scala +// build.sbt +lazy val example = project + .in(file("example")) + .settings( + scalaVersion := "2.13.6", + libraryDependencies ++= Seq( + "org.scala-lang" % "scala-reflect" % scalaVersion.value + ) + ) +``` + +```scala +// example/src/main/scala/location/Location.scala +package location + +import scala.reflect.macros.blackbox.Context +import scala.language.experimental.macros + +case class Location(path: String, line: Int) + +object Macros { + def location: Location = macro locationImpl + + private def locationImpl(c: Context): c.Tree = { + import c.universe._ + val location = typeOf[Location] + val line = Literal(Constant(c.enclosingPosition.line)) + val path = Literal(Constant(c.enclosingPosition.source.path)) + q"new $location($path, $line)" + } +} +``` + +ライブラリとのいくつかの類似点を認識する必要があります。: +一つ以上のマクロメソッド（この場合は`location`メソッド）はマクロコンテキストとこの`Context`からの`Tree`を返すことで実装されています。 + +sbtが提供する[クロスビルディング手法](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)を使用して、このライブラリをScala 3ユーザが利用できるように吸うことができます。 + +主要なアイデアは、アーティファクトを2回ビルドし、2つのリリース物を公開することです。: +- `example_2.13` はScala 2.13ユーザ用 +- `example_3` はScala 3ユーザ用 + +![Cross-building Architecture](/resources/images/scala3-migration/tutorial-macro-cross-building.svg) + +## 1. クロスビルディングの設定 + +Scala 3に `crossScalaVersions` のリストを追加することができます。: + +```scala +crossScalaVersions := Seq("2.13.6", "3.0.0") +``` + +`scala-reflect` の依存関係はScala 3では役に立ちません。 +次のような条件で条件付き削除を行います。: + +```scala +// build.sbt +libraryDependencies ++= { + CrossVersion.partialVersion(scalaVersion.value) match { + case Some((2, 13)) => Seq( + "org.scala-lang" % "scala-reflect" % scalaVersion.value + ) + case _ => Seq.empty + } +} +``` + +sbtの再起動後、`++3.0.0`を動かすことで、Scala 3コンテキストにスイッチできます。 +`++2.13.6`を実行するといつでもScala 2.13コンテキストに戻ることができます。 + +## 2. バージョン固有のソースディレクトリでコードを再配置 + +Scala 3でコンパイルしようとすると、あなたはいくつかの種類のエラーに遭遇するでしょう: + +{% highlight text %} +sbt:example> ++3.0.0 +sbt:example> example / compile +[error] -- Error: /example/src/main/scala/location/Location.scala:15:35 +[error] 15 | val location = typeOf[Location] +[error] | ^ +[error] | No TypeTag available for location.Location +[error] -- Error: /example/src/main/scala/location/Location.scala:18:4 +[error] 18 | q"new $location($path, $line)" +[error] | ^ +[error] |Scala 2 macro cannot be used in Dotty. See https://dotty.epfl.ch/docs/reference/dropped-features/macros.html +[error] |To turn this error into a warning, pass -Xignore-scala2-macros to the compiler +{% endhighlight %} + +Scala 2の実装を維持しながらScala 3の代替手段を提供するために、バージョン固有のソースディレクトリでコードを再配置します。 +Scala 3コンパイラでコンパイルできないすべてのコードは、`src/main/scala-2` フォルダに移動します。 + +> Scalaのバージョン固有のソースディレクトリは、デフォルトで利用できるsbt機能です。 +> 詳細については[sbt documentation](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)で学ぶことができます。 + +例として、`Location` クラスは`src/main/scala`フォルダに残りますが、`Macros` オブジェクトは`src/main/scala-2` フォルダに移動します。: + +```scala +// example/src/main/scala/location/Location.scala +package location + +case class Location(path: String, line: Int) +``` + +```scala +// example/src/main/scala-2/location/Macros.scala +package location + +import scala.reflect.macros.blackbox.Context +import scala.language.experimental.macros + +object Macros { + def location: Location = macro locationImpl + + private def locationImpl(c: Context): c.Tree = { + import c.universe._ + val location = typeOf[Location] + val line = Literal(Constant(c.enclosingPosition.line)) + val path = Literal(Constant(c.enclosingPosition.source.path)) + q"new $location($path, $line)" + } +} +``` + +これで我々は`src/main/scala-3`フォルダにあるScala 3マクロ定義をそれぞれ初期化できます。 +それらは、Scala 2.13の対応物と全く同じシグネチャーを持っている必要があります。 + +```scala +// example/src/main/scala-3/location/Macros.scala +package location + +object Macros: + def location: Location = ??? +``` + +## 3. Scala 3マクロの実装 + +Scala2マクロをScala3に移植するための魔法の公式はありません。 +新しい[メタプログラミング](compatibility-metaprogramming.html)機能について学ぶ必要があります。 + +最終的に、この実装を思いつきます。: + +```scala +// example/src/main/scala-3/location/Macros.scala +package location + +import scala.quoted.{Quotes, Expr} + +object Macros: + inline def location: Location = ${locationImpl} + + private def locationImpl(using quotes: Quotes): Expr[Location] = + import quotes.reflect.Position + val pos = Position.ofMacroExpansion + val file = Expr(pos.sourceFile.jpath.toString) + val line = Expr(pos.startLine + 1) + '{new Location($file, $line)} +``` + +## 4. マクロの交差検証 + +いくつかのテストを加えることはマクロメソッドが両方のScalaのバージョンで動くかどうかの確認に重要です。 + +例として、一つのテストを追加します。 + +```scala +// example/src/test/scala/location/MacrosSpec.scala +package location + +class MacrosSpec extends munit.FunSuite { + test("location") { + assertEquals(Macros.location.line, 5) + } +} +``` + +あなたは両方のバージョンでテストを実行できるようになります。 + +{% highlight text %} +sbt:example> ++2.13.6 +sbt:example> example / test +location.MacrosSpec: + + location +[info] Passed: Total 1, Failed 0, Errors 0, Passed 1 +[success] +sbt:example> ++3.0.0 +sbt:example> example / test +location.MacrosSpec: + + location +[info] Passed: Total 1, Failed 0, Errors 0, Passed 1 +[success] +{% endhighlight %} + +## さいごに + +あなたのマクロプエオジェクトは現在以下のソースファイルが含まれているでしょう: +- `src/main/scala/*.scala`: クロスコンパイルクラス群 +- `src/main/scala-2/*.scala`: Scala 2で実装されたマクロメソッド +- `src/main/scala-3/*.scala`: Scala 3で実装されたマクロメソッド +- `src/test/scala/*.scala`: テスト + +![Cross-building Architecture](/resources/images/scala3-migration/tutorial-macro-cross-building.svg) + +これで、2つのリリースを作ることによってライブラリ公開の準備ができました: +- `example_2.13` はScala 2.13ユーザ用 +- `example_3` はScala 3ユーザ用 diff --git a/_ja/overviews/scala3-migration/tutorial-macro-mixing.md b/_ja/overviews/scala3-migration/tutorial-macro-mixing.md new file mode 100644 index 0000000000..fff362ddb8 --- /dev/null +++ b/_ja/overviews/scala3-migration/tutorial-macro-mixing.md @@ -0,0 +1,198 @@ +--- +title: Scala 2.13とScala 3マクロのミクシング +type: section +description: このセクションはScala 2.13とScala 3マクロの単一アーティファクトでのミクシングについて示します +num: 12 +previous-page: tutorial-macro-mixing +next-page: tooling-syntax-rewriting +language: ja +--- + +このチュートリアルでは、Scala 2.13とScala 3マクロを単一アーティファクトでミックスする方法をお見せします。 + +これを使用して、新しいScala 3マクロライブラリを作り、それをScala 2.13ユーザでも利用可能にすることができます。 +それだけでなく、既存のScala 2.13マクロライブラリをScala 3に移植することも可能ですが、おそらくクロスビルドのほうが簡単です。 + +## 導入 + +Scala 2.13コンパイラはSala 2.13マクロを展開することができ、逆に、Scala 3コンパイラはScala 3マクロを展開することができます。 +マクロミクシングのアイデアは単一アーティファクトにある両方のマクロをパッケージ化し、マクロ展開のフェーズでコンパイラーに2つから選択させることです。 + +これはScala 3だけ可能で、なぜならScala 3のコンパイラはScala 2とScala 3の両方とも定義を読むことができるからです。 + +以下のコードスケルトンで実際に考えてみましょう: + +```scala +// example/src/main/scala/location/Location.scala +package location + +case class Location(path: String, line: Int) + +object Macros: + def location: Location = macro ??? + inline def location: Location = ${ ??? } +``` + +見ての通り、`location` マクロの定義は2つあります。: +- `def location: Location = macro ???` はScala 2.13マクロ定義です +- `inline def location: Location = ${ ??? }` はScala 3マクロ定義です。 + +`location` はオーバーロードされたメソッドではないです、なぜなら2つのシグネチャーは厳密には同一だからです。 +これは非常に驚くべきことです！ +コンパイラは同じ名前とシグネチャーを持つ2つのメソッドをどのように受け入れるのでしょうか？ + +現状のまとめとしては、最初の定義はScala 2.13のみであり、2番目の定義はScala 3のみであるということです。 + +## 1. Scala　3マクロの実装 + +Scala3マクロ実装を定義の横に置くことができます。 + +```scala +package location + +import scala.quoted.{Quotes, Expr} + +case class Location(path: String, line: Int) + +object Macros: + def location: Location = macro ??? + inline def location: Location = ${locationImpl} + + private def locationImpl(using quotes: Quotes): Expr[Location] = + import quotes.reflect.Position + val file = Expr(Position.ofMacroExpansion.sourceFile.jpath.toString) + val line = Expr(Position.ofMacroExpansion.startLine + 1) + '{new Location($file, $line)} +``` + +## 2. Scala　2マクロの実装 + +Scala 3コンパイラは, ダブルクォートまたは、reificationが含まれていない場合、Scala 2マクロ実装はコンパイルできます + +たとえば、このコードはScala 3でコンパイルされるため、Scala 3の実装と一緒に配置できます。 +```scala +import scala.reflect.macros.blackbox.Context + +def locationImpl(c: Context): c.Tree = { + import c.universe._ + val line = Literal(Constant(c.enclosingPosition.line)) + val path = Literal(Constant(c.enclosingPosition.source.path)) + New(c.mirror.staticClass(classOf[Location].getName()), path, line) +} +``` + +しかしながら、多くのケースであなたはScala 2.13マクロ実装をScala 2.13サブモジュールに移動しなければならないでしょう。 + +```scala +// build.sbt + +lazy val example = project.in(file("example")) + .settings( + scalaVersion := "3.0.0" + ) + .dependsOn(`example-compat`) + +lazy val `example-compat` = project.in(file("example-compat")) + .settings( + scalaVersion := "2.13.6", + libraryDependency += "org.scala-lang" % "scala-reflect" % scalaVersion.value + ) +``` + +このような`example`では, この例では、Scala 3でコンパイルされたメインライブラリは、Scala 2.13でコンパイルされた`example-compat`に依存しています。 + +このような場合、Scala 2マクロの実装を`example-compat`にいれて、ダブルクォートを使用できます。 + +```scala +package location + +import scala.reflect.macros.blackbox.Context +import scala.language.experimental.macros + +case class Location(path: String, line: Int) + +object Scala2MacrosCompat { + private[location] def locationImpl(c: Context): c.Tree = { + import c.universe._ + val location = typeOf[Location] + val line = Literal(Constant(c.enclosingPosition.line)) + val path = Literal(Constant(c.enclosingPosition.source.path)) + q"new $location($path, $line)" + } +} +``` + +`Location`クラスを下流に移動させる必要があることに注意してください。 + +## 3. マクロの交差検証 + +いくつかのテストを加えることはマクロメソッドが両方のScalaのバージョンで動くかどうかの確認に重要です。 + +Scala 2.13とScala 3で実行したいので、クロスビルドモジュールを作ります。: + +```scala +// build.sbt +lazy val `example-test` = project.in(file("example-test")) + .settings( + scalaVersion := "3.0.0", + crossScalaVersions := Seq("3.0.0", "2.13.6"), + scalacOptions ++= { + CrossVersion.partialVersion(scalaVersion.value) match { + case Some((2, 13)) => Seq("-Ytasty-reader") + case _ => Seq.empty + } + }, + libraryDependencies += "org.scalameta" %% "munit" % "0.7.26" % Test + ) + .dependsOn(example) +``` + +> `-Ytasty-reader`はScala 3アーティファクトを消費するためにScala 2.13上で必要です + +例えば、テストは次のようになります。: +```scala +// example-test/src/test/scala/location/MacrosSpec.scala +package location + +class MacrosSpec extends munit.FunSuite { + test("location") { + assertEquals(Macros.location.line, 5) + } +} +``` + +これで両方のバージョンでテスト可能のはずです。 + +{% highlight text %} +sbt:example> ++2.13.6 +sbt:example> example-test / test +location.MacrosSpec: + + location +[info] Passed: Total 1, Failed 0, Errors 0, Passed 1 +[success] +sbt:example> ++3.0.0 +sbt:example> example-test / test +location.MacrosSpec: + + location +[info] Passed: Total 1, Failed 0, Errors 0, Passed 1 +[success] +{% endhighlight %} + +## さいごに + +現在のライブラリの構成です: +- メインのScala 3モジュールはScala 3マクロ実装とミクシングしたマクロ定義が含まれています。 +- Scala 2.13の互換性のあるモジュールはScala 2.13マクロ実装を含んでいます。 +これは、コンパイラのマクロ展開フェーズでScala 2.13により消費されるでしょう + +![Mixing-macros Architecture](/resources/images/scala3-migration/tutorial-macro-mixing.svg) + +これでライブラリを公開する準備ができました。 + +Scala 3プロジェクトで利用可能ですし、または次の設定のScala 2.13プロジェクトでも利用できます。: + +```scala +scalaVersion := "2.13.6" +libraryDependencies += ("org" %% "example" % "x.y.z").cross(CrossVersion.for2_13Use3) +scalacOptions += "-Ytasty-reader" +``` diff --git a/_ja/overviews/scala3-migration/tutorial-prerequisites.md b/_ja/overviews/scala3-migration/tutorial-prerequisites.md new file mode 100644 index 0000000000..6b8c27242e --- /dev/null +++ b/_ja/overviews/scala3-migration/tutorial-prerequisites.md @@ -0,0 +1,129 @@ +--- +title: 前提条件 +type: section +description: このセクションはScala 3への移行の前提条件について詳細化します +num: 9 +previous-page: tutorial-intro +next-page: tutorial-sbt +language: ja +--- + +[互換性リファレンス](compatibility-intro.html)のページで示したように、Scala 3への移行に関してはScala 2.13とScala 3の相互互換性のおかげで容易であります。 + +しかしながら、Scala 3移植を始める前にかならず確認しなければならないScala 2.13プロジェクトの前提条件があります。: +- Scala 3にまだ移植されていないマクロライブラリに依存してはなりません +- Scala 3に同等のものがないコンパイラプラグインを使用してはなりません +- `scala-reflect`に依存してはなりません. + +次の段落では、これらの前提条件を確認する方法と、それらが満たされていな場合の対処方法について説明します。 + +移植を続行する準備ができたら[sbt移行チュートリアル](tutorial-sbt.html)にジャンプできます。 + +## マクロの依存 + +マクロライブラリはScalaのライブラリでマクロメソッドを公開しています。 + +それらのライブラリはScala 2で幅広く使われています。 +例えば、: +- [lightbend/scala-logging](https://index.scala-lang.org/lightbend/scala-logging) +- [milessabin/shapeless](https://index.scala-lang.org/milessabin/shapeless) +- [playframework/play-json](https://index.scala-lang.org/playframework/play-json) +- [scalatest/scalatest](https://index.scala-lang.org/scalatest/scalatest) + +しかしScala 3コンパイラはScala 2.13のマクロを展開することができません。 +なので、Scala3にジャンプする前に、あなたは移植されていないマクロライブラリに依存していないかを確認する必要があります。 + +あなたはたくさんのマクロの移行状態を[Scala Macro Libraries](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html) ページで確認することができます。 +幸いなことにたくさんのライブラリはこの行を読むまでに移植されているでしょう。 + +プロジェクト内のこれらのマクロ依存ごとに、クロスビルドバージョン、すなわちScala 2.13とScala 3の両方で使用可能なバージョンにアップグレードする必要があります。 + +いくつか例を上げてみましょう + +`"scalatest" %% "scalatest" % "3.0.9"` への依存関係は、次の理由でアップグレードする必要があります。: +- `scalatest` API は一部のマクロ定義がベースになっているから。 +- `3.0.9` バージョンはScala 3用にパブリッシュされていないから. + +`3.2.7`までアップグレードする必要があり、そしてそれは、Scala 2.13とScala 3のクロス公開されています。 + +```scala +libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.7" +``` + +## コンパイラプラグイン + +Scala 2のコンパイラプラグインはScala 3との互換性がありません。 + +コンパイラプラグインは一般的に`build.sbt`ファイルに設定されていて一つにまとまっています。: + +```scala +// build.sbt +libraryDependencies += + compilerPlugin("org.typelevel" %% "kind-projector" % "0.11.0" cross CrossVersion.full) + +addCompilerPlugin("org.typelevel" %% "kind-projector" % "0.11.0" cross CrossVersion.full) +``` + +一部のコンパイラプラグインは自動的にsbtプラグインによって追加されるでしょう。 + +自身のプロジェクトのコンパイラオブションを見ることによって設定されているプラグインを見つけることができるでしょう。 + +{% highlight text %} +sbt:example> show example / Compile / scalacOptions +[info] * -Xplugin:target/compiler_plugins/wartremover_2.13.6-2.4.15.jar +[info] * -Xplugin:target/compiler_plugins/semanticdb-scalac_2.13.6-4.4.18.jar +[info] * -Yrangepos +[info] * -P:semanticdb:targetroot:/example/target/scala-2.13/meta +{% endhighlight %} + +上記の例では、wartremoverとsemanticdbの2つのコンパイラプラグインが使用されていることがわかります。 +これらのプラグインごとに、代替ソリューションがあることを確認するか、無効にする必要があります。 + +最もよく使用されるコンパイラプラグインの代替ソリューションを以下に示します。 + +### SemanticDB + +[SemanticDB](https://scalameta.org/docs/semanticdb/guide.html) は現在Scala 3コンパイラに同梱されています。 +: +- `-Ysemanticdb` オプションはsemanticDBファイルを生成します。 +- `-semanticdb-target` オプションはsemanticDBファイルの出力ディレクトリを指定できます。 + +sbtは`semanticdbEnabled := true`という単一の設定で、semanticDB設定を自動的に構成できます。 + +### Scala.js + +Scala3上での[Scala.js](https://www.scala-js.org/) コンパイルはコンパイラプラグインに依存していないです。 + +Scala.jsプロジェクトをコンパイルするには`sbt-scalajs`プラグインバージョン`1.5.0`以上だと使用できます。 + +```scala +// project/plugins.sbt +addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.5.0") +``` + +### Scala Native + +Scala 3 はまだ[Scala Native](https://scala-native.readthedocs.io/en/latest/)をサポートしていません。 + +もしScala Nativeにクロスビルドできていれば、Scala3移植は可能です。 +しかしまだNativeプラットフォーム用にコンパイルはできません。 + +### Kind Projector + +[the Kind Projector](https://github.com/typelevel/kind-projector) シンタックスの一部はScala 3の`-Ykind-projector` オプションによりサポートされています。 + +加えて、多くの場合`kind-projector`を不要にする次の機能があります。: +- [Type Lambdas](http://dotty.epfl.ch/docs/reference/new-types/type-lambdas.html) +- [Polymorphic Functions](http://dotty.epfl.ch/docs/reference/new-types/polymorphic-function-types.html) +- [Kind Polymorphism](http://dotty.epfl.ch/docs/reference/other-new-features/kind-polymorphism.html) + +Kind Projectorの移行を学びたい方は [dedicated page](plugin-kind-projector.html)に。 + +## Runtime reflection + +`scala-reflect` Scala3に移植されないでしょう、なぜならScala 3には存在しないScala 2コンパイラの内部展開をするからです。 + +もしあなたのプロジェクトが `scala-reflect`に依存している、または `Manifest`クラスのインスタンスを使用している場合、Scala 3コンパイラでコンパイルできません +この状況を改善する位は、Javaリフレクヨンまたは[Scala 3メタプログラミング機能](compatibility-metaprogramming.html)を使用して、コードの対応する部分を再実装してみてください。 + +`scala-reflect` がクラスパスに推移的に追加されている場合は、それをもたらす依存関係自体をアップグレードする必要があります。 diff --git a/_ja/overviews/scala3-migration/tutorial-sbt.md b/_ja/overviews/scala3-migration/tutorial-sbt.md new file mode 100644 index 0000000000..a85540c27b --- /dev/null +++ b/_ja/overviews/scala3-migration/tutorial-sbt.md @@ -0,0 +1,230 @@ +--- +title: sbtプロジェクトの移行 +type: section +description: このセクションはsbtプロジェクトの移行方法について示します +num: 10 +previous-page: tutorial-prerequisites +next-page: tutorial-macro-cross-building +language: ja +--- + +> このチュートリアルでは、sbtについて記述しています。 +> といっても、Scala 3をサポートしてる限り、移行のアプローチは他のビルドツールと非常に似ています。 + +Scala3にジャンプする前に、最新版のScala 2.13.xとsbt 1.5.xであることを確認しましょう。 + +それでは、プロジェクト全体をScala 3に移植するために必要な手順を見ていきましょう。 + +## 1. プロジェクトの前提をチェック + +プロジェクトが移行されるかの確認をしましょう: +- Scala 3にまだ移植されていないマクロライブラリに依存してはなりません。 +- Scala 3に同等のものがないコンパイラプラグインは使用してはなりません。 +- `scala-reflect`に依存してはなりません。 + +これらの前提に関しては、[前のページ](tutorial-prerequisites.html)で詳しく話しています。 + +## 2. モジュールを選択する + +Scala 2.13とScala 3の相互互換性のおかげで、あなたは全てのモジュールからでも移行を開始することができます。 +しかしながら、依存関係が最も少ないモジュールから始めるほうがおそらく簡単です。 + +もしあなたがマクロ定義やマクロアノテーションを内部的に使っているのであれば、そこを始めに移植する必要があります。 + +## 3. クロスビルドのセットアップ + +コードベースの移行の2つの主な課題は次のとおりです。: +- コードコンパイルする +- ランタイム時の動作で変更がされていないことの確認をする + +クロスビルド戦略をおすすめしており、Scala 3とScala 2.13の両方でコンパイルすることです。 +背後にあるロジックは修正のたびにScala 2.13でテストを実行できるようにすることです。 +これにより、ランタイムの動作が変更されていなことを確認ですることができます。 +これは、非互換性を修正するときに発生する可能性のあるバグを回避するために重要です。 + +sbtのクロスビルディング設定は以下の様にまとめられます。: + +```scala +scalaVersion := "3.0.0" +crossScalaVersions ++= Seq("2.13.6", "3.0.0") +``` + +この設定の意味は: +- デフォルトバージョンは `3.0.0`。 +- 2.13.6 は `++2.13.6` コマンドを走らすことによってロードされます。 +- 3.0.0 は `++3.0.0` コマンドを走らすことによってロードされます。 + +`reload` コマンドは常にデフォルトバージョンをロードすることに気をつけましょう、ここでは 3.0.0です。 + +## 4. 依存に対する準備 + +このステージで、もしあなたが `compile`を走らせると, sbtが一部の依存関係が見つからないということについて忠告してくる可能性があります。 +これは依存関係の宣言されたバージョンがScala 3に対して公開されていないためです。 + +依存関係を新しいバージョンにアップグレードするか、ライブラリのScala 2.13 バージョンを使用するようにsbtに指示する必要があります。 + +> ライブラリの依存関係を変更するときは、プロジェクトのすべてのモジュールに同じ変更を適用してください。 + +ライブラリの利用可能なScala3バージョンがあるかどうかを確認します。 +これを行うには、[Scaladex](https://index.scala-lang.org/)のバージョンマトリックスを使用できます。 +ライブラリのプロジェクトページに移動し、バージョンマトリックスボタンをクリックして、Scala 3とScala 2.13でフィルター処理します。 + +#### 1. ライブラリにScala3バージョンが有る場合 + +我々は強く利用可能なバージョンを使うことを提案します。 +ただ、選択したものが破壊的変更をもたらさないことは確認してください。 + +#### 2. ライブラリにScala3バージョンがない場合 + +あなたはScala2.13のバージョンのライブラリを使うことができます。 そのときのシンタックスは以下のようになります。: + +```scala +("com.lihaoyi" %% "os-lib" % "0.7.7").cross(CrossVersion.for3Use2_13) +``` + +Scala.jsの依存関係は以下のようになります。: + +```scala +("com.lihaoyi" %%% "os-lib" % "0.7.7").cross(CrossVersion.for3Use2_13) +``` + +一度あなたが全ての未解決の依存関係について修正したら、Scala 2.13でテストがまだ通るかどうかのチェックが可能になります。: + +{% highlight text %} +sbt:example> ++2.13.6 +[info] Setting Scala version to 2.13.6 on 1 project. +... +sbt:example> example / test +... +[success] +{% endhighlight %} + +## 5. Scala3コンパイラの設定 + +Scala3コンパイラオプションはScala2,13のオプションとは異なり、いくつかに関しては変名したり、未だサポートされてなかったりします。 +[Compiler Options Lookup](options-lookup.html) ページでScala3へ`scalacOptions` が適応されているかのリストを見ることができます。 + +あなたは一般的なオプションのリスト、Scala 2.13固有のオプションリスト、 およびSala3固有のオプションリストを考え出す必要があります。 + +典型的な設定は以下のようになります: +```scala +scalacOptions ++= { + Seq( + "-encoding", + "UTF-8", + "-feature", + "-language:implicitConversions", + // disabled during the migration + // "-Xfatal-warnings" + ) ++ + (CrossVersion.partialVersion(scalaVersion.value) match { + case Some((3, _)) => Seq( + "-unchecked", + "-source:3.0-migration" + ) + case _ => Seq( + "-deprecation", + "-Xfatal-warnings", + "-Wunused:imports,privates,locals", + "-Wvalue-discard" + ) + }) +} +``` + +`-source:3.0-migration` オプションを追加することで, [Scala 3移行モード](tooling-migration-mode.html)に切り替わります。 +また、移行モードと自動書き換えを最大限に活用するには、`-Xfatal-warnings`を無効にする必要があります。 + +## 6. 非互換性の解消 + +Scala 3でコンパイルするときが来ました: + +{% highlight text %} +sbt:example> ++3.0.0 +[info] Setting Scala version to 3.0.0 on 1 project. +... +sbt:example> example / compile +... +sbt:example> example / Test / compile +{% endhighlight %} + +> `example / compile` はプロジェクトの `main`ソースをコンパイルします。 +> 厳密には `example / Compile / compile`と等価です。 +> +> `example / Test / compile`は `test` ソースをコンパイルします。 + +コンパイラは２つの異なるレベルの診断を生成します。: +- *Migration Warning*: `-rewrite` オプションにてコンパイルしたときに自動的に適用される警告。 +- *Error*: どこかしらでコードがコンパイルできなかったときに出るもの。 + +コンパイラが自動的に修正をかますのでMigration Warningに関しては無視することもできます。. +しかしながら、非互換性のエラーは必ず手動でケアせねばなりません。 + +多くの既知の非互換性が[非互換性テーブル](incompatibility-table.html)にリストされています。 +ここで、エラーの説明といくつかの提案された解決策を見つけることができます。 + +可能であれば、コードのバイナリ互換性を最もよく維持する修正を見けるようにしてみるべきです。 +プロジェクトが公開ライブラリである場合は、このことは特に重要です。 + +> マクロの非互換性は解決が簡単にはできないです。 +> 多くのコードは0からの書き直しが必要です。 +> [メタプログラミング](compatibility-metaprogramming.html)を見てください。 + +非互換性を修正した後は、あなたはScala 2.13でテストを実行することで検証できます。 + +{% highlight text %} +sbt:example> ++2.13.6 +[info] Setting Scala version to 2.13.6 on 1 project. +... +sbt:example> example / test +... +[success] +{% endhighlight %} + +定期的に変更をコミットすることを検討してください。 + +全てのエラーの修正が完了したらScala 3でコンパイルを行う事ができるでしょう。 +ただMigration Warningだけがのこっていると思います。 +`-source:3.0-migration -rewrite` オプションとコンパイルで自動的にパッチが当てれるでしょう。 + +{% highlight text %} +sbt:example> ++3.0.0 +sbt:example> set example / scalacOptions += "-rewrite" +sbt:example> example / compile +... +[info] [patched file /example/src/main/scala/app/Main.scala] +[warn] two warnings found +[success] +{% endhighlight %} + +ここで`-source:3.0-migration` オプションお削除する必要があります。また、`-Xfatal-warnings` オプションを再度追加することもできます。 +リロード、忘れずに。 + +## 7. 移行の検証 + +まれに、異なるImplicit値が解決され、ランタイム時の動作が変更される可能性があります。 +良いテストはそのようなバグが見過ごされないようにする唯一の保証です。 + +Scala 2.13とScala 3でテストか通るかどうか確認してください。 + +{% highlight text %} +sbt:example> ++2.13.6 +sbt:example> example / test +... +[success] +sbt:example> ++3.0.0 +sbt:example> example / test +... +[success] +{% endhighlight %} + +もしCIパイプラインがあれば、Scala 3用にセットアップするときが来ました。 + +## 8. さいごに + +おめでとう！これで、モジュールがScala 3に移行できたはずです。 +プロジェクトがScala 3に完全移行されるまで、モジュールごとに同じプロセスを繰り返すことができます。 + +プログラムを相互公開するかどうかに応じてSala 2.13クロスビルディング構成を保持、または削除できます。 + +これでsbtプロジェクトの移行についての説明は終わりです。 From 9b68cd2b2becfc515888841745ee5c60a294d3c8 Mon Sep 17 00:00:00 2001 From: arata-honda Date: Thu, 25 Nov 2021 01:29:48 +0900 Subject: [PATCH 2/9] Fix not found hash link --- .../incompat-contextual-abstractions.md | 4 +- .../incompat-dropped-features.md | 14 ++--- .../incompat-other-changes.md | 16 +++--- .../scala3-migration/incompat-syntactic.md | 22 ++++---- .../scala3-migration/incompatibility-table.md | 54 +++++++++---------- .../scaladoc-settings-compatibility.md | 4 +- .../scala3-migration/incompatibility-table.md | 2 +- 7 files changed, 58 insertions(+), 58 deletions(-) diff --git a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md index f1e18f8768..4a67ea7a0b 100644 --- a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md +++ b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md @@ -12,10 +12,10 @@ language: ja |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibiltiy| |--- |--- |--- |--- |--- | -|[Type of implicit def](#type-of-implicit-definition)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| +|[暗黙的定義の型](#暗黙的定義の型)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| |[Implicit views](#implicit-views)||||**Possible**| |[View bounds](#view-bounds)|Deprecation|||| -|[Ambiguous conversion on `A` and `=> A`](#ambiguous-conversion-on-a-and--a)||||| +|[`A`と`=> A`でのあいまいな変換](#aと-aでのあいまいな変換)||||| ## 暗黙的定義の型 diff --git a/_ja/overviews/scala3-migration/incompat-dropped-features.md b/_ja/overviews/scala3-migration/incompat-dropped-features.md index 5542220e03..e371c997ec 100644 --- a/_ja/overviews/scala3-migration/incompat-dropped-features.md +++ b/_ja/overviews/scala3-migration/incompat-dropped-features.md @@ -13,13 +13,13 @@ language: ja |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | -|[Symbol literals](#symbol-literals)|Deprecation|✅|| -|[`do`-`while` construct](#do-while-construct)||✅|| -|[Auto-application](#auto-application)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| -|[Value eta-expansion](#value-eta-expansion)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| -|[`any2stringadd` conversion](#any2stringadd-conversion)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| -|[Early initializer](#early-initializer)|Deprecation||| -|[Existential type](#existential-type)|Feature warning||| +|[シンボリックリテラル](#シンボリックリテラル)|Deprecation|✅|| +|[`do`-`while` 構造](#do-while-構造)||✅|| +|[自動適用](#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| +|[Eta展開の値](#eta展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[`any2stringadd` 変換](#any2stringadd-変換)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| +|[先行初期化](#先行初期化)|Deprecation||| +|[存在型](#存在型)|Feature warning||| ## シンボリックリテラル diff --git a/_ja/overviews/scala3-migration/incompat-other-changes.md b/_ja/overviews/scala3-migration/incompat-other-changes.md index 563f4a905e..87293a6fb2 100644 --- a/_ja/overviews/scala3-migration/incompat-other-changes.md +++ b/_ja/overviews/scala3-migration/incompat-other-changes.md @@ -12,14 +12,14 @@ language: ja |Incompatibility|Scala 3 Migration Rewrite| |--- |--- | -|[Inheritance shadowing](#inheritance-shadowing)|✅| -|[Non-private constructor in private class](#non-private-constructor-in-private-class)|Migration Warning| -|[Abstract override](#abstract-override)|| -|[Case class companion](#case-class-companion)|| -|[Explicit call to unapply](#explicit-call-to-unapply)|| -|[Invisible bean property](#invisible-bean-property)|| -|[`=>T` as type argument](#-t-as-type-argument)|| -|[Wildcard type argument](#wildcard-type-argument)|| +|[継承シャドウイング](#継承シャドウイング)|✅| +|[プライベートクラスのNon privateなコンストラクタ](#プライベートクラスのnon-privateなコンストラクタ)|Migration Warning| +|[抽象オーバーライド](#抽象オーバーライド)|| +|[ケースクラスコンパニオン](#ケースクラスコンパニオン)|| +|[明示的な`unapply`の呼び出し](#明示的なunapplyの呼び出し)|| +|[見えないビーンプロパティ](#見えないビーンプロパティ)|| +|[型パラメータとしての`=> T`](#型パラメータとしての-t)|| +|[型引数のワイルドカード](#型引数のワイルドカード)|| ## 継承シャドウイング diff --git a/_ja/overviews/scala3-migration/incompat-syntactic.md b/_ja/overviews/scala3-migration/incompat-syntactic.md index f30f2a7b66..43c9f8313a 100644 --- a/_ja/overviews/scala3-migration/incompat-syntactic.md +++ b/_ja/overviews/scala3-migration/incompat-syntactic.md @@ -16,14 +16,14 @@ Scala 3では括弧がオプションナルなシンタックスと新しい制 殆どの変更は、[Scala 3移行コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意してください。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| -|--- |--- |--- |--- |--- | -|[Restricted keywords](#restricted-keywords)||✅|| -|[Procedure syntax](#procedure-syntax)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| -|[Parentheses around lambda parameter](#parentheses-around-lambda-parameter)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| -|[Open brace indentation for passing an argument](#open-brace-indentation-for-passing-an-argument)||✅|| -|[Wrong indentation](#wrong-indentation)|||| -|[`_` as a type parameter](#_-as-a-type-parameter)|||| -|[`+` and `-` as type parameters](#-and---as-type-parameters)|||| +|--- |--- |--- |--- | +|[制限された予約語](#制限された予約語)||✅|| +|[手続き型シンタックス](#手続き型シンタックス)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[Lambdaパラメータを囲む括弧](#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| +|[引数を渡すための括弧のインデント](#引数を渡すための括弧のインデント)||✅|| +|[間違ったインデント](#間違ったインデント)|||| +|[型パラメータとしての`_`](#型パラメータとしての)|||| +|[型パラメータとしての`+`と`-`](#型パラメータとしてのと)|||| ## 制限された予約語 @@ -62,9 +62,9 @@ object given { // Error: given is now a keyword } {% endhighlight %} -## 手続き型構文 +## 手続き型シンタックス -手続き型構文はしばらくの間非推奨になり、Scala 3では削除されました。 +手続き型シンタックスはしばらくの間非推奨になり、Scala 3では削除されました。 次のコードは現在使用できません。: ```scala @@ -203,7 +203,7 @@ Scala 3コンパイラはこのパターンを許容しません。: +def foo[T: Foo]: Unit = ??? {% endhighlight %} -## 型パラメータとしての`+` と `-` +## 型パラメータとしての`+`と`-` Scala 3の型パラメータとしては`+` と `-` は有効ではありません、なぜならこれらは変位指定のアノテーションとしての予約語だからです。 diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md index 9cace32a94..93c64a8e05 100644 --- a/_ja/overviews/scala3-migration/incompatibility-table.md +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -35,14 +35,14 @@ language: ja いくつかの古い構文はサポートされていないです。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| -|--- |--- |--- |--- |--- | -|[Restricted keywords](incompat-syntactic.html#restricted-keywords)||✅|| -|[Procedure syntax](incompat-syntactic.html#procedure-syntax)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| -|[Parentheses around lambda parameter](incompat-syntactic.html#parentheses-around-lambda-parameter)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| -|[Open brace indentation for passing an argument](incompat-syntactic.html#open-brace-indentation-for-passing-an-argument)||✅|| -|[Wrong indentation](incompat-syntactic.html#wrong-indentation)|||| -|[`_` as a type parameter](incompat-syntactic.html#_-as-a-type-parameter)|||| -|[`+` and `-` as type parameters](incompat-syntactic.html#-and---as-type-parameters)|||| +|--- |--- |--- |--- | +|[制限された予約語](incompat-syntactic.html#制限された予約語)||✅|| +|[手続き型シンタックス](incompat-syntactic.html#手続き型シンタックス)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[Lambdaパラメータを囲む括弧](incompat-syntactic.html#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| +|[引数を渡すための括弧のインデント](incompat-syntactic.html#引数を渡すための括弧のインデント)||✅|| +|[間違ったインデント](incompat-syntactic.html#間違ったインデント)|||| +|[型パラメータとしての`_`](incompat-syntactic.html#型パラメータとしての)|||| +|[型パラメータとしての`+`と`-`](incompat-syntactic.html#型パラメータとしてのと)|||| ### 機能の削除 @@ -50,13 +50,13 @@ language: ja |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | -|[Symbol literals](incompat-dropped-features.html#symbol-literals)|Deprecation|✅|| -|[`do`-`while` construct](incompat-dropped-features.html#do-while-construct)||✅|| -|[Auto-application](incompat-dropped-features.html#auto-application)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| -|[Value eta-expansion](incompat-dropped-features.html#value-eta-expansion)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| -|[`any2stringadd` conversion](incompat-dropped-features.html#any2stringadd-conversion)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| -|[Early initializer](incompat-dropped-features.html#early-initializer)|Deprecation||| -|[Existential type](incompat-dropped-features.html#existential-type)|Feature warning||| +|[シンボリックリテラル](incompat-dropped-features.html#シンボリックリテラル)|Deprecation|✅|| +|[`do`-`while` 構造](incompat-dropped-features.html#do-while-構造)||✅|| +|[自動適用](incompt-dropped-features.html#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| +|[Eta展開の値](incompat-dropped-features.html#eta展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[`any2stringadd` 変換](incompat-dropped-features.html#any2stringadd-変換)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| +|[先行初期化](incompat-dropped-features.html#先行初期化)|Deprecation||| +|[存在型](incompat-dropped-features.html#存在型)|Feature warning||| ### コンテキストの抽象化 @@ -80,14 +80,14 @@ language: ja |Incompatibility|Scala 3 Migration Rewrite| |--- |--- | -|[Inheritance shadowing](incompat-other-changes.html#inheritance-shadowing)|✅| -|[Non-private constructor in private class](incompat-other-changes.html#non-private-constructor-in-private-class)|Migration Warning| -|[Abstract override](incompat-other-changes.html#abstract-override)|| -|[Case class companion](incompat-other-changes.html#case-class-companion)|| -|[Explicit call to unapply](incompat-other-changes.html#explicit-call-to-unapply)|| -|[Invisible bean property](incompat-other-changes.html#invisible-bean-property)|| -|[`=>T` as type argument](incompat-other-changes.html#-t-as-type-argument)|| -|[Wildcard type argument](incompat-other-changes.html#wildcard-type-argument)|| +|[継承シャドウイング](incompat-other-changes.html#継承シャドウイング)|✅| +|[プライベートクラスのNon privateなコンストラクタ](incompat-other-changes.html#プライベートクラスのnon-privateなコンストラクタ)|Migration Warning| +|[抽象オーバーライド](incompat-other-changes.html#抽象オーバーライド)|| +|[ケースクラスコンパニオン](incompat-other-changes.html#ケースクラスコンパニオン)|| +|[明示的な`unapply`の呼び出し](incompat-other-changes.html#明示的な`unapply`の呼び出し)|| +|[見えないビーンプロパティ](incompat-other-changes.html#見えないビーンプロパティ)|| +|[型パラメータとしての`=> T`](incompat-other-changes.html#型パラメータとしての-t)|| +|[型引数のワイルドカード](incompat-other-changes.html#型引数のワイルドカード)|| ### 型チェッカー @@ -97,8 +97,8 @@ Scala 3は強力で理論的な基盤に基づいているため、型チェッ |Incompatibility| |--- | -|[Variance checks](incompat-type-checker.html#unsoundness-fixes-in-variance-checks)| -|[Pattern matching](incompat-type-checker.html#unsoundness-fixes-in-pattern-matching)| +|[分散チェック](incompat-type-checker.html#分散チェックの不具合修正)| +|[パターンマッチング](incompat-type-checker.html#パターンマッチングの不具合修正)| ### 型推論 @@ -106,8 +106,8 @@ Scala 3は強力で理論的な基盤に基づいているため、型チェッ |Incompatibility| |--- | -|[Return type of override method](incompat-type-inference.html#return-type-of-an-override-method)| -|[Reflective type](incompat-type-inference.html#reflective-type)| +|[オーバーライドしたメソッドの返り値の型](incompat-type-inference.html#オーバーライドしたメソッドの返り値の型)| +|[リフレクションの型](incompat-type-inference.html#リフレクションの型)| また、型推論アルゴリズムは全体的な再設計を行い改善されました。 この根本的な変更により、いくつかの非互換性が生じます。: diff --git a/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md index b761ab3f4d..3eada2ea0a 100644 --- a/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md +++ b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md @@ -19,8 +19,8 @@ language: ja | -doc-footer | -project-footer | A footer on every Scaladoc page, by default the EPFL/Lightbend copyright notice. Can be overridden with a custom footer. | Fixed by [#11965](https://github.com/lampepfl/dotty/issues/11965) | | | -doc-no-compile | _ | A directory containing sources which should be parsed for docstrings without compiling (e.g. AnyRef.scala) | We don't need this as we have completely different approach to that issue using -Ydocument-synthetic-types flag for synthetic types | | | -doc-source-url | -source-links | A URL pattern used to link to the source file, with some variables supported... | Scala3 implementation provides richer syntax. You can find migration steps below this [table](#source-links). | | -| -doc-external-doc | -external-mappings | Links describing locations of external dependencies' documentations. | Scala3 implementation provides richer syntax. You can find migration steps below this [table](#external-mappings). | | -| -jdk-api-doc-base | -external-mappings | URL used to link Java API references. | You can specify jdk via -external-mappings since they are generalized setting. You can find migration steps below this [table](#external-mappings) | | +| -doc-external-doc | -external-mappings | Links describing locations of external dependencies' documentations. | Scala3 implementation provides richer syntax. You can find migration steps below this [table](#外部マッピング). | | +| -jdk-api-doc-base | -external-mappings | URL used to link Java API references. | You can specify jdk via -external-mappings since they are generalized setting. You can find migration steps below this [table](#外部マッピング) | | | -doc-generator | _ | The fully qualified name of a doclet class, which will be used to generate the documentation. | We don't need this in Scala3 | | | -doc-root-content | -doc-root-content | The file from which the root package documentation should be imported. | | | | -implicits | _ | | We don't need this in Scala3 - Contextual extension methods are always documented in Scala 3 | | diff --git a/_overviews/scala3-migration/incompatibility-table.md b/_overviews/scala3-migration/incompatibility-table.md index 2943e01b95..999e5ff6b4 100644 --- a/_overviews/scala3-migration/incompatibility-table.md +++ b/_overviews/scala3-migration/incompatibility-table.md @@ -34,7 +34,7 @@ Each incompatibility is described by: Some of the old syntax is not supported anymore. |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| -|--- |--- |--- |--- |--- | +|--- |--- |--- |--- | |[Restricted keywords](incompat-syntactic.html#restricted-keywords)||✅|| |[Procedure syntax](incompat-syntactic.html#procedure-syntax)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| |[Parentheses around lambda parameter](incompat-syntactic.html#parentheses-around-lambda-parameter)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| From 0f03609ab81957ca68fb1b8ac661a37790f3309a Mon Sep 17 00:00:00 2001 From: arata-honda Date: Fri, 26 Nov 2021 09:58:16 +0900 Subject: [PATCH 3/9] Apply the advice given by eed3si9n --- .../compatibility-classpath.md | 2 +- .../scala3-migration/compatibility-intro.md | 30 +++++++++---------- .../compatibility-metaprogramming.md | 2 +- .../scala3-migration/compatibility-runtime.md | 2 +- .../scala3-migration/compatibility-source.md | 30 +++++++++---------- 5 files changed, 33 insertions(+), 33 deletions(-) diff --git a/_ja/overviews/scala3-migration/compatibility-classpath.md b/_ja/overviews/scala3-migration/compatibility-classpath.md index c594649136..0eed28ef4c 100644 --- a/_ja/overviews/scala3-migration/compatibility-classpath.md +++ b/_ja/overviews/scala3-migration/compatibility-classpath.md @@ -1,5 +1,5 @@ --- -title: Classpathレベル +title: クラスパス互換性 type: section description: このセクションでは、Scala 2.13とScala 3クラスファイルの互換性について説明しています。 num: 3 diff --git a/_ja/overviews/scala3-migration/compatibility-intro.md b/_ja/overviews/scala3-migration/compatibility-intro.md index 4ed49d659c..7762606da8 100644 --- a/_ja/overviews/scala3-migration/compatibility-intro.md +++ b/_ja/overviews/scala3-migration/compatibility-intro.md @@ -9,28 +9,28 @@ language: ja --- Scala 3はScalaエコシステムにおける互換性に関して革新的なものであり、全Scalaプログラマの日々の経験を大きく向上させるでしょう。 -この新しい互換性の時代は移行から始まります。 +互換性の新時代は、Scala 3 マイグレーションから始まる。 -Scala 2からScala 3に映ることは大きな急速進歩であります。 -Scalaはピカピカの新しいコンパイラで、言語のコアな基礎部分の完全なる再デザインを踏まえています。まだ、Scala 2.12からScala 2.13への移行のときよりは、ハードじゃないことを主張したいです。 +Scala 2からScala 3に移ることは大きな急速進歩であります。 +Scala 3 は、言語のコアな基礎部分の完全な再設計に基づき構築された新品のコンパイラだ。それでも、Scala 2.12 からScala 2.13 へのときよりも難しくないマイグレーションとなる自信がある。 -Scala 2.13とScala 3の間での相互互換性のおかげで一層シンプルになりました。 +Scala 2.13 と Scala 3 の間での相互互換性のおかげで、見方によっては以前よりもシンプルになったと言えるかもしれない。 この章では2つのバージョン差異における互換性の詳細について語る。 -ここでは、下記に従う疑問についての答えを見つけることができるでしょう。: +ここでは、下記に従う疑問についての答えを見つけることができるだろう。: -**[Sourceレベル](compatibility-source.html)** +**[ソース互換性](compatibility-source.html)** - Scala 3は異なる言語？ - Scala 2.13プロジェクトをScala 3に変換するのはどれくらいハード? -**[Classpathレベル](compatibility-classpath.html)** -- Scala 3ではScala 2.13のライブラリを使えるの？ -- 逆に、Scala 3のライブラリをScala 2.13で使えるの？ +**[クラスパス互換性](compatibility-classpath.html)** +- Scala 3ではScala 2.13のライブラリを使えるのか？ +- 逆に、Scala 3のライブラリをScala 2.13で使えるのか？ -**[Runtime](compatibility-runtime.html)** -- 本番環境においてScala 3プログラムを安全にデプロイできるの? -- Scala 2.13とくらべてScala 3はどれくらいはやいの？ +**[ランタイム互換性](compatibility-runtime.html)** +- 本番環境においてScala 3プログラムを安全にデプロイできるのか? +- Scala 2.13と比較してScala 3はどれくらいはやいのか？ -**[メタプログラミング](compatibility-metaprogramming.html)** -- 所有してるScala 2.13プロジェクトはScala 2のマクロ機能のリプレイスによって影響は出るのでしょうか？ -- どうやったら、所有するScala 2.13マクロライブラリをScala 3にうつせるの？ +**[メタプログラミング互換性](compatibility-metaprogramming.html)** +- 所有してるScala 2.13プロジェクトはScala 2のマクロ機能のリプレイスにより影響が出るのか？ +- どうすれば、所有するScala 2.13マクロライブラリをScala 3にうつせるのか？ diff --git a/_ja/overviews/scala3-migration/compatibility-metaprogramming.md b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md index 14ed94a061..9817cca1ab 100644 --- a/_ja/overviews/scala3-migration/compatibility-metaprogramming.md +++ b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md @@ -1,5 +1,5 @@ --- -title: メタプログラミング +title: メタプログラミング互換性 type: section description: このセクションではメタプログラミングの移行について議論します。 num: 5 diff --git a/_ja/overviews/scala3-migration/compatibility-runtime.md b/_ja/overviews/scala3-migration/compatibility-runtime.md index 5272de3974..54f8f11019 100644 --- a/_ja/overviews/scala3-migration/compatibility-runtime.md +++ b/_ja/overviews/scala3-migration/compatibility-runtime.md @@ -1,5 +1,5 @@ --- -title: Runtime +title: ランタイム互換性 type: section description: このセクションではScala 3のランタイム時の特性について記述しています。 num: 4 diff --git a/_ja/overviews/scala3-migration/compatibility-source.md b/_ja/overviews/scala3-migration/compatibility-source.md index a60e54f6c7..6c1fc4847e 100644 --- a/_ja/overviews/scala3-migration/compatibility-source.md +++ b/_ja/overviews/scala3-migration/compatibility-source.md @@ -1,5 +1,5 @@ --- -title: Sourceレベル +title: ソース互換性 type: section description: このセクションでは、Scala 2.13とScala3ソース間の互換性レベルについて説明しています。 num: 2 @@ -8,22 +8,22 @@ next-page: compatibility-classpath language: ja --- -Scala 3はScala 2のバージョン向上したものです。 +Scala 3 は、Scala 2 言語の改良版だ。 -新たなシンタクスにもかかわらず、Scala 2.13の大部分はまだ有効です。 -すべてではありませんが、一部の構成は単純化、制限、または完全に削除されています。 -しかしながらこれらの決定は正当な理由で、適切な回避策が可能であるように注意して作成されています。 +新構文も追加されたが、Scala 2.13 の言語仕様の大半は今後も有効となる。 +しかし、言語機能の一部は単純化されたり、制限されたり、完全に廃止されたものもある。 +これらの変更はもっともな理由があり、適切な回避策が可能であるように注意を払って決定された。 -一般的に、全ての非互換性に対する簡単なクロスコンパイルソリューションがあり、そしてそれはScala 2.13からScala 3へ簡単かつスムーズに移行します。 -非互換性のコーパスは [非互換性テーブル](incompatibility-table.html)に。 +一般的に、全ての非互換性に対する簡単なクロスコンパイルソリューションがあり、Scala 2.13からScala 3へ簡単かつスムーズに移行する。 +非互換性のコーパスは [非互換性テーブル](incompatibility-table.html)にある。 -ただし例外があり、そしてそれは従来のScala 2のマクロをリプレイスした新しいメタプログラミングフレームワークです。 -詳細説明に関しては、この章の終わりの[メタプログラミング](compatibility-metaprogramming.html)のセクションにあります。 +ただし例外があり、それは従来のScala 2のマクロをリプレイスした新しいメタプログラミングフレームワークだ。 +詳細説明に関しては、この章の終わりの[メタプログラミング](compatibility-metaprogramming.html)のセクションにある。 -メタプログラミングはおいておいて、Scala 2.13ソースコードはかなり簡単にScala 3に移植できます。 -移行が完了するとすぐに、あなたはScala 2にはないScala 3のパワフルな機能を使えるようになるでしょう。 -Scala 2.13のすべてのものがコンパイルできるというわけではないというのが欠点ではあります。 -しかしながら驚くことに、この新しいScala 3のアーティファクトはScala 2.13の依存関係として使用できます。 +メタプログラミングはさておき、Scala 2.13ソースコードはかなり簡単にScala 3に移植できる。 +移行が完了すると、Scala 2には存在しないScala 3の強力な機能を使えるようになるだろう。 +全てのScala 2.13ソースコードがコンパイルできるというわけではないというのが欠点だ。 +しかしながら驚くことに、新しいScala 3のアーティファクトはScala 2.13の依存関係として使用できる。 -詳細に説明するように、下位互換性と上位互換性があります。 -これはScala言語の歴史におけるブレイクスルーです。 +詳細に説明するように、下位互換性と上位互換性がある。 +これはScala言語の歴史におけるブレイクスルーだ。 From 484de1c88765148b52077838a37c439398e65fdd Mon Sep 17 00:00:00 2001 From: arata-honda Date: Fri, 26 Nov 2021 10:08:43 +0900 Subject: [PATCH 4/9] modify apply ommision --- _ja/overviews/scala3-migration/compatibility-source.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_ja/overviews/scala3-migration/compatibility-source.md b/_ja/overviews/scala3-migration/compatibility-source.md index 6c1fc4847e..af3e2dcfff 100644 --- a/_ja/overviews/scala3-migration/compatibility-source.md +++ b/_ja/overviews/scala3-migration/compatibility-source.md @@ -18,7 +18,7 @@ Scala 3 は、Scala 2 言語の改良版だ。 非互換性のコーパスは [非互換性テーブル](incompatibility-table.html)にある。 ただし例外があり、それは従来のScala 2のマクロをリプレイスした新しいメタプログラミングフレームワークだ。 -詳細説明に関しては、この章の終わりの[メタプログラミング](compatibility-metaprogramming.html)のセクションにある。 +詳細説明に関しては、この章の終わりの[メタプログラミング互換性](compatibility-metaprogramming.html)のセクションにある。 メタプログラミングはさておき、Scala 2.13ソースコードはかなり簡単にScala 3に移植できる。 移行が完了すると、Scala 2には存在しないScala 3の強力な機能を使えるようになるだろう。 From 4145e6aa6fcbc4c4c6935d57a00c000a01055204 Mon Sep 17 00:00:00 2001 From: arata-honda Date: Sat, 27 Nov 2021 01:02:37 +0900 Subject: [PATCH 5/9] Fix linking to internal hash --- _ja/overviews/scala3-migration/incompat-syntactic.md | 4 ++-- .../scala3-migration/incompatibility-table.md | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/_ja/overviews/scala3-migration/incompat-syntactic.md b/_ja/overviews/scala3-migration/incompat-syntactic.md index 43c9f8313a..7e745d8eac 100644 --- a/_ja/overviews/scala3-migration/incompat-syntactic.md +++ b/_ja/overviews/scala3-migration/incompat-syntactic.md @@ -22,8 +22,8 @@ Scala 3では括弧がオプションナルなシンタックスと新しい制 |[Lambdaパラメータを囲む括弧](#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| |[引数を渡すための括弧のインデント](#引数を渡すための括弧のインデント)||✅|| |[間違ったインデント](#間違ったインデント)|||| -|[型パラメータとしての`_`](#型パラメータとしての)|||| -|[型パラメータとしての`+`と`-`](#型パラメータとしてのと)|||| +|[型パラメータとしての`_`](#型パラメータとしての_)|||| +|[型パラメータとしての`+`と`-`](#型パラメータとしてのと-)|||| ## 制限された予約語 diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md index 93c64a8e05..ed5fe761fc 100644 --- a/_ja/overviews/scala3-migration/incompatibility-table.md +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -41,8 +41,8 @@ language: ja |[Lambdaパラメータを囲む括弧](incompat-syntactic.html#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| |[引数を渡すための括弧のインデント](incompat-syntactic.html#引数を渡すための括弧のインデント)||✅|| |[間違ったインデント](incompat-syntactic.html#間違ったインデント)|||| -|[型パラメータとしての`_`](incompat-syntactic.html#型パラメータとしての)|||| -|[型パラメータとしての`+`と`-`](incompat-syntactic.html#型パラメータとしてのと)|||| +|[型パラメータとしての`_`](incompat-syntactic.html#型パラメータとしての_)|||| +|[型パラメータとしての`+`と`-`](incompat-syntactic.html#型パラメータとしてのと-)|||| ### 機能の削除 @@ -52,7 +52,7 @@ language: ja |--- |--- |--- |--- | |[シンボリックリテラル](incompat-dropped-features.html#シンボリックリテラル)|Deprecation|✅|| |[`do`-`while` 構造](incompat-dropped-features.html#do-while-構造)||✅|| -|[自動適用](incompt-dropped-features.html#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| +|[自動適用](incompat-dropped-features.html#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| |[Eta展開の値](incompat-dropped-features.html#eta展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| |[`any2stringadd` 変換](incompat-dropped-features.html#any2stringadd-変換)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| |[先行初期化](incompat-dropped-features.html#先行初期化)|Deprecation||| @@ -64,10 +64,10 @@ language: ja |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibility| |--- |--- |--- |--- |--- | -|[Type of implicit def](incompat-contextual-abstractions.html#type-of-implicit-definition)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| +|[暗黙的定義の型](incompat-contextual-abstractions.html#暗黙的定義の型)|||[✅](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes)|| |[Implicit views](incompat-contextual-abstractions.html#implicit-views)||||**Possible**| |[View bounds](incompat-contextual-abstractions.html#view-bounds)|Deprecation|||| -|[Ambiguous conversion on `A` and `=> A`](incompat-contextual-abstractions.html#ambiguous-conversion-on-a-and--a)||||| +|[`A`と`=> A`でのあいまいな変換](incompat-contextual-abstractions.html#aと-aでのあいまいな変換)||||| さらに、暗黙の解決ルールを変更して、より便利で意外なものにならないようにしました。 新しいルールについては[ここ](/scala3/reference/changed-features/implicit-resolution.html)に説明しています。 @@ -84,7 +84,7 @@ language: ja |[プライベートクラスのNon privateなコンストラクタ](incompat-other-changes.html#プライベートクラスのnon-privateなコンストラクタ)|Migration Warning| |[抽象オーバーライド](incompat-other-changes.html#抽象オーバーライド)|| |[ケースクラスコンパニオン](incompat-other-changes.html#ケースクラスコンパニオン)|| -|[明示的な`unapply`の呼び出し](incompat-other-changes.html#明示的な`unapply`の呼び出し)|| +|[明示的な`unapply`の呼び出し](incompat-other-changes.html#明示的なunapplyの呼び出し)|| |[見えないビーンプロパティ](incompat-other-changes.html#見えないビーンプロパティ)|| |[型パラメータとしての`=> T`](incompat-other-changes.html#型パラメータとしての-t)|| |[型引数のワイルドカード](incompat-other-changes.html#型引数のワイルドカード)|| From 1afc769a96dbaed05e6d53e7e833b9feb91f4af4 Mon Sep 17 00:00:00 2001 From: arata-honda Date: Sun, 28 Nov 2021 00:10:03 +0900 Subject: [PATCH 6/9] Apply the advice on compatibility-classpath.md given by eed3si9n --- .../compatibility-classpath.md | 68 +++++++++---------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/_ja/overviews/scala3-migration/compatibility-classpath.md b/_ja/overviews/scala3-migration/compatibility-classpath.md index 0eed28ef4c..6b6f5b7a8b 100644 --- a/_ja/overviews/scala3-migration/compatibility-classpath.md +++ b/_ja/overviews/scala3-migration/compatibility-classpath.md @@ -1,31 +1,31 @@ --- title: クラスパス互換性 type: section -description: このセクションでは、Scala 2.13とScala 3クラスファイルの互換性について説明しています。 +description: このセクションは、Scala 2.13とScala 3クラスファイルの互換性について説明します。 num: 3 previous-page: compatibility-source next-page: compatibility-runtime language: ja --- -コード上で、パブリックな型と構文を利用でき、そしてパブリックメソッドは異なるモジュールやライブラリで定義されています。 -そしてできる限り長く型チェックとして働いて、コンパイルフェーズにてコードの意味的な構成を検証し、クラスファイルに含まれている型や構文やメソッドの重要性を読むことができます。 +コードを書くとき、他のモジュールやライブラリで定義されている公開型やフィールドを使ったり、公開メソッドを呼び出すことができる。 +これはコンパイラフェーズの一つである type checker が、公開型、フィールド、メソッドなどのシグネチャを各自を定義するクラスファイルから読み込むことができる限りうまくいく。type checker は、この情報を用いてコード上の意味的一貫性を検査し、これは型検査と呼ばれる。 -Scala 2ではシグネチャはpickleフォーマットで保存されます。 -Scala 3では少し違っていて、なぜならシグネチャレイアウトよりも多くのTASTyフォーマットに寄り添っているからです。 -しかしながらScala 2.13からScala 3へ移行する目的においては、シグネチャだけでも有効です。 +Scala 2 では、シグネチャは Pickle と呼ばれる独自のフォーマットを用いて保存される。 +Scala 3 では少し違っていて、シグネチャ情報だけに留まらずその他の多くの情報を持つ TASTy フォーマットを採用している。 +しかし、本題である Scala 2.13 から Scala 3 への移行において役に立つのはシグネチャだけだ。 ## Scala 3 Unpickler -はじめの良い知らせとしてScala 3のコンパイラはScala 2.13のpickleフォーマットを読み込むことができるということ、すなわち、Scala 2.13によりコンパイルされたモジュールやライブラリに依存したコードの型チェックができるということです。 +はじめの良い知らせとして Scala 3 のコンパイラは Scala 2.13 の Pickle フォーマットを読み込むことができるということ、すなわち、Scala 2.13 によりコンパイルされたモジュールやライブラリに依存したコードの型チェックができるということだ。 -Scala3のUnpicklerは数年間広範囲的にコミュニティビルドによってテストされています。なので使うこと自体は安全です。 +Scala 3 の Unpickler は数年間広範囲的にコミュニティビルドによってテストされている。なので使うこと自体は安全だ。 -### Scala 3モジュールはScala 2.13アーティファクトに依存できます +### Scala 3 モジュールは Scala 2.13 アーティファクトに依存できる ![Scala 3 module depending on a Scala 2.13 artifact](/resources/images/scala3-migration/compatibility-3-to-213.svg) -sbtビルドとして、次のように説明できます（sbt 1.5.0以降が必要です）: +sbt ビルドとして、次のように説明できる( sbt 1.5.0 以降が必要だ): ```scala lazy val foo = project.in(file("foo")) @@ -36,7 +36,7 @@ lazy val bar = project.in(file("bar")) .settings(scalaVersion := "2.13.6") ``` -または、barが公開されたScala 2.13ライブラリである場合は、次のことができます。: +または、bar が公開された Scala 2.13 ライブラリである場合は、次のことができる。: ```scala lazy val foo = project.in(file("foo")) @@ -46,24 +46,24 @@ lazy val foo = project.in(file("foo")) ) ``` -sbtで `CrossVersion.for3Use2_13`を使用して、 `bar_3`の代わりに`bar_2.13`を解決します。 +sbt で `CrossVersion.for3Use2_13` を使用して、`bar_3` の代わりに `bar_2.13` を解決する。 -### スタンダードライブラリ +### 標準ライブラリ -1つ目のノート例はScala 2.13ライブラリです。 -Scala 2.13ライブラリがScala 3用の公式スタンダードライブラリとして確かに決定しています。 +Scala 2.13 標準ライブラリは、重要なクロス依存性の例だ。 +実は、Scala 2.13 標準ライブラリをそのまま Scala 3 用の公式標準ライブラリとして採用した。 -スタンダードライブラリは自動的にビルドツールに与えられることを覚えておきましょう、なので手動的に設定する必要はありません。 +標準ライブラリは自動的にビルドツールにより与えられるため、手動で設定する必要はありません。 -## Scala 2.13のTASTy読み取り機能 +## Scala 2.13 の TASTy 読み取り機能 -2つ目の良い知らせはscala 2.13.4からリリースされたTASTy読み取り機能がScala 3ライブラリで使えるということです。 +2つ目の良い知らせは、Scala 2.13.4 より Scala 2.13 TASTy 読み取り機能がリリースされ、Scala 2.13 側から Scala 3 で書かれたライブラリ群の呼び出しが可能となったことだ。 -> TASTy読み取り機能は非常に新しいものです。そのため、`-Ytasty-reader` フラグの下でのみ使用できます。 +> TASTy 読み取り機能はとても新しいものだ。そのため、`-Ytasty-reader` フラグ下でのみ使用できる。 ### サポートされている機能 -TASTy読み取り機能は、すべての従来の言語機能に加えて、次の新しい機能をサポートします。: +TASTy 読み取り機能は、すべての従来の言語機能に加えて、次の新しい機能をサポートする。: - [Enumerations]({% link _scala3-reference/enums/enums.md %}) - [Intersection Types]({% link _scala3-reference/new-types/intersection-types.md %}) - [Opaque Type Aliases]({% link _scala3-reference/other-new-features/opaques.md %}) @@ -89,13 +89,13 @@ TASTy読み取り機能は、すべての従来の言語機能に加えて、次 - [Inline]({% link _scala3-reference/metaprogramming/inline.md %}) (including Scala 3 macros) - [Kind Polymorphism]({% link _scala3-reference/other-new-features/kind-polymorphism.md %}) (the `scala.AnyKind` upper bound) -### Scala 2.13モジュールScala 3アーティファクトに依存できます +### Scala 2.13 モジュールは Scala 3 アーティファクトに依存できる -`-Ytasty-reader`でTASTyリーダーを有効にすることで、Scala 2.13モジュールはScala 3アーティファクトに依存できます。 +`-Ytasty-reader` で TASTy 読み取り機能を有効にすることで、Scala 2.13 モジュールは Scala 3 アーティファクトに依存できる。 ![Scala 2 module depending on a Scala 3 artifact](/resources/images/scala3-migration/compatibility-213-to-3.svg) -sbtビルドとして、次のように説明できます。: +sbt ビルドとして、次のように説明できる。: ```scala lazy val foo = project.in.file("foo") @@ -109,7 +109,7 @@ lazy val bar = project.in(file("bar")) .settings(scalaVersion := "3.0.0") ``` -または、`bar`が公開されたScala 3ライブラリの場合: +または、`bar` が公開された Scala 3 ライブラリの場合: ```scala lazy val foo = project.in.file("foo") @@ -120,25 +120,25 @@ lazy val foo = project.in.file("foo") ) ``` -`CrossVersion.for2_13Use3`と同様に、sbtで `CrossVersion.for3Use2_13`を使用して、`bar_2.13`ではなく`bar_3`を解決します。 +`CrossVersion.for2_13Use3` と同様に、sbt で `CrossVersion.for3Use2_13` を使用して、`bar_2.13` ではなく `bar_3` を解決する。 ## 相互運用性の概要 -要するに、下位、上位互換性があり、そしてそれにより**移行が段階的に行うことが可能になるのです**。 +要するに、下位、上位互換性があり、そしてそれにより**移行が段階的に行うことが可能になる**。 -ライブラリの依存関係がまだ移植されてない場合（マクロライブラリを除く）でも、一度にScalaアプリケーションの一つのモジュールを移植することができます。 +ライブラリの依存関係がまだ移植されてない場合(マクロライブラリを除く)でも、一度に Scala アプリケーションの一つのモジュールを移植することができる。 -移行期間中、Scala 2.13モジュール間で、Scala 3モジュールを持つことができます。 +移行期間中、2 つの Scala 2.13 モジュールで挟まれた Scala 3 モジュール層を扱うことができる。 ![Sandwich pattern](/resources/images/scala3-migration/compatibility-sandwich.svg) -これはできるだけ長くすべてのライブラリが単一バイナリバージョンを解決できるように許しておます: `lib-foo_3` と `lib-bar_2.13` を同じクラスパスに持つことができますが、`lib-foo_3` と `lib-foo_2.13`を含めることはできません. +クロス依存性は、全てのライブラリがそれぞれ単一のバイナリバージョンへと解決される限り許される。例えば、`lib-foo_3` と `lib-bar_2.13` を同じクラスパスに持つことができるが、`lib-foo_3` と `lib-foo_2.13` を含めることはできない。 -この逆のパターン、すなわち2.13モジュールが中央にある場合でも可能です。 +この逆のパターン、すなわち 2.13 モジュールが中央にある場合でも可能だ。 -> #### ライブラリメンテナンスの免責事項 +> #### ライブラリ作者への注意 > -> 公開されているライブラリの中でScala 2.13とScala 3間の相互運用性を使うことは一般的にエンドユーザにとっては安全ではないです。 +> 公開ライブラリの中で Scala 2.13 と Scala 3 間の相互運用性を使うと、多くの場合そのライブラリを使用するエンドユーザにとって安全では無いことに注意してほしい。 > -> 何をしているか正確に知らない限り、Scala 2.13に依存するScala 3のライブラリを公開することはおすすめできないです（Scala-libraryは除く）し逆も然りです. -> 理由としては、ライブラリユーザがクラスパス内の同じfooライブラリの中の競合するバージョン`foo_2.13`, `foo_3`で終わるのを防ぐためで、この問題は場合によっては解決することができません。 \ No newline at end of file +> 状況を完全に理解した上級ユーザ以外は、( scala-library 以外の) Scala 2.13 系ライブラリに依存した Scala 3系のライブラリを公開することは非推奨とされており、逆も然りだ。 +> なぜなら、ライブラリを使用するユーザを、クラスパス内の同じ foo ライブラリ内の2つのバージョンである `foo_2.13` と `foo_3` の競合から防ぐためであり、この問題は場合によっては解決することができない。 \ No newline at end of file From 74d38305cc0547300c9ee05e6fb9800fc7a96bdf Mon Sep 17 00:00:00 2001 From: arata-honda Date: Sun, 28 Nov 2021 22:50:53 +0900 Subject: [PATCH 7/9] Apply the advice on compatibility-runtime.md and compatibility-metaprograming.md given by eed3si9n --- .../scala3-migration/compatibility-intro.md | 2 +- .../compatibility-metaprogramming.md | 60 +++++++++---------- .../scala3-migration/compatibility-runtime.md | 26 ++++---- .../incompat-contextual-abstractions.md | 4 +- .../scala3-migration/incompat-type-checker.md | 6 +- .../scala3-migration/incompatibility-table.md | 4 +- _ja/overviews/scala3-migration/options-new.md | 2 +- .../scala3-migration/plugin-kind-projector.md | 2 +- .../tooling-migration-mode.md | 2 +- .../scala3-migration/tooling-tour.md | 2 +- .../scala3-migration/tutorial-sbt.md | 6 +- 11 files changed, 58 insertions(+), 58 deletions(-) diff --git a/_ja/overviews/scala3-migration/compatibility-intro.md b/_ja/overviews/scala3-migration/compatibility-intro.md index 7762606da8..70cad6de3c 100644 --- a/_ja/overviews/scala3-migration/compatibility-intro.md +++ b/_ja/overviews/scala3-migration/compatibility-intro.md @@ -27,7 +27,7 @@ Scala 2.13 と Scala 3 の間での相互互換性のおかげで、見方によ - Scala 3ではScala 2.13のライブラリを使えるのか？ - 逆に、Scala 3のライブラリをScala 2.13で使えるのか？ -**[ランタイム互換性](compatibility-runtime.html)** +**[実行時互換性](compatibility-runtime.html)** - 本番環境においてScala 3プログラムを安全にデプロイできるのか? - Scala 2.13と比較してScala 3はどれくらいはやいのか？ diff --git a/_ja/overviews/scala3-migration/compatibility-metaprogramming.md b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md index 9817cca1ab..0242d54e90 100644 --- a/_ja/overviews/scala3-migration/compatibility-metaprogramming.md +++ b/_ja/overviews/scala3-migration/compatibility-metaprogramming.md @@ -1,26 +1,26 @@ --- title: メタプログラミング互換性 type: section -description: このセクションではメタプログラミングの移行について議論します。 +description: このセクションはメタプログラミングの移行を解説する。 num: 5 previous-page: compatibility-runtime next-page: tooling-tour language: ja --- -マクロを呼ぶメソッドはマクロ展開と呼ばれるコンパイラフェーズ中に実行され、プログラムの一部である抽象的なシンタックスツリーを生成します。 +マクロメソッドの呼び出しは、マクロ展開と呼ばれるコンパイラフェーズの中で実行され、抽象構文木 (つまりプログラムの一部) を生成する。 -Scala 2.13のマクロAPIはScala 2.13コンパイラの内部と密接に関連しています。 -それゆえ、Scala 3コンパイラではScala 2.13マクロを展開することはできないのです。 +Scala 2.13 のマクロ API は Scala 2.13 コンパイラの内部と密接に関連している。 +それゆえ、Scala 3 コンパイラでは Scala 2.13 マクロを展開することはできない。 -対象的に、Scala 3ではメタプログラミングの新たで原理的なアプローチを導入しており、安定性のために設計されています。 -Scala 3マクロとそしてそのインラインメソッドは通常、Scala 3コンパイラの将来のバージョンと互換性があります。 -これは異論のない改善ですが、新しいメタプログラミング機能を使用して、すべてのScala 2.13マクロをゼロから書き直す必要があるということも意味しています。 +一方 Scala 3 は、安定性を考慮して設計しなおされた、新たなメタプログラミングの方法を導入する。 +Scala 3 マクロとそしてそのインラインメソッドは通常、Scala 3 コンパイラの将来のバージョンと互換性がある。 +これは異論のない改善だが、新しいメタプログラミング機能を使用して、すべての Scala 2.13 マクロをゼロから書き直す必要があるということも意味している。 -## マクロの依存 +## マクロを定義するライブラリ依存性 -Scala 3のモジュールはマクロ定義が含まれているScala 2.13アーティファクトに依存することができますがコンパイラはそれらのマクロを展開することはできないでしょう。 -シンプルにエラーとして帰ってきます。 +Scala 3 のモジュールはマクロ定義が含まれている Scala 2.13 アーティファクトに依存することができますが、コンパイラはそれらのマクロを展開することはできないだろう。 +マクロ展開に当たると、それは単にエラーが返ってくるようになる。 {% highlight text %} -- Error: /src/main/scala/example/Example.scala:10:45 @@ -30,42 +30,42 @@ Scala 3のモジュールはマクロ定義が含まれているScala 2.13アー |To turn this error into a warning, pass -Xignore-scala2-macros to the compiler {% endhighlight %} -`-Xignore-scala2-macros` を使うことはコードの型チェックに役立つだけではなく、未完成なクラスファイルを生成します。 +`-Xignore-scala2-macros` を使うことで型検査の役には立つが、不完全なクラスファイルを生成することに注意してほしい。 -あなたのプロジェクトでこのエラーが出た時、あなたは次第にマクロアーティファクトのScala 3コンパイルバージョンを上げるほか選択肢がなくなるでしょう +あなたのプロジェクトでこのエラーが出た場合、結局の所、マクロ定義元のアーティファクトを Scala 3 系にアップグレードする以外の選択肢は残されていない。 ## マクロエコシステムの移行 -実験的ではありながら、ScalaコミュニティはScala 2マクロ機能を複数の方法で大きく適用させてきました。: コード生成, 最適化, 人間工学的なDSL... +Scala 2 マクロは実験的機能とは言われつつも、実際の所 Scala コミュニティーは広範囲に渡ってマクロを採用し、コード生成、最適化、使い易い DSL など様々な面で使われている。 -大部分のエコシステムは現在Scala 2.13マクロにより定義されている外部ライブラリに依存しています。 -それらのライブラリの識別や移植はエコシステムを前に動かすキーとなるでしょう。 +大部分のエコシステムは現在 Scala 2.13 マクロにより定義されている外部ライブラリに依存してる。 +それらのライブラリの識別や移植はエコシステムを前進させるだろう。 -[このページ](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html)にたくさんのオープンソースの移行状態が可視化されています。. +[このページ](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html)に多くのオープンソースの移行状態が可視化されている。 -## マクロの再記述 +## マクロの書き換え -この新しいメタプログラミング機能は完全にScala 2と異なります。 +この新しいメタプログラミング機能は完全に Scala 2 と異なる。 構成としては: - [インラインメソッド][inline] -- [コンパイル時間のオペレーション][compiletime] +- [コンパイル時の演算][compiletime] - [マクロ][macros] -- [クォーテッドコード][quotes] -- [抽象的シンタックスツリーを超えた反映 (AST)][reflection] +- [クォート][quotes] +- [抽象構文木 (AST) のリフレクション][reflection] -マクロを再実装する前に次のことを自問する必要があります。: -- `インライン`と`scala.compiletime`を使用してロジックの再実装できますか? -- シンプルかつ安全にマクロ展開ができるか? -- ASTにアクセスすることが本当に必要なことですか? -- 返却型として[マッチタイプ](/scala3/reference/new-types/match-types.html) を利用しますか? +マクロの再実装に深入りしてしまう前に、以下を自問するべきだ: +- `inline` と `scala.compiletime` を使用してロジックの再実装できるだろうか? +- よりシンプルで安全な式ベースのマクロを使うことができるか? +- AST にアクセスすることが本当に必要なことか? +- 返り値の型として[マッチタイプ](/scala3/reference/new-types/match-types.html) を使うことができるだろうか? -あなたは全ての新メタプログラミング概念を [Macro Tutorial][scala3-macros]を読むことで学ぶことができます。 +新しく登場したメタプログラミングの概念の全ては [Macro Tutorial][scala3-macros] にて解説してある。 ## マクロライブラリのクロスビルド -素晴らしいマクロライブラリを書き終わると、Scala 2.13とScala 3の中で利用可能になります。 -ここで２つの異なるアプローチがあり、伝統的なクロスビルド技術と、より最新の合成マクロ技術があります。 -あなたは下記のチュートリアルを読むことでそれを学ぶことができます。: +素晴らしいマクロライブラリを書いて、Scala 2.13 系と Scala 3 系の両方でリリースしたいとする。 +その場合、従来のクロスビルドと、より新しい mixing macro という 2つの異なるアプローチがある。 +詳細は以下のチュートリアルを参考にしてほしい: - [Cross-Building a Macro Library](tutorial-macro-cross-building.html) - [Mixing Scala 2.13 and Scala 3 Macros](tutorial-macro-mixing.html) diff --git a/_ja/overviews/scala3-migration/compatibility-runtime.md b/_ja/overviews/scala3-migration/compatibility-runtime.md index 54f8f11019..71a0c02632 100644 --- a/_ja/overviews/scala3-migration/compatibility-runtime.md +++ b/_ja/overviews/scala3-migration/compatibility-runtime.md @@ -1,29 +1,29 @@ --- -title: ランタイム互換性 +title: 実行時互換性 type: section -description: このセクションではScala 3のランタイム時の特性について記述しています。 +description: このセクションではScala 3の実行時の特性について記述しています。 num: 4 previous-page: compatibility-classpath next-page: compatibility-metaprogramming language: ja --- -Scala 2.13とScala 3は同じアプリケーションバイナリインターフェイス(ABI)を共有します。 +Scala 2.13 と Scala 3 は同じアプリケーションバイナリインターフェイス ( ABI ) を共有する。 -> ABIはバイトコード上、またはScala.js IRでScalaコードを表現しているものです。 -> ABIはランタイムにおけるScalaプログラムの振る舞いを決めます。 +> ABI はバイトコード上、または Scala.js IR で Scala コードを表現しているものだ。 +> ABI は実行時における Scala プログラムの振る舞いを決める。 -Scala 2.13とScala 3の混ざった同一ソースコードをコンパイルすると、とても似ているバイトコードを生成します。 -違いとしてはいくつかの機能が変更されたことで、lazy valの初期化インスタンスが向上しています。 +Scala 2.13 と Scala 3 の混ざった同一ソースコードをコンパイルすると、非常に似たバイトコードを生成する。 +違いとしてはいくつかの機能が変更されたことで、例えば lazy val の初期化が改善した。 -ABIの共有によりScala 2.13とScala 3ファイルを同じJVMクラスによりロードできるようになります。 -同様に、Scala 2.13ファイルとScala 3 `sjsir` ファイルは、Scala.jsリンカーによってリンクできます。 +ABI の共有により Scala 2.13 と Scala 3 ファイルを同じ JVM クラスでロードできる。 +同様に、Scala 2.13 ファイルと Scala 3 `sjsir` ファイルは、Scala.js リンカーによってリンクできる。 -更に、ランタイム時の突発的なふるまいから我々を守ってくれます。 -そして、Scala 2.13からScala 3の移行で、ランタイム時時のクラッシュとパフォーマンスを安全にしてくれます。 +予期せぬ実行時の振る舞いをある程度軽減させることができる。 +そして、Scala 2.13からScala 3の移行で、実行時のクラッシュとパフォーマンスを安全にしてくれます。 -まずはじめに、Scalaプログラムの実行時の特性を確認することは、Scala 2.13と比較してScala 3では良くも悪くもありません。 -しかしながら、いくつかの新しい機能があなたの課題に関して選択肢を与えてくれるでしょう。: +Scala 3 で書かれたプログラムの実行時特性は、一見したところ Scala 2.13系と比較して良くも悪くもなっていない。 +しかし、以下の新機能によってプログラムの最適化を行うことができる: - [Opaque Type Aliases](http://dotty.epfl.ch/docs/reference/other-new-features/opaques.html) - [Inline Methods](http://dotty.epfl.ch/docs/reference/metaprogramming/inline.html) - [@threadUnsafe annotation](http://dotty.epfl.ch/docs/reference/other-new-features/threadUnsafe-annotation.html) diff --git a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md index 4a67ea7a0b..d4bee0b9ae 100644 --- a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md +++ b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md @@ -41,9 +41,9 @@ def pretty[A](a: A)(implicit ev: A => Pretty): String = [Scala 3移行コンパイル](tooling-migration-mode.html)これらのケースについてWARNINGを出してくれまが、直すことはできません。 -この非互換性により、ランタイム時の非互換性を引き起こし、プログラムが破損する可能性があることに注意してください。 +この非互換性により、実行時の非互換性を引き起こし、プログラムが破損する可能性があることに注意してください。 実際、コンパイラはより広いスコープで別の暗黙的変換を見つけることができます。 -これにより、ランタイム時の望んでいない動作が発生します。 +これにより、実行時の望んでいない動作が発生します。 この例は、次の場合を示しています。: diff --git a/_ja/overviews/scala3-migration/incompat-type-checker.md b/_ja/overviews/scala3-migration/incompat-type-checker.md index 9f02f67849..539c9ddb94 100644 --- a/_ja/overviews/scala3-migration/incompat-type-checker.md +++ b/_ja/overviews/scala3-migration/incompat-type-checker.md @@ -9,13 +9,13 @@ language: ja --- Scala 2.13の型チェッカーは一部の特定のケースでは挙動がおかしいです。 -これにより、予期しない場所で予期しないランタイム時エラーなどが発生する可能性があります。 +これにより、予期しない場所で予期しない実行時エラーなどが発生する可能性があります。 Scala 3はより強力な理論的基盤に基づいており、型チェッカーのこれらの不健全なバグは修正されました。 ## 分散チェックの不具合修正 Scala 2では、デフォルトのパラメータと内部クラスは分散チェックの対象ではありません。 -Scala 3リポジトリでのこの[テスト](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/tests/neg/variances.scala)で示されているように、健全ではなく、ランタイム時エラーを引き起こす可能性があります。 +Scala 3リポジトリでのこの[テスト](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/tests/neg/variances.scala)で示されているように、健全ではなく、実行時エラーを引き起こす可能性があります。 Scala3コンパイラは以下のコードを許容していません。 @@ -106,7 +106,7 @@ object Request { Scala 2から、明らかに間違っているコードを見つけるのに便利な改善です。 この非互換性を解決するには、コンパイラがチェックできる解決策を見つけるようにすることです。 -ただし、必ずしも簡単なわけではなく、時には不可能な場合もあり、その場合、コードはランタイム時に失敗する可能性があります。 +ただし、必ずしも簡単なわけではなく、時には不可能な場合もあり、その場合、コードは実行時に失敗する可能性があります。 この例では、`A`が両方の型引数の共通の親であると宣言することにより、`x`と`y`の制約を緩和すること示します。 これにより、コンパイラはコードを正常に型チェックします。 diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md index ed5fe761fc..93a27170fc 100644 --- a/_ja/overviews/scala3-migration/incompatibility-table.md +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -10,7 +10,7 @@ language: ja 非互換性とは、Scala 2.13でコンパイルできるがScala 3ではなできないコードの一部のことです。 コードベースの移行には、ソースコードの全ての非互換性を見つけて修正することが含まれています。 -極稀に、我々はランタイム時の非互換性に遭遇します：動作が異なるコードの一部です。 +極稀に、我々は実行時の非互換性に遭遇します：動作が異なるコードの一部です。 このページでは我々は既知の非互換性の分類を提案します。 それぞれの非互換性は以下のように説明されています。: @@ -92,7 +92,7 @@ language: ja ### 型チェッカー Scala 2.13の型チェッカーはある特定のケースに関して解決できないです。 -これは思いもしない驚異的なランタイム時エラーを導いてしまいます。 +これは思いもしない驚異的な実行時エラーを導いてしまいます。 Scala 3は強力で理論的な基盤に基づいているため、型チェッカーのこれらの不健全なバグが修正されました。 |Incompatibility| diff --git a/_ja/overviews/scala3-migration/options-new.md b/_ja/overviews/scala3-migration/options-new.md index 3b7be35db6..a06e56b63f 100644 --- a/_ja/overviews/scala3-migration/options-new.md +++ b/_ja/overviews/scala3-migration/options-new.md @@ -37,7 +37,7 @@ language: ja | 3.0.x | description | |-|-| -| `-Xignore-scala2-macros` | Scala 2マクロを呼び出すコードをコンパイルするときのエラーを無視しますがランタイム時に失敗するでしょう。 | +| `-Xignore-scala2-macros` | Scala 2マクロを呼び出すコードをコンパイルするときのエラーを無視しますが実行時に失敗するでしょう。 | | `-Ximport-suggestion-timeout` | エラーが報告されたときにインポート候補を検索するためのタイムアウト（ミリ秒単位）。 | | `-Xmax-inlined-trees` | インラインツリーの最大数。 Default: 2000000 | | `-Xmax-inlines` | 連続するインラインの最大数。 Default: 32. | diff --git a/_ja/overviews/scala3-migration/plugin-kind-projector.md b/_ja/overviews/scala3-migration/plugin-kind-projector.md index dc73f20c15..4228f1c11b 100644 --- a/_ja/overviews/scala3-migration/plugin-kind-projector.md +++ b/_ja/overviews/scala3-migration/plugin-kind-projector.md @@ -73,7 +73,7 @@ Either[Int, +*] // equivalent to: type R[+A] = Either[Int, A] Function2[-*, Long, +*] // equivalent to: type R[-A, +B] = Function2[A, Long, B] ``` -## 非互換性構造の再記述 +## 非互換性構造の書き換え Scala 3の`-Ykind-projector` と `-Ykind-projector:underscores` は、`kind-projector`シンタックスの部分集合のみを実装し、それ以外は特に実装しません。: diff --git a/_ja/overviews/scala3-migration/tooling-migration-mode.md b/_ja/overviews/scala3-migration/tooling-migration-mode.md index fef293858c..e31ce00f34 100644 --- a/_ja/overviews/scala3-migration/tooling-migration-mode.md +++ b/_ja/overviews/scala3-migration/tooling-migration-mode.md @@ -40,7 +40,7 @@ where possible standard options include: 我々はこれを **Scala 3 migration compilation**とよんでいます. -## 自動再記述 +## 自動書き換え 一度マイグレーションモードでコンパイルすると、ほとんど全てのWARNINGはコンパイラによって自動的に解決されます。 これを行うためには、再度コンパイルする必要があり、今回は、 `-source:3.0-migration` と　`-rewrite` オプションを使います。 diff --git a/_ja/overviews/scala3-migration/tooling-tour.md b/_ja/overviews/scala3-migration/tooling-tour.md index 8f66865f1e..919e9b7619 100644 --- a/_ja/overviews/scala3-migration/tooling-tour.md +++ b/_ja/overviews/scala3-migration/tooling-tour.md @@ -131,7 +131,7 @@ fileOverride { このステップはシンタックスの非推奨を修正するためにScalafixや既存ルールに依存します。 - 型を明示してコードを移行: Scala 3はあたらしい型インタフェースのアルゴリズムをもっており、Scala 2の推論とはわずかに異なります。 - 最後のステップでは、ランタイム時の動作を変更せずにプロジェクトをScala 3でコンパイルできるように、型の最小セットを明示します。 + 最後のステップでは、実行時の動作を変更せずにプロジェクトをScala 3でコンパイルできるように、型の最小セットを明示します。 ## Scaladex diff --git a/_ja/overviews/scala3-migration/tutorial-sbt.md b/_ja/overviews/scala3-migration/tutorial-sbt.md index a85540c27b..e26f4af61f 100644 --- a/_ja/overviews/scala3-migration/tutorial-sbt.md +++ b/_ja/overviews/scala3-migration/tutorial-sbt.md @@ -35,11 +35,11 @@ Scala 2.13とScala 3の相互互換性のおかげで、あなたは全てのモ コードベースの移行の2つの主な課題は次のとおりです。: - コードコンパイルする -- ランタイム時の動作で変更がされていないことの確認をする +- 実行時の動作で変更がされていないことの確認をする クロスビルド戦略をおすすめしており、Scala 3とScala 2.13の両方でコンパイルすることです。 背後にあるロジックは修正のたびにScala 2.13でテストを実行できるようにすることです。 -これにより、ランタイムの動作が変更されていなことを確認ですることができます。 +これにより、実行時の動作が変更されていなことを確認ですることができます。 これは、非互換性を修正するときに発生する可能性のあるバグを回避するために重要です。 sbtのクロスビルディング設定は以下の様にまとめられます。: @@ -202,7 +202,7 @@ sbt:example> example / compile ## 7. 移行の検証 -まれに、異なるImplicit値が解決され、ランタイム時の動作が変更される可能性があります。 +まれに、異なるImplicit値が解決され、実行時の動作が変更される可能性があります。 良いテストはそのようなバグが見過ごされないようにする唯一の保証です。 Scala 2.13とScala 3でテストか通るかどうか確認してください。 From d767cf7f01ba83d820ebb4d7ce741707819bc37f Mon Sep 17 00:00:00 2001 From: arata-honda Date: Thu, 2 Dec 2021 00:07:25 +0900 Subject: [PATCH 8/9] Adjust the tone --- .../scala3-migration/external-resources.md | 8 +- .../incompat-contextual-abstractions.md | 55 +++---- .../incompat-dropped-features.md | 86 +++++------ .../incompat-other-changes.md | 94 +++++------ .../scala3-migration/incompat-syntactic.md | 87 +++++------ .../scala3-migration/incompat-type-checker.md | 50 +++--- .../incompat-type-inference.md | 30 ++-- .../scala3-migration/incompatibility-table.md | 81 +++++----- .../scala3-migration/options-intro.md | 14 +- .../scala3-migration/options-lookup.md | 40 ++--- _ja/overviews/scala3-migration/options-new.md | 146 +++++++++--------- .../scala3-migration/plugin-intro.md | 6 +- .../scala3-migration/plugin-kind-projector.md | 50 +++--- .../scaladoc-settings-compatibility.md | 33 ++-- .../tooling-migration-mode.md | 36 ++--- .../tooling-syntax-rewriting.md | 82 +++++----- .../scala3-migration/tooling-tour.md | 99 ++++++------ .../scala3-migration/tutorial-intro.md | 16 +- .../tutorial-macro-cross-building.md | 74 ++++----- .../scala3-migration/tutorial-macro-mixing.md | 76 ++++----- .../tutorial-prerequisites.md | 94 +++++------ .../scala3-migration/tutorial-sbt.md | 141 +++++++++-------- 22 files changed, 712 insertions(+), 686 deletions(-) diff --git a/_ja/overviews/scala3-migration/external-resources.md b/_ja/overviews/scala3-migration/external-resources.md index 565751c136..7ecdae994a 100644 --- a/_ja/overviews/scala3-migration/external-resources.md +++ b/_ja/overviews/scala3-migration/external-resources.md @@ -1,7 +1,7 @@ --- title: 外部リソース type: section -description: このセクションでは、Scala 3への移行に関する外部リソースを一覧表示します。 +description: このセクションでは、Scala 3 への移行に関する外部リソースを一覧表示します。 num: 27 previous-page: plugin-kind-projector next-page: @@ -10,11 +10,11 @@ language: ja ## コース -### Lunatechの[_Moving from Scala 2 to Scala 3_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course) +### Lunatech の[_Moving from Scala 2 to Scala 3_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course) -Scala 3の最新情報を検討している方や、既存のScala 2アプリケーションをScala 3に移行することを検討している開発者であればLunatechの [_"Moving from Scala 2 to Scala 3"_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course)コースはget startedするのに良いです。 +Scala 3 の最新情報を検討している方や、既存の Scala 2 アプリケーションを Scala 3 に移行することを検討している開発者であれば Lunatech の [_"Moving from Scala 2 to Scala 3"_](https://github.com/lunatech-labs/lunatech-scala-2-to-scala3-course)コースは get started するのに良い。 -このコースでは、単一モジュールのAkka TypedSudokuソルバーを約10ステップのシリーズで移行する方法について説明します。以下のScala 3機能の実用化について説明します。: +このコースでは、単一モジュールの Akka TypedSudoku ソルバーを約10ステップのシリーズで移行する方法について説明する。以下の Scala 3 機能の実用化について説明している: - 新しい制御構造のシンタックス - インデントベースのシンタックス diff --git a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md index d4bee0b9ae..f8acac3e8f 100644 --- a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md +++ b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md @@ -8,7 +8,7 @@ next-page: incompat-other-changes language: ja --- -[コンテキスト抽象化]({% link _scala3-reference/contextual.md %})の再設計にはいくつかの非互換性をもたらします。 +[コンテキスト抽象化]({% link _scala3-reference/contextual.md %})の再設計にはいくつかの非互換性をもたらす。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibiltiy| |--- |--- |--- |--- |--- | @@ -19,16 +19,16 @@ language: ja ## 暗黙的定義の型 -暗黙的定義の型 (`val` や`def`) はScala 3では明示的に与える必要があります。 -これらを推論することはできなくなりました。 +暗黙的定義の型 (`val` や`def`) は Scala 3 では明示的に与える必要がある。 +これらを推論することはできなくなった。 -[ohze/scala-rewrites](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes) のリポジトリのScalafixルールで`ExplicitImplicitTypes`と名付けられているものでは、自動的に見逃してる型のアノテーションを付けてくれます。 +[ohze/scala-rewrites](https://github.com/ohze/scala-rewrites#fixexplicittypesexplicitimplicittypes) のリポジトリの Scalafix ルールで `ExplicitImplicitTypes` と名付けられているものは、自動的に見逃してる型のアノテーションを付ける。 ## Implicit Views -Scala 3では、`implicit val ev: A => B`のような形のimplicit関数値からの暗黙的型変換をサポートしなくなりました。 +Scala 3 では、`implicit val ev: A => B` のような形の implicit 関数値からの暗黙的型変換をサポートしなくなった。 -以下のコードは現在無効になります。: +以下のコードは現在無効になる: ```scala trait Pretty { @@ -39,13 +39,13 @@ def pretty[A](a: A)(implicit ev: A => Pretty): String = a.print // Error: value print is not a member of A ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)これらのケースについてWARNINGを出してくれまが、直すことはできません。 +[Scala 3 移行コンパイル](tooling-migration-mode.html)で、これらのケースについてWARNINGを出すが、直すことはできない。 -この非互換性により、実行時の非互換性を引き起こし、プログラムが破損する可能性があることに注意してください。 -実際、コンパイラはより広いスコープで別の暗黙的変換を見つけることができます。 -これにより、実行時の望んでいない動作が発生します。 +この非互換性により、実行時の非互換性を引き起こし、プログラムが破損する可能性があることに注意すべきだ。 +実際、コンパイラはより広いスコープで別の暗黙的変換を見つけることができる。 +これにより、実行時に望んでいない動作が発生する。 -この例は、次の場合を示しています。: +例として、次の場合を示す: ```scala trait Pretty { @@ -58,11 +58,12 @@ def pretty[A](a: A)(implicit ev: A => Pretty): String = a.print // always print "any" ``` -解決される変換は、コンパイラのモードによって異なります。: - - `-source:3.0-migration`: `ev`変換を行います。 - - `-source:3.0`: `ev`変換の実行はできませんが、`anyPretty`は実行できます。ただこれは望ましくありません。 +解決される変換は、コンパイラのモードによって異なる: -簡単な修正の一つとしては、正しい変換を明示的に提供することです。: + - `-source:3.0-migration`: `ev`変換を行う。 + - `-source:3.0`: `ev`変換は実行できないが、`anyPretty`は実行可能だ。ただし、これは望ましくない。 + +簡単な修正の一つとしては、正しい変換を明示的に提供することだ: {% highlight diff %} def pretty[A](a: A)(implicit ev: A => Pretty): String = @@ -72,14 +73,14 @@ def pretty[A](a: A)(implicit ev: A => Pretty): String = ## View Bounds -View Boundsは長い間非推奨担っていましたがScala 2.13では未だサポートされています。 -Scala 3ではコンパイルできないです。 +View Bounds は長い間非推奨になっていたが Scala 2.13 では未だサポートされている。 +Scala 3ではコンパイルできない。 ```scala def foo[A <% Long](a: A): Long = a ``` -この例では下記のエラーを取得します。: +例では下記のエラーを得る: {% highlight text %} -- Error: src/main/scala/view-bound.scala:2:12 @@ -88,11 +89,11 @@ def foo[A <% Long](a: A): Long = a | view bounds `<%' are deprecated, use a context bound `:' instead {% endhighlight %} -このメッセージはcontext boundをview boundsの代わりに使うよう提案していますが、メソッドのシグネチャが変更してしまうでしょう。 -おそらくバイナリ互換性を維持するほうがより簡単で安全でしょう。 -そのため、暗黙的変換を宣言して明示的に呼び出す必要があります。 +このメッセージは context bound を view bounds の代わりに使うよう提案しているが、そうするとメソッドのシグネチャが変更してしまうだろう。 +おそらくバイナリ互換性を維持するほうがより簡単で安全だろう。 +そのため、暗黙的変換を宣言して明示的に呼び出す必要がある。 -上記の[Implicit Views](#implicit-views)で説明した通り、実行時の非互換性により落ちる可能性があることに気をつけましょう。 +上記の[Implicit Views](#implicit-views)で説明した通り、実行時の非互換性によりプログラムが落ちる可能性があることに気をつけよう。 {% highlight diff %} -def foo[A <% Long](a: A): Long = a @@ -101,10 +102,10 @@ def foo[A <% Long](a: A): Long = a ## `A`と`=> A`でのあいまいな変換 -Scala 2.13では`A`での暗黙的変換が`=> A`での暗黙的変換より優先されてます。 -Scala3ではそうではなく、あいまい変換に繋がります。 +Scala 2.13 では `A` での暗黙的変換が `=> A` での暗黙的変換より優先される。 +Scala3では優先されず、あいまい変換へ繋がる。 -以下に例示します。: +以下に例示する: ```scala implicit def boolFoo(bool: Boolean): Foo = ??? @@ -113,7 +114,7 @@ implicit def lazyBoolFoo(lazyBool: => Boolean): Foo = ??? true.foo() ``` -Scala 2.13のコンパイラは`boolFoo`変換を選択しますがScala 3コンパイラはコンパイル失敗します。 +Scala 2.13 のコンパイラは `boolFoo` 変換を選択するが Scala 3 コンパイラはコンパイル失敗する。 {% highlight text %} -- Error: src/main/scala/ambiguous-conversion.scala:4:19 @@ -125,7 +126,7 @@ Scala 2.13のコンパイラは`boolFoo`変換を選択しますがScala 3コン |both method boolFoo in object Foo and method lazyBoolFoo in object Foo provide an extension method `foo` on (true : Boolean) {% endhighlight %} -一時的な解決策としては、明示的に変換を書き換えることです。 +一時的な解決策としては、明示的に変換を書き換えることだ。 {% highlight diff %} implicit def boolFoo(bool: Boolean): Foo = ??? diff --git a/_ja/overviews/scala3-migration/incompat-dropped-features.md b/_ja/overviews/scala3-migration/incompat-dropped-features.md index e371c997ec..d0666b3a89 100644 --- a/_ja/overviews/scala3-migration/incompat-dropped-features.md +++ b/_ja/overviews/scala3-migration/incompat-dropped-features.md @@ -8,25 +8,25 @@ next-page: incompat-contextual-abstractions language: ja --- -一部の機能は言語の簡略化のため削除しました。 -殆どの変更は、[Scala 3 migration compilation](tooling-migration-mode.html)中に自動的に処理できることに注意してください。 +一部の機能は言語の簡略化のため削除した。 +殆どの変更は、[Scala 3 移行コンパイル](tooling-migration-mode.html)中に自動的に処理できることに注意してください。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | |[シンボリックリテラル](#シンボリックリテラル)|Deprecation|✅|| -|[`do`-`while` 構造](#do-while-構造)||✅|| +|[`do`-`while` 機能](#do-while-機能)||✅|| |[自動適用](#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| -|[Eta展開の値](#eta展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[イータ展開の値](#イータ展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| |[`any2stringadd` 変換](#any2stringadd-変換)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| |[先行初期化](#先行初期化)|Deprecation||| |[存在型](#存在型)|Feature warning||| ## シンボリックリテラル -シンボリックリテラル構文はScala 2.13では非推奨とされていましたがScala 3で廃止されました。 -しかし、`scala.Symbol` クラスは引き続き存在するため、各文字列リテラルを`Symbol`のアプリケーションで安全に置き換えすることができます。 +シンボリックリテラル構文は Scala 2.13 では非推奨とされていたが Scala 3 で廃止された。 +しかし、`scala.Symbol` クラスは引き続き存在するため、各文字列リテラルを `Symbol` のアプリケーションで安全に置き換えすることができる。 -このコードはScala 3ではコンパイルできません。: +このコードは Scala 3 ではコンパイルできない: ```scala val values: Map[Symbol, Int] = Map('abc -> 1) @@ -34,7 +34,7 @@ val values: Map[Symbol, Int] = Map('abc -> 1) val abc = values('abc) // Migration Warning: symbol literal 'abc is no longer supported ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードは以下のように書き換えられます。: +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} val values: Map[Symbol, Int] = Map(Symbol("abc") -> 1) @@ -43,17 +43,17 @@ val values: Map[Symbol, Int] = Map(Symbol("abc") -> 1) +val abc = values(Symbol("abc")) {% endhighlight %} -`Symbol`クラスは変換期では非常に便利ではありますが、`scala-library`のfuture バージョンでは非推奨になりやがて廃止されることに注意してください。 -2番目のステップとして、`Symbol`を使用するたびに、プレーンな文字列リテラル`"abc"` または、カスタム専用クラスに置き換えすることをおすすめします。 +`Symbol` クラスは変換期では非常に便利だが、`scala-library` の future バージョンでは非推奨になり、やがて廃止されることに注意してください。 +2番目のステップとして、`Symbol` を使用するたびに、プレーンな文字列リテラル `"abc"` または、カスタム専用クラスに置き換えすることを勧める。 -## `do`-`while` 構造 +## `do`-`while` 機能 -`do` の予約後は[新しい制御構文]({% link _scala3-reference/other-new-features/control-syntax.md %})で従来と異なる意味を持つようになりました。 +`do` の予約語は[新しい制御構文]({% link _scala3-reference/other-new-features/control-syntax.md %})で従来と異なる意味を持つ。 -この混乱を防ぐため、伝統的な`do while ()`構造は廃止します。 -それと等価である`while ({ ; }) ()`を使うことをおすすめします。そして、それはクロスコンパイルできます。またScala 3のシンタックスでは、`while { ; } do ()`のようになります。 +この混乱を防ぐため、伝統的な `do while ()` 機能は廃止した。 +それと等価である `while ({ ; }) ()` を使うことを勧める。そして、このフォームはクロスコンパイルできる。また Scala 3 の構文では、`while { ; } do ()` のようになる。 -Scala 3ではこのコードはコンパイルできません。 +Scala 3 ではこのコードはコンパイルできない ```scala do { // Migration Warning: `do while ` is no longer supported @@ -61,7 +61,7 @@ do { // Migration Warning: `do while ` is no longer supported } while (f(i) == 0) ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。 +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: ```scala while ({ { @@ -71,10 +71,10 @@ while ({ { ## 自動適用 -自動適用は`def toInt(): Int`のような空の親メソッドを呼ぶときに呼び出すシンタックスです。 -Scala 2.13で非推奨になり、Scala 3で削除されました。 +自動適用は `def toInt(): Int` のような空の親メソッドを呼ぶときに呼び出す構文だ。 +Scala 2.13 で非推奨になり、Scala 3 で削除された。 -Scala 3ではこのコードは無効です。: +Scala 3ではこのコードは無効だ: ```scala object Hello { @@ -84,7 +84,7 @@ object Hello { println(Hello.message) // Migration Warning: method message must be called with () argument ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。: +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} object Hello { @@ -95,21 +95,21 @@ object Hello { +println(Hello.message()) {% endhighlight %} -自動適用は、Scala 3ドキュメンテーションの[このページ](/scala3/reference/dropped-features/auto-apply.html)でも詳細がカバーされています +自動適用は、Scala 3 ドキュメンテーションの[このページ](/scala3/reference/dropped-features/auto-apply.html)でも詳細がカバーされている。 -## Eta展開の値 +## イータ展開の値 -Scala 3では[自動的なEta展開](/scala3/reference/changed-features/eta-expansion-spec.html)を導入しており、これにより、シンタックス`m _`を評価するメソッドが非推奨になります。 -さらにScala 3では、値をnull関数に拡張することはできなくなりました。 +Scala 3 では[自動的なイータ展開](/scala3/reference/changed-features/eta-expansion-spec.html)を導入しており、これにより、構文 `m _` を評価するメソッドが非推奨になる。 +更に Scala 3 では、値を null 関数に拡張することはできなくなった。 -したがって、このコードはScala 3では無効です。: +したがって、このコードはScala 3では無効だ: ```scala val x = 1 val f: () => Int = x _ // Migration Warning: The syntax ` _` is no longer supported; ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のように書き換えます。: +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} val x = 1 @@ -119,29 +119,29 @@ val x = 1 ## `any2stringadd` 変換 -implicit `Predef.any2stringadd` 変換はScala 2.13で非推奨となり、Scala 3では廃止されます。 +implicit `Predef.any2stringadd` 変換は Scala 2.13 で非推奨となり、Scala 3では廃止された。 -これらのコードはコンパイルできません。 +これらのコードはコンパイルできない。 ```scala val str = new AnyRef + "foo" // Error: value + is not a member of Object ``` -この`String`への変換は必ず明示的に`String.valueOf`などで適用する必要があります。 +この `String` への変換は必ず明示的に `String.valueOf` などに適用する必要がある。 {% highlight diff %} -val str = new AnyRef + "foo" +val str = String.valueOf(new AnyRef) + "foo" {% endhighlight %} -この書き換えは[`scala/scala-rewrites`](https://index.scala-lang.org/scala/scala-rewrites/scala-rewrites/0.1.2?target=_2.13)にあるScalafixルールの`fix.scala213.Any2StringAdd`により適用できます。 +この書き換えは[`scala/scala-rewrites`](https://index.scala-lang.org/scala/scala-rewrites/scala-rewrites/0.1.2?target=_2.13)にある Scalafix ルールの `fix.scala213.Any2StringAdd` により適用できる。 ## 先行初期化 -先行初期化はScala 2.13では非推奨となり、Scala 3では廃止されます。 -まれに使われいましたが、その殆どがScala3で現在サポートされている[Trait parameters](/scala3/reference/other-new-features/trait-parameters.html)の不足を補うためのものです。 +先行初期化は Scala 2.13 では非推奨となり、Scala 3 では廃止された。 +稀に使われていたが、その殆どが Scala 3 で現在サポートされている[Trait parameters](/scala3/reference/other-new-features/trait-parameters.html)の不足を補うためのものだ。 -そういうわけで、以下のコードはコンパイルできません。 +なので、以下のコードはコンパイルできない。 ```scala trait Bar { @@ -154,7 +154,7 @@ object Foo extends { } with Bar ``` -Scala 3コンパイラでは2つのエラーを出します。: +Scala 3 コンパイラでは2つのエラーを出す: {% highlight text %} -- Error: src/main/scala/early-initializer.scala:6:19 @@ -170,7 +170,7 @@ Scala 3コンパイラでは2つのエラーを出します。: | Early definitions are not supported; use trait parameters instead {% endhighlight %} -トレイトパラメータを以下のように使うことが提案されています: +トレイトパラメータを以下のように使うことが提案される: ```scala trait Bar(name: String) { @@ -180,8 +180,8 @@ trait Bar(name: String) { object Foo extends Bar("Foo") ``` -Scala 2.13でトレイトパラメータは使用できないので、これはクロスコンパイルできません。 -もしクロスコンパイル方法が必要であれば、初期化された`val`と`var`をコンストラクタパラメータとして運ぶような中間クラスを使用します。 +Scala 2.13 でトレイトパラメータは使用できないので、これはクロスコンパイルできない。 +もしクロスコンパイル方法が必要であれば、初期化された `val` と `var` をコンストラクタパラメータとして運ぶような中間クラスを使用する。 ```scala abstract class BarEarlyInit(val name: String) extends Bar @@ -189,7 +189,7 @@ abstract class BarEarlyInit(val name: String) extends Bar object Foo extends BarEarlyInit("Foo") ``` -このクラスのケースでは、次のように固定値の2次コンストラクタを使用することもできます: +このクラスのケースでは、次のように固定値の2次コンストラクタを使用することもできる: ```scala class Fizz private (val name: String) extends Bar { @@ -199,15 +199,15 @@ class Fizz private (val name: String) extends Bar { ## 存在型 -存在型は[廃止された機能](/scala3/reference/dropped-features/existential-types.html)で、以下のコードは無効です。 +存在型は[廃止された機能](/scala3/reference/dropped-features/existential-types.html)で、以下のコードは無効だ。 ```scala def foo: List[Class[T]] forSome { type T } // Error: Existential types are no longer supported ``` -> 存在型はScala 2.13の実験的な機能で、`import scala.language.existentials`するか、コンパイラフラグとして`-language:existentials`を設定することにより、明示的に有効にする必要があります。 +> 存在型は Scala 2.13 の実験的な機能で、`import scala.language.existentials` するか、コンパイラフラグとして `-language:existentials` を設定することにより、明示的に有効にする必要がある。 -提案された解決策として、依存型を運ぶ方を導入することです。: +解決策の提案として、依存型を運ぶ型を導入する: ```scala trait Bar { @@ -218,5 +218,5 @@ trait Bar { def foo: Bar ``` -常に可能であるとは限りませんが、ワイルドカード引数、 `_` または `?`を使用するほうが簡単な場合が多いのです。 -例えば、`List[T] forSome { type T }`を`List[?]`に置き換えることができます。 +常に可能であるとは限りらないが、ワイルドカード引数、`_` または `?` を使用するほうが簡単な場合が多い。 +例えば、`List[T] forSome { type T }` を `List[?]` に置き換えることができる。 diff --git a/_ja/overviews/scala3-migration/incompat-other-changes.md b/_ja/overviews/scala3-migration/incompat-other-changes.md index 87293a6fb2..f41e51e875 100644 --- a/_ja/overviews/scala3-migration/incompat-other-changes.md +++ b/_ja/overviews/scala3-migration/incompat-other-changes.md @@ -8,7 +8,7 @@ next-page: incompat-type-checker language: ja --- -その他の機能は言語をより簡単、安全、または一貫性のあるものにするために簡略化または制限されています。 +その他の機能は言語をより簡単、安全、または一貫性のあるものにするために簡略化または制限した。 |Incompatibility|Scala 3 Migration Rewrite| |--- |--- | @@ -23,8 +23,8 @@ language: ja ## 継承シャドウイング -親クラスまたはトレイトからの継承されたメンバーは外部スコープで定義された識別子をシャドウイングすることができます。 -このパターンのことを継承シャドウイングと呼びます。 +親クラスまたはトレイトからの継承されたメンバーは外部スコープで定義された識別子をシャドウイングすることができる。 +このパターンのことを継承シャドウイングと呼ぶ。 ```scala object B { @@ -35,14 +35,14 @@ object B { } ``` -例として、以下のコードを与えてみます。Cの中にある単項式`x`は`x`のメンバー定義を外部クラス`B`から参照することができ、また親クラス`A`の`x`のメンバー定義しても参照できます。 -どちらの参照かは`A`の定義に進むまでわかりません。 +例として、以下のコードを与える。C の中にある単項式 `x` は `x` のメンバー定義を外部クラス `B` から参照することができ、また親クラス `A` の `x` のメンバー定義からも参照できる。 +どちらの参照かは `A` の定義に進むまでわからない。 -これはエラーが発生しやすいことで知られています。 +これはエラーが発生しやすいことで知られている。 -そのため、Scala3では、親クラス`A`に実際にメンバー`x`がある場合、コンパイラは曖昧性解消を必要とします。 +そのため、Scala 3 では、親クラス `A` に実際にメンバー `x` がある場合、コンパイラは曖昧性解消を必要とする。 -これにより、次のコードがコンパイルされなくなります。 +これにより、次のコードがコンパイルされなくなった。 ```scala class A { @@ -66,13 +66,13 @@ object B { | and inherited subsequently in class C {% endhighlight %} -[Scala 3移行コンパイル](tooling-migration-mode.html) は`println(x)` を`println(this.x)`に置き換えることで自動的に曖昧性解消を行います。 +[Scala 3移行コンパイル](tooling-migration-mode.html) は`println(x)` を `println(this.x)` に置き換えることで自動的に曖昧性解消を行う。 ## プライベートクラスのNon privateなコンストラクタ -Scala 3ではプライベートクラスのコンストラクタはプライベートである必要があります。 +Scala 3 ではプライベートクラスのコンストラクタはプライベートである必要がある。 -例としては、次のようになります。: +例としては、次のようになる: ```scala package foo @@ -80,7 +80,8 @@ package foo private class Bar private[foo] () {} ``` -エラーメッセージはこのようになります。: +エラーメッセージは以下になる: + ``` -- Error: /home/piquerez/scalacenter/scala-3-migration-guide/incompat/access-modifier/src/main/scala-2.13/access-modifier.scala:4:19 4 | private class Bar private[foo] () @@ -89,15 +90,15 @@ private class Bar private[foo] () {} | in its type signature (): foo.Foo.Bar ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では自動的には書き換えが行われずWARNINGが与えられます。 +[Scala 3移行コンパイル](tooling-migration-mode.html) では自動的には書き換えが行われずWARNINGが与えられる。 -クラスはプライベートであるため、この解決策としてはコンストラクタをプライベートにすることです。 +クラスはプライベートであるため、解決策はコンストラクタをプライベートにすることだ。 ## 抽象オーバーライド -Scala 3では、抽象defでdefをオーバーライドすると、サブクラスはdef抽象を考慮しますが、Scala 2では具象とみなされていました。 +Scala 3 では、抽象 def で def をオーバーライドすると、サブクラスは def 抽象を考慮するが、Scala 2 では具象とみなされていた。 -次のコードでは、`C`の`bar`メソッドはScala 2.13コンパイラでは具象であるとみなされていますが、Scala 3コンパイラでは抽象的であるとみなされてるため、次のエラーが発生します。 +次のコードでは、`C` の `bar` メソッドは Scala 2.13 コンパイラでは具象であるとみなされているが、Scala 3 コンパイラでは抽象的であるとみなされるため、次のエラーが発生する。 ```scala trait A { @@ -111,17 +112,17 @@ trait B extends A { class C extends B // Error: def bar(x: Int): Int は定義されていませんので、class C は抽象である必要があります ``` -この振る舞いは[Dotty issue #4770](https://github.com/lampepfl/dotty/issues/4770)で決定しました。 +この振る舞いは[Dotty issue #4770](https://github.com/lampepfl/dotty/issues/4770)にて決定した。 -簡単な修正は、抽象defを削除することです。 -これは、実際にはScala 2では効果がなかったためです。 +簡単な修正としては、抽象 def を削除することだ。 +これは、実際には Scala 2 では効果がなかったためだ。 ## ケースクラスコンパニオン -ケースクラスのコンパニオンオブジェクトは`Function{0-23}`の特性を拡張しなくなりました。 -特に、これらのメソッドは継承しなくなりました。: `tupled`, `curried`, `andThen`, `compose`... +ケースクラスのコンパニオンオブジェクトは `Function{0-23}` の特性を拡張しなくした。 +特に、これらのメソッドは継承しない: `tupled`, `curried`, `andThen`, `compose`... -例として、このコードは無効になります。: +例として、このコードは無効になる: ```scala case class Foo(x: Int, b: Boolean) @@ -130,7 +131,7 @@ Foo.curried(1)(true) Foo.tupled((2, false)) ``` -クロスコンパイルによるソリューションはメソッド`Foo.apply`を明示的にEta展開することです。 +クロスコンパイルによるソリューションはメソッド `Foo.apply` を明示的にイータ展開することだ。 {% highlight diff %} -Foo.curried(1)(true) @@ -140,7 +141,7 @@ Foo.tupled((2, false)) +(Foo.apply _).tupled((2, false)) {% endhighlight %} -パフォーマンス上の理由から、中間間数値を導入することもできます。 +パフォーマンス上の理由から、中間間数値を導入することもできる。 ```scala val fooCtr: (Int, Boolean) => Foo = (x, b) => Foo(x, b) @@ -150,20 +151,20 @@ fooCtr.tupled((2, false)) ``` ## 明示的な`unapply`の呼び出し -Scalaにおいて、ケースクラスには自動生成された抽象メソッドがあり、コンパニオンオブジェクトで`unapply`と呼ばれます。 -Scala 2.13とScala 3間でシグネチャが変わりました。 +Scala において、ケースクラスには自動生成された抽象メソッドがあり、コンパニオンオブジェクトで `unapply` と呼ばれている。 +Scala 2.13 と Scala 3 間でシグネチャが変わった。 -新しいシグネチャは、オプションがありません(参照として新しい[Pattern Matching](/scala3/reference/changed-features/pattern-matching.html)) 、これにより、`unapply`が明示的に呼び出されたときに非互換性が発生します。 +新しいシグネチャは、オプションがなく(参照として新しい[Pattern Matching](/scala3/reference/changed-features/pattern-matching.html)) 、これにより、`unapply` が明示的に呼び出されたときに非互換性が発生する。 -この問題は、Scalaバージョン間でシグネチャが同じ状態のユーザが定義したエクストラクタには影響しないことに注意してください。 +この問題は、Scala バージョン間でシグネチャが同じ状態のユーザが定義したエクストラクタには影響しないことに注意すべきだ。 -次のケースクラス定義があるとします。: +次のケースクラス定義があるとする: ```scala case class Location(lat: Double, long: Double) ``` -Scala 2.13コンパイラでは `unapply` メソッドを生成します : +Scala 2.13 コンパイラでは `unapply` メソッドを生成する: ```scala object Location { @@ -171,7 +172,7 @@ object Location { } ``` -一方でScala 3コンパイラでは以下のようにメソッドが生成されます: +一方で Scala 3 コンパイラでは以下のようにメソッドを生成する: ```scala object Location { @@ -179,7 +180,7 @@ object Location { } ``` -その結果、次のコードはコンパイルされなくなります。 +その結果、次のコードはコンパイルされなくなる ```scala def tuple(location: Location): (Int, Int) = { @@ -187,7 +188,7 @@ def tuple(location: Location): (Int, Int) = { } ``` -考えられる解決策は、パターンバインディングを使用することです。: +考えられる解決策は、パターンバインディングを使用することだ: {% highlight diff %} def tuple(location: Location): (Int, Int) = { @@ -199,9 +200,9 @@ def tuple(location: Location): (Int, Int) = { ## 見えないビーンプロパティ -`BeanProperty`アノテーションにより生成されたgetterとsetterメソッドは、主なユースケースがJavaフレームワークと相互運用性があるため、Scala 3では表示されなくなりました。 +`BeanProperty` アノテーションにより生成された getter と setter メソッドは、主なユースケースが Java フレームワークと相互運用性があるため、Scala 3 では表示されない。 -例として下記に示します。: +例として下記に示す: ```scala class Pojo() { @@ -215,7 +216,7 @@ pojo.setFooBar("hello") // [E008] Not Found Error: value setFooBar is not a memb println(pojo.getFooBar()) // [E008] Not Found Error: value getFooBar is not a member of Pojo ``` -解決策は、より慣用的な`pojo.fooBar` getterとsetter呼び出すことです。 +解決策は、より慣用的な `pojo.fooBar` getter と setter 呼び出すことだ。 {% highlight diff %} val pojo = new Pojo() @@ -229,11 +230,11 @@ val pojo = new Pojo() ## 型パラメータとしての`=> T` -この`=> T`ようなフォームでは型パラメータへの引数として使用できなくなりました。 +この `=> T` ようなフォームでは型パラメータへの引数として使用できなくなった。 -この決定はScala3ソースコードの[コメント](https://github.com/lampepfl/dotty/blob/0f1a23e008148f76fd0a1c2991b991e1dad600e8/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala#L144-L152)で説明しています。 +この決定は Scala 3 ソースコードの[コメント](https://github.com/lampepfl/dotty/blob/0f1a23e008148f76fd0a1c2991b991e1dad600e8/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala#L144-L152)で説明している。 -例として、`Int => (=> Int) => Int`の関数は、型パラメータ`T2`に`=> Int` を割り当てるため、カリー化なしのメソッドにわたすことはできません。 +例として、`Int => (=> Int) => Int` の関数は、型パラメータ `T2` に `=> Int` を割り当てるため、カリー化なしのメソッドにわたすことはできない。 ``` -- [E134] Type Mismatch Error: src/main/scala/by-name-param-type-infer.scala:3:41 @@ -248,15 +249,16 @@ val pojo = new Pojo() |match arguments ((Test.f : Int => (=> Int) => Int)) ``` -この解決策は状況に依存します。例として、いずれかを行うことができます。: - - 適切なシグネチャを使用して、独自の`カリー化してない`メソッドを定義します。 +この解決策は状況に依存する。例では、いずれかを行うことができる: + + - 適切なシグネチャを使用して、独自の`カリー化してない`メソッドを定義する。 - `カリー化していない`実装をローカルでインライン化する。 ## 型引数のワイルドカード -Scala 3ではワイルドカードの引数より種類の多い抽象型メンバーへの適用は減らすことができません。 +Scala 3 ではワイルドカードの引数より種類の多い抽象型メンバーへの適用は減らすことができない。 -この例では、コンパイルされません。 +この例では、コンパイルされない。 ```scala trait Example { @@ -266,20 +268,20 @@ trait Example { } ``` -型パラメータを使うことで修正できます。: +型パラメータを使うことで修正できる。: {% highlight diff %} -def f(foo: Foo[_]): Unit +def f[A](foo: Foo[A]): Unit {% endhighlight %} -しかし、簡単な解決策では`Foo`が自身を型パラメータとして使われるときはうまくいきません。 +しかし、簡単な解決策では `Foo` が自身を型パラメータとして使われるときはうまくいかない。 ```scala def g(foos: Seq[Foo[_]]): Unit ``` -このようなケースでは、`Foo`の周りをラップするクラスを使います。: +このようなケースでは、`Foo` の周りをラップするクラスを使う: {% highlight diff %} +class FooWrapper[A](foo: Foo[A]) diff --git a/_ja/overviews/scala3-migration/incompat-syntactic.md b/_ja/overviews/scala3-migration/incompat-syntactic.md index 7e745d8eac..0665f300ed 100644 --- a/_ja/overviews/scala3-migration/incompat-syntactic.md +++ b/_ja/overviews/scala3-migration/incompat-syntactic.md @@ -1,24 +1,24 @@ --- -title: シンタックスの変更 +title: 構文の変更 type: section -description: この章ではシンタックス変更に伴い生じたすべての非互換性について詳細化します +description: この章では構文変更に伴い生じる全ての非互換性について詳細化します num: 15 previous-page: incompatibility-table next-page: incompat-dropped-features language: ja --- -Scala 3では括弧がオプションナルなシンタックスと新しい制御構造のシンタックスが導入されています。 -これには、既存のシンタックスに最小限の制限があります。 +Scala 3では括弧がオプションナルな構文と新しい制御構造の構文が導入された。 +この導入により、既存の構文にごく僅かな制限がある。 -他のシンタックスの変更は、意外性を減らし、一貫性を高めることを目的としています。 +他の構文の変更は、意外性を減らし、一貫性を高めることを目的としている。 -殆どの変更は、[Scala 3移行コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意してください。 +殆どの変更は、[Scala 3移行コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意すべきだ。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | |[制限された予約語](#制限された予約語)||✅|| -|[手続き型シンタックス](#手続き型シンタックス)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[手続き型構文](#手続き型構文)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| |[Lambdaパラメータを囲む括弧](#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| |[引数を渡すための括弧のインデント](#引数を渡すための括弧のインデント)||✅|| |[間違ったインデント](#間違ったインデント)|||| @@ -27,11 +27,12 @@ Scala 3では括弧がオプションナルなシンタックスと新しい制 ## 制限された予約語 -Scala 3予約語(キーワード)のリストは[ここ](https://dotty.epfl.ch/docs/internals/syntax.html#keywords)で見ることができます。 -一般的な予約語を識別子として使用することはできませんが、半予約語は制限されていません。 +Scala 3 予約語(キーワード)のリストは[ここ](https://dotty.epfl.ch/docs/internals/syntax.html#keywords)で見ることができる。 +一般的な予約語を識別子として使用することはできないが、半予約語は制限されていない。 + +Scala 2.13 から Scala 3 への移行に関しては、新しい一般的な予約語の一部分が問題になる。 +問題になる予約語の一部を下記に列挙する: -Scala 2.13からScala 3への移行に関しては、新しい一般的な予約語の一部分のみが問題になります。 -それらは下記に列挙されています。: - `enum` - `export` - `given` @@ -39,7 +40,7 @@ Scala 2.13からScala 3への移行に関しては、新しい一般的な予約 - `=>>` - `?=>` -次のコードはScala 2.13でコンパイルできますが、Scala 3ではコンパイルできません。 +次のコードは Scala 2.13 でコンパイルできますが、Scala 3 ではコンパイルできない。 ```scala object given { // Error: given is now a keyword @@ -49,7 +50,7 @@ object given { // Error: given is now a keyword } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のようにコードが書き直されてます。: +[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のようにコードが書き直される: {% highlight diff %} -object given { @@ -62,10 +63,10 @@ object given { // Error: given is now a keyword } {% endhighlight %} -## 手続き型シンタックス +## 手続き型構文 -手続き型シンタックスはしばらくの間非推奨になり、Scala 3では削除されました。 -次のコードは現在使用できません。: +手続き型構文はしばらくの間非推奨になり、Scala 3 では削除された。 +次のコードは現在使用できない: ```scala object Bar { @@ -75,7 +76,7 @@ object Bar { } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わります。 +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる。 {% highlight diff %} object Bar { @@ -88,14 +89,14 @@ object Bar { ## Lambdaパラメータを囲む括弧 -パラメータの型が続く場合、Lambdaのパラメータを括弧で囲む必要があります。 -次のコードは無効です。 +パラメータの型が続く場合、Lambda のパラメータを括弧で囲む必要がある。 +次のコードは無効だ。 ```scala val f = { x: Int => x * x } // Error: parentheses are required around the parameter of a lambda ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わります: +[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる: {% highlight diff %} -val f = { x: Int => x * x } @@ -104,10 +105,10 @@ val f = { x: Int => x * x } // Error: parentheses are required around the parame ## 引数を渡すための括弧のインデント -Scala 2では改行を中括弧で囲むことで、新しい行の後に引数を渡すことができます。 -このスタイルのコーディングは有効ですが、[Scala style guide](https://docs.scala-lang.org/style) では推奨されておらず、Scala 3ではサポートされなくなりました。 +Scala 2 では改行を中括弧で囲むことで、新しい行の後に引数を渡すことができる。 +このスタイルのコーディングは有効だが、[Scala style guide](https://docs.scala-lang.org/style) では推奨されておらず、Scala 3 ではサポートされなくなった。 -このシンタックスは現在無効です。: +この構文は現在無効だ: ```scala test("my test") { // Error: This opening brace will start a new statement in Scala 3. @@ -115,7 +116,7 @@ test("my test") } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではブロックの最初の行をインデントします。 +[Scala 3移行コンパイル](tooling-migration-mode.html)ではブロックの最初の行をインデントする。 {% highlight diff %} test("my test") @@ -125,7 +126,7 @@ test("my test") } {% endhighlight %} -この移行ルールは、改行の後に型を絞り込むなど、他のパターンに適用されます。 +この移行ルールは、改行の後に型を絞り込むなど、他のパターンに適用される。 {% highlight diff %} type Bar = Foo @@ -135,7 +136,7 @@ type Bar = Foo } {% endhighlight %} -望ましい解決策は次のように書くことです: +望ましい解決策は次のように書くことだ: {% highlight diff %} -test("my test") @@ -147,8 +148,8 @@ type Bar = Foo ## 間違ったインデント -Scala 3コンパイラは現状正しいインデントを求めます。 -次のコードは、Scala 2.13ではコンパイルできたものですが、インデントを理由にコンパイルできないようになっています。 +Scala 3 コンパイラは現状正しいインデントを求める。 +次のコードは、Scala 2.13 ではコンパイルできたが、Scala 3ではインデントを理由にコンパイルできないようになっている。 ```scala def bar: (Int, Int) = { @@ -158,7 +159,7 @@ def bar: (Int, Int) = { } // [E007] Type Mismatch Error: Found Unit, Required (Int, Int) ``` -このインデントは必ず修正しなければなりません。 +このインデントは必ず修正しなければならない。 {% highlight diff %} def bar: (Int, Int) = { @@ -169,24 +170,24 @@ def bar: (Int, Int) = { } {% endhighlight %} -これらのエラーは[scalafmt](https://scalameta.org/scalafmt/) や [IntelliJ Scala formatter](https://www.jetbrains.com/help/idea/reformat-and-rearrange-code.html)などのScalaフォーマットツールを使えば防ぐことができます。 -これらのフォーマットツールはプロジェクトのコードスタイル全体を変更する可能性があるので注意してください。 +これらのエラーは[scalafmt](https://scalameta.org/scalafmt/) や [IntelliJ Scala formatter](https://www.jetbrains.com/help/idea/reformat-and-rearrange-code.html)などの Scala フォーマットツールを使えば防ぐことができる。 +これらのフォーマットツールはプロジェクトのコードスタイル全体を変更する可能性があるので注意すべきです。 ## 型パラメータとしての`_` -Scala 2仕様で特段言及されたことがない場合でも、型パラメータとして`_`はScala 2.13では許容されていました。 -これは[fastparse](https://index.scala-lang.org/lihaoyi/fastparse)のAPIで、コンテキストバインドと組み合わせて使用され、implicit パラメータを宣言します。 +Scala 2 仕様で特段言及されたことがない場合でも、型パラメータとして `_` は Scala 2.13 では許容されていた。 +これは[fastparse](https://index.scala-lang.org/lihaoyi/fastparse)の API で、コンテキストバインドと組み合わせて使用され、implicit パラメータを宣言する。 ```scala def foo[_: Foo]: Unit = ??? ``` -ここに、ワイルドカード記号としてではなく型パラメータとしての`_`と`Foo[_]`のimplictパラメータをとる`foo`メソッドがあります。 +ここに、ワイルドカード記号としてではなく型パラメータとしての `_` と `Foo[_]` の implict パラメータをとる `foo` メソッドがある。 -Martin Odersky このパターンを"scalacコンパイラのバグの巧妙な悪用"([ソース](https://www.reddit.com/r/scala/comments/fczcvo/mysterious_context_bounds_in_fastparse_2/fjecokn/))として説明していました。 +Martin Odersky このパターンを"scalac コンパイラのバグの巧妙な悪用"([ソース](https://www.reddit.com/r/scala/comments/fczcvo/mysterious_context_bounds_in_fastparse_2/fjecokn/))として説明していた。 -Scala 3コンパイラはこのパターンを許容しません。: +Scala 3 コンパイラはこのパターンを許容しない: {% highlight text %} -- [E040] Syntax Error: src/main/scala/anonymous-type-param.scala:4:10 @@ -195,8 +196,8 @@ Scala 3コンパイラはこのパターンを許容しません。: | an identifier expected, but '_' found {% endhighlight %} -解決方法としては、例えば、`T`のように有効な固有名詞を型パラメータとして与えることです。 -このやり方ではバイナリ互換性は崩れないでしょう。 +解決方法は、例えば、`T` のように有効な固有名詞を型パラメータとして与えることだ。 +このやり方ではバイナリ互換性は崩れないだろう。 {% highlight diff %} -def foo[_: Foo]: Unit = ??? @@ -205,9 +206,9 @@ Scala 3コンパイラはこのパターンを許容しません。: ## 型パラメータとしての`+`と`-` -Scala 3の型パラメータとしては`+` と `-` は有効ではありません、なぜならこれらは変位指定のアノテーションとしての予約語だからです。 +Scala 3 の型パラメータとしては `+` と `-` は有効ではない。なぜならこれらは変位指定のアノテーションとしての予約語だからだ。 -`def foo[+]` や `def foo[-]` は書くことができません。 +`def foo[+]` や `def foo[-]` は書くことができない。 {% highlight text %} -- Error: src/main/scala/type-param-identifier.scala:2:10 @@ -216,7 +217,7 @@ Scala 3の型パラメータとしては`+` と `-` は有効ではありませ | no `+/-` variance annotation allowed here {% endhighlight %} -解決方法としては、例えば、`T`のように有効な固有名詞を型パラメータとして与えることです。 +解決方法としては、例えば、`T` のように有効な固有名詞を型パラメータとして与えることだ。 -しかしながら、`+` と `-` は一般的に有効な型識別子です。 -`type +`とは書くことができます。 +しかしながら、`+` と `-` は一般的に有効な型識別子だ。 +なので、`type +`とは書くことができる。 diff --git a/_ja/overviews/scala3-migration/incompat-type-checker.md b/_ja/overviews/scala3-migration/incompat-type-checker.md index 539c9ddb94..d306dfc561 100644 --- a/_ja/overviews/scala3-migration/incompat-type-checker.md +++ b/_ja/overviews/scala3-migration/incompat-type-checker.md @@ -1,23 +1,23 @@ --- -title: 型チェッカー +title: 型検査 type: section -description: この章では型チェッカーの不具合修正について詳細化します +description: この章では型検査の不具合修正について詳細化します num: 19 previous-page: incompat-other-changes next-page: incompat-type-inference language: ja --- -Scala 2.13の型チェッカーは一部の特定のケースでは挙動がおかしいです。 -これにより、予期しない場所で予期しない実行時エラーなどが発生する可能性があります。 -Scala 3はより強力な理論的基盤に基づいており、型チェッカーのこれらの不健全なバグは修正されました。 +Scala 2.13 の型検査は一部の特定のケースでは挙動がおかしい。 +これにより、予期しない場所で実行時エラーなどが発生する可能性がある。 +Scala 3 はより強力な理論的基盤に基づいており、型検査のこれらの不健全なバグは修正された。 ## 分散チェックの不具合修正 -Scala 2では、デフォルトのパラメータと内部クラスは分散チェックの対象ではありません。 -Scala 3リポジトリでのこの[テスト](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/tests/neg/variances.scala)で示されているように、健全ではなく、実行時エラーを引き起こす可能性があります。 +Scala 2 では、デフォルトのパラメータと内部クラスは分散チェックの対象ではない。 +Scala 3 リポジトリでのこの[テスト](https://github.com/lampepfl/dotty/blob/10526a7d0aa8910729b6036ee51942e05b71abf6/tests/neg/variances.scala)で示されているように、健全ではなく、実行時エラーを引き起こす可能性がある。 -Scala3コンパイラは以下のコードを許容していません。 +Scala3 コンパイラは以下のコードを許容していない。 ```scala class Foo[-A](x: List[A]) { @@ -40,13 +40,13 @@ class Outer[+A](x: A) { |covariant type A occurs in contravariant position in type A of parameter y {% endhighlight %} -この種類のそれぞれの問題は特定のケアが必要です。 -あなたはケース・バイ・ケースで選択的に解決方法をトライことができます。: -- 型`A`の内部変数を作る -- 型パラメータ`B`の上位、または下位境界を追加する +この種類の各問題は特定のケアが必要だ。 +ケース・バイ・ケースで選択的に解決方法をトライことができる: +- 型 `A` の内部変数を作る +- 型パラメータ `B` の上位、または下位境界を追加する - 新しいオーバーロードメソッドを追加する -例では、2つの解決策を選択できます。: +例では、2つの解決策を選択可能だ: {% highlight diff %} class Foo[-A](x: List[A]) { @@ -61,7 +61,7 @@ class Outer[+A](x: A) { } {% endhighlight %} -また、一時的な解決策ですが、`uncheckedVariance` アノテーションを使用することもできます。: +また、一時的な解決策だが、`uncheckedVariance` アノテーションを使用することもできる: {% highlight diff %} class Outer[+A](x: A) { @@ -72,10 +72,10 @@ class Outer[+A](x: A) { ## パターンマッチングの不具合修正 -Scala3ではいくつかのパターンマッチによるバグを修正しました、 -これはタイプチェックの意味的に間違ったmatch式を防ぎます +Scala 3 ではいくつかのパターンマッチによるバグを修正した。 +これは型検査の意味的に間違ったmatch式を防ぐ -たとえば、`combineReq`のmatch式は、Scala 2.13でコンパイルできますが、Scala3ではコンパイルできません。 +例えば、`combineReq` の match 式は、Scala 2.13 でコンパイルできるが、Scala 3 ではコンパイルできない。 ```scala trait Request @@ -92,7 +92,7 @@ object Request { } ``` -エラーメッセージは次のようになります: +エラーメッセージは次のようになる: {% highlight text %} -- [E007] Type Mismatch Error: src/main/scala/pattern-match.scala:9:59 @@ -102,17 +102,17 @@ object Request { | Required: Fetch[A$1] {% endhighlight %} -これは`x`と`y`が同じタイプのパラメータ`A`を持っているという証拠にはなりません。 +これは `x` と `y` が同じ型のパラメータ `A` を持っているということにはならない。 -Scala 2から、明らかに間違っているコードを見つけるのに便利な改善です。 -この非互換性を解決するには、コンパイラがチェックできる解決策を見つけるようにすることです。 -ただし、必ずしも簡単なわけではなく、時には不可能な場合もあり、その場合、コードは実行時に失敗する可能性があります。 +Scala 2 から、明らかに間違っているコードを見つけるのに便利な改善だ。 +この非互換性を解決するには、コンパイラがチェックできる解決策を見つけるようにすることだ。 +ただし、それは必ずしも簡単なわけではなく、時には不可能な場合もあり、その場合、コードは実行時に失敗する可能性がある。 -この例では、`A`が両方の型引数の共通の親であると宣言することにより、`x`と`y`の制約を緩和すること示します。 -これにより、コンパイラはコードを正常に型チェックします。 +この例では、`A` が両方の型引数の共通の親であると宣言することにより、`x` と `y` の制約を緩和すること示す。 +これにより、コンパイラはコードを正常に型検査する。 ```scala def combineFetch[A](x: Fetch[_ <: A], y: Fetch[_ <: A]): Fetch[A] = Fetch(x.ids ++ y.ids) ``` -一般的であり安全ではない別の解決策としてはキャストすることです。 +一般的であり安全ではない別の解決策としてはキャストすることだ。 diff --git a/_ja/overviews/scala3-migration/incompat-type-inference.md b/_ja/overviews/scala3-migration/incompat-type-inference.md index 922635e256..7708af47e2 100644 --- a/_ja/overviews/scala3-migration/incompat-type-inference.md +++ b/_ja/overviews/scala3-migration/incompat-type-inference.md @@ -8,19 +8,19 @@ next-page: options-intro language: ja --- -型インタフェースに伴うルールの内部的変更による、2つの非互換性についてこのページでは説明します。 +型推論に関するルールの内部的変更による、2つの非互換性についてこのページでは説明する。 -他の非互換性に関しては型インタフェースのアルゴリズムの書き換えにより生じてしまいます。 -新しいアルゴリズムは古いやつよりも良いのですが、一部Scala 2.13で成功していたものが落ちてしまうときがあります。: +他の非互換性に関しては型推論のアルゴリズムの書き換えにより生じる。 +新しいアルゴリズムは古いやつよりも良いのですが、一部 Scala 2.13 で成功していたものが落ちてしまうときがある: -> 明示的にメソッドやパブリックな変数に対して返り値の型を書くことは常に良い習慣であります。 -> 推測される型が異なる場合があるため、ライブラリのパブリックAPIがScalaバージョンにより変更されるのを防ぎます。 +> 明示的にメソッドやパブリックな変数に対して返り値の型を書くことは常に良い習慣だ。 +> 推測される型が異なる場合があるため、ライブラリのパブリック API が Scala バージョンにより変更されるのを防ぐ。 > -> これはScalafixの[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)のルールを使用してScala3の移行前に行うことができます。 +> これは Scalafix の[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)のルールを使用して Scala 3 の移行前に行うことができる。 ## オーバーライドしたメソッドの返り値の型 -Scala 3でオーバーライドメソッドの返却値の型はベースメソッドからの継承により推論されますが、Scala 2.13では、オーバーライドメソッドの左側から推測されます。 +Scala 3 でオーバーライドメソッドの返却値の型はベースメソッドからの継承により推論されるが、Scala 2.13 では、オーバーライドメソッドの左側から推測される。 ```scala class Parent { @@ -32,8 +32,8 @@ class Child extends Parent { } ``` -この例では、Scala 2.13では`Child#foo`メソッドは`RichFoo`を返却しますが、Scala 3では`Foo`を返却します。 -以下に示すように、コンパイラエラーが発生する可能性があります。 +この例では、Scala 2.13 では `Child#foo` メソッドは`RichFoo` を返却するが、Scala 3 では `Foo` を返却する。 +以下のようなコンパイラエラーが発生する可能性がある。 ```scala class Foo @@ -53,9 +53,9 @@ class Child extends Parent { (new Child).foo.show // Scala 3 error: value show is not a member of Foo ``` -In some rare cases involving implicit conversions and runtime casting it could even cause a runtime failure. +暗黙的な変換と実行時のキャストを含む稀なケースにおいては、実行時エラーを引き起こす可能性がある。 -The solution is to make the return type of the override method explicit: +解決策は、オーバーライドメソッドの返却値の型を明示的に示すことだ: {% highlight diff %} class Child extends Parent { @@ -66,10 +66,10 @@ class Child extends Parent { ## リフレクションの型 -Scala 2のリフレクションの呼び出しは削除され、より広範な[プログラマティック構造型](/scala3/reference/changed-features/structural-types.html)に置き換えられています。 +Scala 2 のリフレクションの呼び出しは削除され、より広範な[プログラマティック構造型](/scala3/reference/changed-features/structural-types.html)に置き換えられる。 -Scala 3は`scala.language.reflectiveCalls`がインポートされている場所ならどこでも`scala.reflect.Selectable.reflectiveSelectable`を利用可能にすることで、Scala 2のリフレクションの呼び出しを模倣することができます。 -ただし、Scala 3コンパイラーはデフォルトでは構造型を推測しないため、コンパイルに失敗します。: +Scala 3 は `scala.language.reflectiveCalls` がインポートされている場所ならどこでも `scala.reflect.Selectable.reflectiveSelectable` を利用することが可能で、Scala 2 のリフレクションの呼び出しを模倣することができる。 +ただし、Scala 3 コンパイラーはデフォルトでは構造型を推測しないため、コンパイルに失敗する: ```scala import scala.language.reflectiveCalls @@ -81,7 +81,7 @@ val foo = new { foo.bar // Error: value bar is not a member of Object ``` -簡単な解決策は、構造タイプを明示的に書き留めておくことです。 +簡単な解決策は、構造型を明示的に書くことだ。 {% highlight diff %} import scala.language.reflectiveCalls diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md index 93a27170fc..40db412f23 100644 --- a/_ja/overviews/scala3-migration/incompatibility-table.md +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -8,36 +8,38 @@ next-page: incompat-syntactic language: ja --- -非互換性とは、Scala 2.13でコンパイルできるがScala 3ではなできないコードの一部のことです。 -コードベースの移行には、ソースコードの全ての非互換性を見つけて修正することが含まれています。 -極稀に、我々は実行時の非互換性に遭遇します：動作が異なるコードの一部です。 +非互換性とは、Scala 2.13 でコンパイルできるが Scala 3 ではコンパイルできないコードの一部のことである。 +コードベースの移行作業には、ソースコードの全ての非互換性を見つけて修正することが含まれている。 +極稀に、実行時の非互換性に遭遇する：動作が異なるコードの一部だ。 + +このページでは既知の非互換性の分類を提案する。 +それぞれの非互換性は以下のように説明している: -このページでは我々は既知の非互換性の分類を提案します。 -それぞれの非互換性は以下のように説明されています。: - 詳細な説明と提案された解決策へのリンクを含む名前 - - Scala 2.13コンパイラが非推奨または機能WARNINGを発するかどうか + - Scala 2.13 コンパイラが非推奨または機能WARNINGを発するかどうか - 非互換性に関しての[Scala 3移行](tooling-migration-mode.html)ルールの存在 - - 非互換性に関して修正できるScalafixルールの存在 + - 非互換性に関して修正できる Scalafix ルールの存在 > #### Scala2.13の非推奨と機能WARNING -> 2.13コンパイルを`-source:3`で実行すると非互換性のコードを見つけます。 +> 2.13 コンパイルを `-source:3` で実行すると非互換性のコードを見つける。 -> #### Scala 3移行とScalafixリライトの比較 -> Scala3移行モードはすぐに使用できます。 -> それに対して、Scalafixは手動でインストールして構成する必要があるツールです。 -> ただし、Scalafixには独自の利点があります。: -> - Scala 2.13で動く +> #### Scala 3移行とScalafix書き換えの比較 +> Scala 3 移行モードはすぐに使用できる。 +> それに対して、Scalafix は手動でインストールして構成する必要があるツールだ。 +> ただし、Scalafix には独自の利点がある: +> +> - Scala 2.13 で動く > - 一度に1つずつ適用することができる個々のルールで構成されている > - カスタムルールの追加により拡張が容易である -### シンタックスの変更 +### 構文の変更 -いくつかの古い構文はサポートされていないです。 +いくつかの古い構文はサポートされていない。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | |[制限された予約語](incompat-syntactic.html#制限された予約語)||✅|| -|[手続き型シンタックス](incompat-syntactic.html#手続き型シンタックス)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| +|[手続き型構文](incompat-syntactic.html#手続き型構文)|Deprecation|✅|[✅](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html)| |[Lambdaパラメータを囲む括弧](incompat-syntactic.html#lambdaパラメータを囲む括弧)||✅|[✅](https://github.com/ohze/scala-rewrites/tree/dotty/#fixscala213parensaroundlambda)| |[引数を渡すための括弧のインデント](incompat-syntactic.html#引数を渡すための括弧のインデント)||✅|| |[間違ったインデント](incompat-syntactic.html#間違ったインデント)|||| @@ -46,21 +48,21 @@ language: ja ### 機能の削除 -いくつかの機能は言語を簡単にするために削除されています。 +いくつかの機能は言語を簡単にするために削除した。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | |[シンボリックリテラル](incompat-dropped-features.html#シンボリックリテラル)|Deprecation|✅|| -|[`do`-`while` 構造](incompat-dropped-features.html#do-while-構造)||✅|| +|[`do`-`while` 機能](incompat-dropped-features.html#do-while-機能)||✅|| |[自動適用](incompat-dropped-features.html#自動適用)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala)| -|[Eta展開の値](incompat-dropped-features.html#eta展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| +|[イータ展開の値](incompat-dropped-features.html#イータ展開の値)|Deprecation|✅|[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala)| |[`any2stringadd` 変換](incompat-dropped-features.html#any2stringadd-変換)|Deprecation||[✅](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala)| |[先行初期化](incompat-dropped-features.html#先行初期化)|Deprecation||| |[存在型](incompat-dropped-features.html#存在型)|Feature warning||| ### コンテキストの抽象化 -[コンテキストの抽象化]({% link _scala3-reference/contextual.md %})の再設計は明確に定義された非互換性が発生します。 +[コンテキストの抽象化]({% link _scala3-reference/contextual.md %})の再設計は明確に定義された非互換性が発生する。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule|Runtime Incompatibility| |--- |--- |--- |--- |--- | @@ -69,14 +71,14 @@ language: ja |[View bounds](incompat-contextual-abstractions.html#view-bounds)|Deprecation|||| |[`A`と`=> A`でのあいまいな変換](incompat-contextual-abstractions.html#aと-aでのあいまいな変換)||||| -さらに、暗黙の解決ルールを変更して、より便利で意外なものにならないようにしました。 -新しいルールについては[ここ](/scala3/reference/changed-features/implicit-resolution.html)に説明しています。 +さらに、暗黙の解決ルールを変更して、より便利で、意外なものにはならないようにした。 +新しいルールについては[ここ](/scala3/reference/changed-features/implicit-resolution.html)に説明している。 -これらの変更により、Scala 3コンパイラーは、既存のScala 2.13コードのいくつかの暗黙的なパラメーターの解決に失敗する可能性があります。 +これらの変更により、Scala 3 コンパイラーは、既存の Scala 2.13 コードのいくつかの暗黙的なパラメーターの解決に失敗する可能性がある。 ### その他の変更した機能 -他のいくつかの機能は、言語をより簡単に、より安全に、またはより一貫性のあるものにするために簡略化または制限されています。 +他のいくつかの機能は、言語をより簡単に、より安全に、またはより一貫性のあるものにするために簡略化または制限した。 |Incompatibility|Scala 3 Migration Rewrite| |--- |--- | @@ -89,11 +91,11 @@ language: ja |[型パラメータとしての`=> T`](incompat-other-changes.html#型パラメータとしての-t)|| |[型引数のワイルドカード](incompat-other-changes.html#型引数のワイルドカード)|| -### 型チェッカー +### 型検査 -Scala 2.13の型チェッカーはある特定のケースに関して解決できないです。 -これは思いもしない驚異的な実行時エラーを導いてしまいます。 -Scala 3は強力で理論的な基盤に基づいているため、型チェッカーのこれらの不健全なバグが修正されました。 +Scala 2.13 の型検査はある特定のケースに関して解決できない。 +これは驚異的で思いもしない実行時エラーを導く。 +Scala 3 は強力で理論的な基盤に基づいているため、型検査のこれらの不健全なバグは修正された。 |Incompatibility| |--- | @@ -102,26 +104,27 @@ Scala 3は強力で理論的な基盤に基づいているため、型チェッ ### 型推論 -いくつかの固有の型推論のルールはScala 2.13とScala 3の間で変更されました +いくつかの固有の型推論のルールは Scala 2.13 と Scala 3 の間で変更した。 |Incompatibility| |--- | |[オーバーライドしたメソッドの返り値の型](incompat-type-inference.html#オーバーライドしたメソッドの返り値の型)| |[リフレクションの型](incompat-type-inference.html#リフレクションの型)| -また、型推論アルゴリズムは全体的な再設計を行い改善されました。 -この根本的な変更により、いくつかの非互換性が生じます。: -- 別の型で推測することがあります -- 新しい型チェックエラーが表示される場合があります +また、型推論アルゴリズムは全体的な再設計を行い改善した。 +この根本的な変更により、いくつかの非互換性が生じる: + +- 別の型で推測することがある +- 新しい型検査でエラーが表示される場合がある -> すべてのパブリックな値とメソッドの結果の型を明示的に記述することは良い習慣です。 -> この習慣は、推測されるタイプが異なり、ライブラリのパブリックAPIがScalaバージョンで変更されるのを防ぎます。 +> すべてのパブリックな値とメソッドの結果の型を明示的に記述することは良い習慣である。 +> この習慣は、推測される型が異なり、ライブラリのパブリック API が Scala バージョンで変更されるのを防ぐ。 > -> これは、Scalafixの[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)ルールを使用して、Scala3の移行前に行うことができます. +> これは、Scalafix の[ExplicitResultTypes](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html)ルールを使用して、Scala 3 の移行前に行うことができる。 ### マクロ -Scala 3コンパイラはScala 2.13マクロを展開することはできません。 -このような状況では、新しいScala 3メタプログラミング機能を使用して、Scala 2.13マクロを再実装する必要があります。 +Scala 3 コンパイラは Scala 2.13 マクロを展開することはできない。 +このような状況では、新しい Scala 3 メタプログラミング機能を使用して、Scala 2.13 マクロを再実装する必要がある。 -[メタプログラミング](compatibility-metaprogramming.html) のページに戻れば新しいメタプログラミング機能について学ぶことができます +[メタプログラミング](compatibility-metaprogramming.html) のページに戻れば新しいメタプログラミング機能について学ぶことができる。 diff --git a/_ja/overviews/scala3-migration/options-intro.md b/_ja/overviews/scala3-migration/options-intro.md index 5a502fcaed..6a42bbcdde 100644 --- a/_ja/overviews/scala3-migration/options-intro.md +++ b/_ja/overviews/scala3-migration/options-intro.md @@ -1,22 +1,22 @@ --- title: コンパイラオプション type: chapter -description: この章ではScala 2.13とScala 3間のコンパイラオプションの違いについて示します +description: この章は Scala 2.13 と Scala 3 間のコンパイラオプションの違いについて示します num: 21 previous-page: incompat-type-inference next-page: options-lookup language: ja --- -Scala 3コンパイラは0から書き直されたため、Scala 2.13コンパイラと同じオプションは提供されません。 -別の名前で利用できるオプションもあれば、まだ実装されていないオプションもあります。 +Scala 3 コンパイラはゼロから書き直されたため、Scala 2.13 コンパイラと同じオプションは提供されない。 +別の名前で利用できるオプションもあれば、まだ実装されていないオプションもある。 -Scala 2.13プロジェクトをScala 3に移植した時、コンパイラオプションのリストを適用させる必要があるでしょう +Scala 2.13 プロジェクトを Scala 3 に移植した際、コンパイラオプションのリストを適用させる必要がある。 適用させるために[ルックアップテーブル](options-lookup.html)を参照してください。 -> 利用できないオプションをScala 3コンパイラーに渡しても、失敗することはありません。 +> 利用できないオプションを Scala 3 コンパイラーに渡しても、失敗することはない。 > WARNINGを出力し、指定したオプションを無視します。 -[新しいコンパイラオプション](options-new.html)のページで、Scala 2.13にはないScala 3の新しいオプションを見つけることができます。 +[新しいコンパイラオプション](options-new.html)のページで、Scala 2.13 にはない Scala 3 の新しいオプションを見つけることができる。 -scaladoc設定のリファレンスとScala2scaladocとの互換性については、[ScaladocについてScala2とScala3間における互換性設定](scaladoc-settings-compatibility.html)ページをご覧ください。 +scaladoc 設定のリファレンスと Scala2scaladoc との互換性については、[ScaladocについてScala2とScala3間における互換性設定](scaladoc-settings-compatibility.html)ページをご覧ください。 diff --git a/_ja/overviews/scala3-migration/options-lookup.md b/_ja/overviews/scala3-migration/options-lookup.md index 750d0dd987..b1e6580e4a 100644 --- a/_ja/overviews/scala3-migration/options-lookup.md +++ b/_ja/overviews/scala3-migration/options-lookup.md @@ -8,21 +8,21 @@ next-page: options-new language: ja --- -コンパイラオプションは、Scala 2.13の名前に従って分類および順序付けしています。 -各Scala 2.13オプションは、Scala 3でのステータスを関連付けています。 +コンパイラオプションは、Scala 2.13 の名前に従い、分類および順序付けしている。 +各 Scala 2.13 オプションは、Scala 3 でのステータスと関連付けている。 | Status | Meaning | -|-|-| -| | Scala 3で利用可能です | -| `` | ``に変名しました | -| | 3.0.0では利用できませんが後から追加でしょう | +|---|---| +| | Scala 3で利用可能 | +| `` | `` に変名した | +| | 3.0.0 では利用できないが後から追加するだろう | -> 現状の比較に関しては2.13.4と3.0.0-M3で比較しています。 +> 現状の比較に関しては 2.13.4 と 3.0.0-M3 で比較している。 ## 基本設定 | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Dproperty=value` | | | `-J` | | | `-P::` || @@ -67,7 +67,7 @@ language: ja ## 拡張設定 | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-X` || | `-Xcheckinit` | `-Ycheck-init` | | `-Xdev` | | @@ -111,7 +111,7 @@ language: ja ## プライベート設定 | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Ybackend-parallelism` | | | `-Ybackend-worker-queue` | | | `-Ybreak-cycles` | | @@ -184,11 +184,11 @@ language: ja ## 詳細設定 -2.13では詳細設定が導入されていました。 -その殆どに関してScala 3ではまだ実装されていません。 +2.13 では詳細設定が導入されていた。 +その殆どはScala 3 ではまだ実装されていない。 | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Vbrowse:` | | | `-Vdebug-tasty` | | | `-Vdoc` | | @@ -228,8 +228,8 @@ language: ja ## Warning設定 -Warningの設定は2.13で導入されていました。 -その殆どに関してScala 3ではまだ実装されていません。 +Warningの設定は 2.13 で導入されていた。 +その殆どは Scala 3 ではまだ実装されていない。 | 2.13.x | 3.0.x | |-|-| @@ -246,13 +246,13 @@ Warningの設定は2.13で導入されていました。 ## コンパイラプラグイン -いくつかの便利なScala 2.13コンパイラプラグインはScala 3コンパイラに同梱されています。 -いくつかの新しいネイティブオプションを使用して、有効にできます。 +いくつかの便利な Scala 2.13 コンパイラプラグインは Scala 3 コンパイラに同梱されている。 +いくつかの新しいネイティブオプションを使用して、有効にできる。 ### Scala.js | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Xplugin:scalajs-compiler_.jar` | `-scalajs` | | `-P:scalajs:genStaticForwardersForNonTopLevelObjects` | `-scalajs-genStaticForwardersForNonTopLevelObjects` | | `-P:scalajs:mapSourceURI`| `-scalajs-mapSourceURI`| @@ -260,12 +260,12 @@ Warningの設定は2.13で導入されていました。 ### SemanticDB | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Xplugin:semanticdb-scalac_.jar`| `-Xsemanticdb` | | `-P:semanticdb:targetroot:` | `-semanticdb-target:` | ### Kind-Projector | 2.13.x | 3.0.x | -|-|-| +|---|---| | `-Xplugin:kind-projector_.jar` | `-Ykind-projector` | diff --git a/_ja/overviews/scala3-migration/options-new.md b/_ja/overviews/scala3-migration/options-new.md index a06e56b63f..2c9feff6f7 100644 --- a/_ja/overviews/scala3-migration/options-new.md +++ b/_ja/overviews/scala3-migration/options-new.md @@ -1,98 +1,98 @@ --- title: 新しいコンパイラオプション type: section -description: この章ではScala 3の全ての新しいコンパイラオプションをリスト化します +description: この章では Scala 3 の全ての新しいコンパイラオプションをリスト化します num: 23 previous-page: options-lookup next-page: scaladoc-settings-compatibility language: ja --- -現在のページには、Scala 3.0.xで追加されたオプションのみが含まれています。 +このページでは、Scala 3.0.x で追加されたオプションのみが含まれている。 ## 基本設定 | 3.0.x | description | -|-|-| +|---|---| | `-color` | 出力の色付け Default: always. | -| `-doc-snapshot` | 現在のDottyのバージョン用のドキュメントのスナップショットを生成します| -| `-explain` | エラーの詳細を説明します。 | -| `-from-tasty` | TASTyファイルのクラスコンパイル. 引数は .tasty または .jar ファイル. | -| `-indent` | -rewriteと一緒に使います, 重要なインデントのために可能な場合は {...} シンタックスを削除します。 | -| `-new-syntax` | 制御式に `then` と `do` が必要になります。 | -| `-no-indent` | クラシックな {...} シンタックスが必要で, インデントは重要ではないです | -| `-old-syntax` | 条件の周りに`(...)`が必要です。 | -| `-pagewidth` | ページ幅の設定 Default: 80. | -| `-print-lines` | ソースコードの行数を表示します。 | -| `-print-tasty` | 生のTASTyを表示します。 | -| `-project` | プロジェクトの名前。 | -| `-project-logo` | プロジェクトロゴ (in /imagesにある)を含めます。 | +| `-doc-snapshot` | 現在のDottyのバージョン用のドキュメントのスナップショットを生成する| +| `-explain` | エラーの詳細を記述する | +| `-from-tasty` | TASTyファイルのクラスコンパイル。 引数は .tasty または .jar ファイル | +| `-indent` | -rewrite と一緒に使う。重要なインデントのために可能な場合は {...} 構文を削除する | +| `-new-syntax` | 制御式に `then` と `do` が必要 | +| `-no-indent` | クラシックな {...} 構文が必要で、インデントは考慮しない | +| `-old-syntax` | 条件の周りに `(...)` が必要だ | +| `-pagewidth` | ページ幅の設定 Default: 80 | +| `-print-lines` | ソースコードの行数を表示する | +| `-print-tasty` | 生のTASTyを表示する | +| `-project` | プロジェクトの名前 | +| `-project-logo` | プロジェクトロゴ (/images下にある)を含める。 | | `-project-url` | プロジェクトのリポジトリ | | `-project-version` | プロジェクトの現行バージョン | -| `-rewrite` | `...-migration` ソースバージョンと組み合わせて使用​​する場合, ソースを最新バージョンに移行させます。 | +| `-rewrite` | `...-migration` ソースバージョンと組み合わせて使用​​する場合、ソースを最新バージョンに移行する | | `-siteroot` | ドキュメントを生成する静的ファイルを含むディレクトリ Default: ./docs. | -| `-sourceroot` | ワークスペースのルートディレクトリを指定します。 Default: .. | +| `-sourceroot` | ワークスペースのルートディレクトリを指定する Default: .. | ## 拡張設定 | 3.0.x | description | -|-|-| -| `-Xignore-scala2-macros` | Scala 2マクロを呼び出すコードをコンパイルするときのエラーを無視しますが実行時に失敗するでしょう。 | -| `-Ximport-suggestion-timeout` | エラーが報告されたときにインポート候補を検索するためのタイムアウト（ミリ秒単位）。 | -| `-Xmax-inlined-trees` | インラインツリーの最大数。 Default: 2000000 | -| `-Xmax-inlines` | 連続するインラインの最大数。 Default: 32. | -| `-Xprint-diff` | 前回のプリント出力以降に変更されたツリーの部分をプリント出力します。 | -| `-Xprint-diff-del` | 削除された部分を含め、最後のプリント出力した以降に変更されたツリーの部分をプリント出力します。 | -| `-Xprint-inline` | インライン化されたコードがどこから来たのかを示します。 | -| `-Xprint-suspension` | マクロがコンパイルされるまでコードが一時停止されるタイミングを表示します。 | -| `-Xrepl-disable-display` | REPLで定義を表示しません。 | -| `-Xwiki-syntax` | ScaladocでWiki構文を使用するScala2の動作を保持します。 | +|---|---| +| `-Xignore-scala2-macros` | Scala 2 マクロを呼び出すコードをコンパイルする際、エラーを無視するが実行時に失敗するだろう | +| `-Ximport-suggestion-timeout` | エラーが報告されたときにインポート候補を検索する時のタイムアウト（ミリ秒単位） | +| `-Xmax-inlined-trees` | インラインツリーの最大数 Default: 2000000 | +| `-Xmax-inlines` | 連続するインラインの最大数 Default: 32 | +| `-Xprint-diff` | 前回のプリント出力以降に変更されたツリーの部分をプリント出力する | +| `-Xprint-diff-del` | 削除された部分を含め、最後のプリント出力した以降に変更されたツリーの部分をプリント出力する | +| `-Xprint-inline` | インライン化されたコードがどこから来たのかを示す | +| `-Xprint-suspension` | マクロがコンパイルされるまでコードが一時停止されるタイミングを表示する | +| `-Xrepl-disable-display` | REPLで定義を表示しない | +| `-Xwiki-syntax` | Scaladoc で Wiki 構文を使用する Scala 2 の動作を保持する | ## プライベート設定 | 3.0.x | description | -|-|-| -| `-Ycheck-all-patmat` | すべてのパターンマッチング（アルゴリズムのテストに使用）の網羅性と冗長性を確認します。| -| `-Ycheck-mods` | シンボルとその定義ツリーに修正が同期していることを確認します。 | -| `-Ycheck-reentrant` | コンパイルされたプログラムに、グローバルルートからアクセスできる変数が含まれていないことを確認します。 | -| `-Ycook-comments` | コメントを調整します（型チェック `@ usecase`など） | -| `-Ydebug-error` | エラーが検出されたときにスタックトレースをプリント出力します。 | -| `-Ydebug-flags` | 定義のすべてのフラグをプリント出力します。 | -| `-Ydebug-missing-refs` | 必要なシンボルが欠落している場合は、スタックトレースにプリント出力します。 | -| `-Ydebug-names` | 名前の内部表現を表示します。 | -| `-Ydebug-pos` | スパンを含む完全なソース位置を表示します。 | -| `-Ydebug-trace` | トレースのコアオプションです。 | -| `-Ydebug-tree-with-id` | 指定されたIDのツリーが作成されたときに、スタックトレースをプリント出力します。 Default: -2147483648. | -| `-Ydebug-type-error` | TypeErrorがキャッチされたときにスタックトレースをプリント出力します | -| `-Ydetailed-stats` | 詳細な内部コンパイラ統計を表示します（別途Stats.enabledをtrueに設定する必要があります）。 | -| `-YdisableFlatCpCaching` | コンパイラインスタンス間でjarからのクラスパス要素のフラットクラスパス表現をキャッシュさせません。 | -| `-Ydrop-comments` | ソースファイルをスキャンするときにコメントを削除します。 | -| `-Ydump-sbt-inc` | コンパイルされたすべてのfoo.scalaについて、foo.incでsbtインクリメンタルコンパイルに使用されるAPI表現と依存関係をプリント出力します。これは-Yforce-sbt-phasesを意味します。 | -| `-Yerased-terms` | 消去された用語の使用を許可します。 | -| `-Yexplain-lowlevel` | タイプエラーを説明するときは、タイプを下位レベルで表示します。　| -| `-Yexplicit-nulls` | 参照型をNULL不可にします。null許容型は、ユニオンで表すことができます。: e.g. String|Null. | -| `-Yforce-sbt-phases` | デバッグ用で、コンパイラがsbtの外部で実行されている場合でも、インクリメンタルコンパイル（ExtractDependenciesおよびExtractAPI）します。 | -| `-Yfrom-tasty-ignore-list` | -from-tastyの使用時にロードされないjarファイル内の `tasty`ファイルのリストを指定 | -| `-Yindent-colons` | 行末のコロンがインデントブロックを開始できるようにします。 | -| `-Yinstrument` | 割り当てとクロージャーの作成をカウントするインストルメンテーションコードを追加します。 | -| `-Yinstrument-defs` | メソッド呼び出しをカウントするインストルメンテーションコードを追加します。 -Yinstrumentも設定する必要があります。 | -| `-Yno-decode-stacktraces` | トリガー操作にデコードする代わりに、生のStackOverflowスタックトレースを実行します | -| `-Yno-deep-subtypes` | 深いサブタイプの呼び出しスタックで例外をスローします。 | -| `-Yno-double-bindings` | 名前付き型が2回バインドされていないことをアサートします（プログラムにエラーがない場合にのみ有効にする必要があります）。 | -| `-Yno-kind-polymorphism` | 種類のポリモーフィズムを無効にします。 | -| `-Yno-patmat-opt` | すべてのパターンマッチングの最適化を無効にします。 | -| `-Yplain-printer` | Pretty-printを使用してきれいにプリント出力します。 | -| `-Yprint-debug` | ツリーのプリント出力時に, デバッグ用にその他の便利な情報を出力します。 | -| `-Yprint-debug-owners` | ツリーのプリント出力時に, 定義の所有者をプリント出力します。 | -| `-Yprint-pos` | ツリーの場所を表示します。 | -| `-Yprint-pos-syms` | シンボル定義の場所を表示します。 | -| `-Yprint-syms` | ツリーをプリント出力する場合、ツリー内の対応する情報ではなく、シンボルで情報をプリント出力します | -| `-Yrequire-targetName` | @targetNameアノテーションなしで定義しているのがあればWARNINGします。 | -| `-Yretain-trees` | ClassSymbol＃treeからアクセス可能なトップレベルクラスのツリーを保持します。 | -| `-Yscala2-unpickler` | Scala2シンボルをどこから取得できるかを制御します。"always", "never", またはクラスパスのどれかを指定できます。 Default: always. | -| `-Yshow-print-errors` | ツリーのプリント出力時に投げられる例外を抑制しないようにします。 | -| `-Yshow-suppressed-errors` | 通常は抑制されている後続のエラーとWARNINGを表示します. | -| `-Yshow-tree-ids` | デバッグ出力ですべてのツリーノードに一意にタグを付けます。 | -| `-Yshow-var-bounds` | 型変数とその境界をプリント出力します。 | -| `-Ytest-pickler` | 関数的なpicklingにおける自己テスト; -Ystop-after:picklerと一緒に使われるべきです。 | -| `-Yunsound-match-types` | 不健全なmatchタイプの削減アルゴリズムを使用します。| +|---|---| +| `-Ycheck-all-patmat` | すべてのパターンマッチング（アルゴリズムのテストに使用）の網羅性と冗長性を確認する | +| `-Ycheck-mods` | シンボルとその定義ツリーに修正が同期していることを確認する | +| `-Ycheck-reentrant` | コンパイルされたプログラムに、グローバルルートからアクセスできる変数が含まれていないことを確認する | +| `-Ycook-comments` | コメントを調整する（型検査 `@ usecase` など） | +| `-Ydebug-error` | エラーが検出されたときにスタックトレースをプリント出力する | +| `-Ydebug-flags` | 定義のすべてのフラグをプリント出力する | +| `-Ydebug-missing-refs` | 必要なシンボルが欠落している場合は、スタックトレースにプリント出力する | +| `-Ydebug-names` | 名前の内部表現を表示する | +| `-Ydebug-pos` | スパンを含む完全なソース位置を表示する | +| `-Ydebug-trace` | トレースのコアオプション | +| `-Ydebug-tree-with-id` | 指定されたIDのツリーが作成されたときに、スタックトレースをプリント出力する Default: -2147483648 | +| `-Ydebug-type-error` | TypeError がキャッチされたときにスタックトレースをプリント出力する | +| `-Ydetailed-stats` | 詳細な内部コンパイラ統計を表示する（別途 Stats.enabled を true に設定する必要がある） | +| `-YdisableFlatCpCaching` | コンパイラインスタンス間で jar からのクラスパス要素のフラットクラスパス表現をキャッシュさせない | +| `-Ydrop-comments` | ソースファイルをスキャンするときにコメントを削除する | +| `-Ydump-sbt-inc` | コンパイルされたすべての foo.scala について、foo.inc で sbt インクリメンタルコンパイルに使用される API 表現と依存関係をプリント出力する　これは -Yforce-sbt-phases を意味する | +| `-Yerased-terms` | 消去された用語の使用を許可する | +| `-Yexplain-lowlevel` | タイプエラーを説明するときは、タイプを下位レベルで表示する　| +| `-Yexplicit-nulls` | 参照型を NULL 不可にする　null 許容型は、ユニオンで表すことができる: e.g. String|Null. | +| `-Yforce-sbt-phases` | デバッグ用で、コンパイラが sbt の外部で実行されている場合でも、インクリメンタルコンパイル（ExtractDependencies および ExtractAPI ）する | +| `-Yfrom-tasty-ignore-list` | -from-tasty の使用時にロードされない jar ファイル内の `tasty` ファイルのリストを指定する | +| `-Yindent-colons` | 行末のコロンがインデントブロックを開始できるようする | +| `-Yinstrument` | 割り当てとクロージャーの作成をカウントするインストルメンテーションコードを追加する | +| `-Yinstrument-defs` | メソッド呼び出しをカウントするインストルメンテーションコードを追加する -Yinstrument も設定する必要がある | +| `-Yno-decode-stacktraces` | トリガー操作にデコードする代わりに、生の StackOverflow スタックトレースを実行する | +| `-Yno-deep-subtypes` | 深いサブタイプの呼び出しスタックで例外をスローする | +| `-Yno-double-bindings` | 名前付き型が2回バインドされていないことをアサートする（プログラムにエラーがない場合にのみ有効にする必要がある） | +| `-Yno-kind-polymorphism` | 種類のポリモーフィズムを無効にする | +| `-Yno-patmat-opt` | すべてのパターンマッチングの最適化を無効にする | +| `-Yplain-printer` | Pretty-print を使用してきれいにプリント出力する | +| `-Yprint-debug` | ツリーのプリント出力時に、デバッグ用にその他の便利な情報を出力する | +| `-Yprint-debug-owners` | ツリーのプリント出力時に, 定義の所有者をプリント出力する | +| `-Yprint-pos` | ツリーの場所を表示する | +| `-Yprint-pos-syms` | シンボル定義の場所を表示する | +| `-Yprint-syms` | ツリーをプリント出力する場合、ツリー内の対応する情報ではなく、シンボルで情報をプリント出力する | +| `-Yrequire-targetName` | @targetName アノテーションなしで定義しているのがあればWARNINGを出す | +| `-Yretain-trees` | ClassSymbol＃tree からアクセス可能なトップレベルクラスのツリーを保持する | +| `-Yscala2-unpickler` | Scala2 シンボルをどこから取得できるかを制御する。 "always"、 "never"、 またはクラスパスのどれかを指定する。 Default: always | +| `-Yshow-print-errors` | ツリーのプリント出力時に投げられる例外を抑制しないようにする | +| `-Yshow-suppressed-errors` | 通常は抑制されている後続のエラーとWARNINGを表示する | +| `-Yshow-tree-ids` | デバッグ出力ですべてのツリーノードに一意にタグを付ける | +| `-Yshow-var-bounds` | 型変数とその境界をプリント出力する | +| `-Ytest-pickler` | 関数的な pickling における自己テスト; -Ystop-after:pickler と一緒に使われるべきだ | +| `-Yunsound-match-types` | 不健全な match タイプの削減アルゴリズムを使用する| diff --git a/_ja/overviews/scala3-migration/plugin-intro.md b/_ja/overviews/scala3-migration/plugin-intro.md index 66ffd08110..d0ba71ce2c 100644 --- a/_ja/overviews/scala3-migration/plugin-intro.md +++ b/_ja/overviews/scala3-migration/plugin-intro.md @@ -1,12 +1,12 @@ --- title: コンパイラプラグイン type: chapter -description: このセクションではScala 2コンパイラプラグインを用いて移行する方法を示します +description: このセクションは Scala 2 コンパイラプラグインを用いて移行する方法を示します。 num: 25 previous-page: options-new next-page: plugin-kind-projector language: ja --- -Scala 3には、以前のコンパイラプラグインにより提供されていた、いくつかの機能が含まれています。 -この章では、使用している特定のコンパイラプラグインをScala3に移行する方法について詳しく説明します。 \ No newline at end of file +Scala 3 には、以前のコンパイラプラグインにより提供されていた一部機能が含まれてる。 +この章では、使用している特定のコンパイラプラグインを Scala 3 に移行する方法について詳しく説明する。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/plugin-kind-projector.md b/_ja/overviews/scala3-migration/plugin-kind-projector.md index 4228f1c11b..8c90636b22 100644 --- a/_ja/overviews/scala3-migration/plugin-kind-projector.md +++ b/_ja/overviews/scala3-migration/plugin-kind-projector.md @@ -1,22 +1,22 @@ --- title: Kind Projector移行 type: section -description: このセクションではkind-projector pluginからScala 3のkind-projectorシンタックスに移行する方法を示します +description: このセクションでは kind-projector plugin からScala 3 の kind-projector 構文に移行する方法を示します num: 26 previous-page: plugin-intro next-page: external-resources language: ja --- -将来的には、Scala3は型ラムダのプレースホルダーに `_`アンダースコア記号を使用する予定です---アンダースコアは現在（通常の）用語レベルのラムダのプレースホルダーに使用されているのと同じです。 +将来的には、Scala 3 は型ラムダのプレースホルダーに `_` アンダースコア記号を使用する予定だ---アンダースコアは現在（通常の）用語レベルのラムダのプレースホルダーに使用されているのと同じだ。 -新しい型ラムダのシンタックスはデフォルトでは有効になっていません。有効にするには、コンパイラフラグ `-Ykind-projector：underscores`を使用します。 アンダースコアの型ラムダを有効にすると、ワイルドカードとしての `_`の使用が無効になり、`?`記号を使用してのみワイルドカードを書き込むことができるということに注意してください。 +新しい型ラムダの構文はデフォルトでは有効になっていない。有効にするには、コンパイラフラグ `-Ykind-projector：underscores` を使用する。 アンダースコアの型ラムダを有効にすると、ワイルドカードとしての `_` の使用が無効になり、`?` 記号を使用してのみワイルドカードを書き込むことができるということに注意すべきだ。 -アンダースコアの型ラムダを使用しながらScala 2とScala 3のプロジェクトをクロスコンパイルする場合は、 [kind-projector](https://github.com/typelevel/kind-projector) バージョンで`0.13.0`以上から開始することができ、Scala 2 バージョンは `2.13.6`と `2.12.14`が必要です。 -有効にするには、コンパイラフラグ `-Xsource:3 -P:kind-projector:underscore-placeholders` をビルドに追加します。 -Scala 3と同様、この設定によりワイルドカードとしての `_`の使用が無効になりますが、フラグ`-Xsource:3`を使用すると、`?`記号に置き換えることができます。 +アンダースコアの型ラムダを使用しながら Scala 2 と Scala 3 のプロジェクトをクロスコンパイルする場合は、 [kind-projector](https://github.com/typelevel/kind-projector) バージョンで `0.13.0` 以上から開始することができ、Scala 2 バージョンは `2.13.6` と `2.12.14`が必要である。 +有効にするには、コンパイラフラグ `-Xsource:3 -P:kind-projector:underscore-placeholders` をビルドに追加する。 +Scala 3 と同様、この設定によりワイルドカードとしての `_` の使用が無効になるが、フラグ `-Xsource:3` を使用すると、`?` 記号に置き換えることができる。 -次の `sbt`構成は、新しいシンタックスでクロスコンパイルするための正しいフラグを設定します。 +次の `sbt` 構成は、新しい構文でクロスコンパイルするための正しいフラグを設定する。 ```scala ThisBuild / scalacOptions ++= { @@ -27,25 +27,25 @@ ThisBuild / scalacOptions ++= { } ``` -## 新しいシンタックスの移行 +## 新しい構文の移行 -既存のkind-projector対応コードで型ラムダにアンダースコアを使用するには、`*` または `?` を用いている型ラムダのプレースホルダを`_`に置き換えます。 +既存の kind-projector 対応コードで型ラムダにアンダースコアを使用するには、`*` または `?` を用いている型ラムダのプレースホルダを `_` に置き換える。 -次に、`?`記号を使用するには、ワイルドカードとしての`_`のすべての使用方法を書き直す必要があります。 +次に、`?` 記号を使用するには、ワイルドカードとしての `_` のすべての使用方法を書き直す必要がある。 -たとえば、次のワイルドカードの使用方法をあげます: +例えば、次のワイルドカードの使用方法を示す: ```scala def getWidget(widgets: Set[_ <: Widget], name: String): Option[Widget] = widgets.find(_.name == name) ``` -必ず書き直します: +必ず書き直す必要がある: ```scala def getWidget(widgets: Set[? <: Widget], name: String): Option[Widget] = widgets.find(_.name == name) ``` -そしてkind-projectorの`*`プレースホルダを使用します: +そして kind-projector の `*` プレースホルダを使用する: ```scala Tuple2[*, Double] // equivalent to: type R[A] = Tuple2[A, Double] @@ -53,7 +53,7 @@ Either[Int, +*] // equivalent to: type R[+A] = Either[Int, A] Function2[-*, Long, +*] // equivalent to: type R[-A, +B] = Function2[A, Long, B] ``` -必ず書き直す必要があります: +必ず書き直す必要がある: ```scala Tuple2[_, Double] // equivalent to: type R[A] = Tuple2[A, Double] @@ -63,9 +63,9 @@ Function2[-_, Long, +_] // equivalent to: type R[-A, +B] = Function2[A, Long, B ## 既存コードのコンパイル -アンダースコアの型ラムダに移行しなくても、ほとんどを変更せずにScala 3でコンパイルできる可能性があります。 +アンダースコアの型ラムダに移行しなくても、ほとんどを変更せずに Scala 3 でコンパイルできる可能性がある。 -`-Ykind-projector`フラグを使用して`*`ベースの型ラムダのサポートを有効にします (アンダースコアの型ラムダを有効にしないで)、次のフォームがコンパイルされます。: +`-Ykind-projector` フラグを使用して `*` ベースの型ラムダのサポートを有効にする (アンダースコアの型ラムダを有効にしないで)、次のフォームがコンパイルされる: ```scala Tuple2[*, Double] // equivalent to: type R[A] = Tuple2[A, Double] @@ -75,13 +75,13 @@ Function2[-*, Long, +*] // equivalent to: type R[-A, +B] = Function2[A, Long, B ## 非互換性構造の書き換え -Scala 3の`-Ykind-projector` と `-Ykind-projector:underscores` は、`kind-projector`シンタックスの部分集合のみを実装し、それ以外は特に実装しません。: +Scala 3 の `-Ykind-projector` と `-Ykind-projector:underscores` は、`kind-projector` 構文の部分集合のみを実装し、それ以外は特に実装しない: * より種類の多い型ラムダのプレースホルダ * より種類の多い名前付き型ラムダパラメーター -* `Lambda`予約後(`λ`はまだサポートされています) +* `Lambda`予約語(`λ` はまだサポートされている) -次のすべてのフォームを書き直す必要があります: +次のすべてのフォームを書き直す必要がある: ```scala // classic @@ -94,35 +94,35 @@ EitherT[_[_], Int, _] // equivalent to: type R[F[_], B] = EitherT[F, Int, B] Lambda[(F[_], A) => EitherT[F, Int, A]] ``` -Scala 3とクロスコンパイルするための次の形式にします: +Scala 3 とクロスコンパイルするための次の形式にする: ```scala type MyLambda[F[_], A] = EitherT[F, Int, A] MyLambda ``` -また、クロスコンパイルする必要がない場合は、Scala 3の[Native Type Lambdas](https://dotty.epfl.ch/docs/reference/new-types/type-lambdas.html) を使用することができます。: +また、クロスコンパイルする必要がない場合は、Scala 3 の[Native Type Lambdas](https://dotty.epfl.ch/docs/reference/new-types/type-lambdas.html) を使用することができる: ```scala [F[_], A] =>> EitherT[F, Int, A] ``` -`Lambda`の場合、次のフォームを書き直す必要があります: +`Lambda` の場合、次のフォームを書き直す必要がある: ```scala Lambda[(`+E`, `+A`) => Either[E, A]] ``` -クロスコンパイルするには以下に書く必要があります: +クロスコンパイルするには以下のように書く必要がある: ```scala λ[(`+E`, `+A`) => Either[E, A]] ``` -または、Scala 3の型ラムダの代わりに以下を使います: +または、Scala 3 の型ラムダの代わりに以下を用いる: ```scala [E, A] =>> Either[E, A] ``` -Note: Scala 3の型ラムダは、パラメーターに`-`または`+`の分散マーカーを必要としなくなりました。これらは推測されるようになりました。 +Note: Scala 3 の型ラムダは、パラメーターに `-` または `+` の分散マーカーを必要としなくなった。これらは推測されるようになった。 diff --git a/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md index 3eada2ea0a..7edf4eb574 100644 --- a/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md +++ b/_ja/overviews/scala3-migration/scaladoc-settings-compatibility.md @@ -1,14 +1,14 @@ --- -title: Scala2とScala3間のScaladoc設定の互換性 +title: Scala 2 と Scala 3 間での Scaladoc 設定の互換性 type: section -description: この章ではScala 2とScala 3の全てのscaladocオプションをリスト化し、両者の関係性について説明します +description: この章では Scala 2 と Scala 3 の全ての scaladoc オプションをリスト化し、両者の関係性について説明します。 num: 24 previous-page: options-new next-page: plugin-intro language: ja --- -現在のページには、scaladoc設定のステータスが記載されています。関連するGithub issueは[discussion](https://github.com/lampepfl/dotty/issues/11907)で見つけることができます。 +このページに、scaladoc 設定のステータスを記載している。関連する Github issue は[discussion](https://github.com/lampepfl/dotty/issues/11907)で見つけることが可能だ。 | Scala2 | Scala3 | Description | Comment | Is implemented? @@ -57,29 +57,30 @@ language: ja ## Source links -Source linksgithubやbitbucketなどのリモートリポジトリにあるソースコードを指すために使用されます。 -うまくいけば、新しいシンタックスは古いシンタックスのほぼ上位集合になります。 -Hopefully, the new syntax is almost superset of the old syntax. -新しいscaladocシンタックスに移行するために, これらの変数が使われていないことを確認してください: -`€{TPL_OWNER}` や `€{FILE_PATH_EXT}`。 それ以外の場合は、他の`variables`を使用してソースリンクを書き換える必要があります。 -または、新しい変数を使用することもできます。より詳しくは[dotty docs](https://dotty.epfl.ch/docs/usage/scaladoc/settings.html)に記述されています。 -新しいシンタックスでは、ソースが特定のURLに一致するように、ファイルパスのプレフィックスを指定できます。異なるディレクトリまたは異なるリポジトリに散在しています。 +Source links は github や bitbucket などのリモートリポジトリにあるソースコードを指すために使用される。 +うまくいけば、新しい構文は古い構文のほぼ上位集合になる。 +新しい scaladoc 構文に移行するために、これらの変数が使われていないことを確認すべきだ: +`€{TPL_OWNER}` や `€{FILE_PATH_EXT}`。 それ以外の場合は、他の `variables` を使用して Source links を書き換える必要がある。 +それか、新しい変数を使用することも可能だ。より詳しくは[dotty docs](https://dotty.epfl.ch/docs/usage/scaladoc/settings.html)に記述されている。 +新しい構文では、ソースが特定の URL に一致するよう、ファイルパスのプレフィックスを指定できる。これは異なるディレクトリまたは異なるリポジトリに散在している。 ## 外部マッピング -この設定は、javadoc/scaladocの古い設定を一般化したものです。 +この設定は、javadoc/scaladoc の古い設定を一般化したものだ。 + +外部マッピングの例は以下のようになる: -外部マッピングの例は以下のようになります: ``` -external-mappings:.*scala.*::scaladoc3::https://scala-lang.org/api/3.x/,.*java.*::javadoc::https://docs.oracle.com/javase/8/docs/api/ ``` -マッピングの形式は '\::\[scaladoc3|scaladoc|javadoc]::\'です。 例に示すように、コンマで区切って複数のマッピングを指定できます。 +マッピングの形式は '\::\[scaladoc3|scaladoc|javadoc]::\'だ。 例のように、カンマで区切って複数のマッピングを指定できる。 + +古い構文は次のとおりだ: -古い構文は次のとおりです。: - scaladocの場合 - `prefix#url` - javadocの場合 - URLのみ -fq名に一致する正規表現を取得し(javadocの場合、`java.*`のようにワイルドカードにすることができます), ダブルコロン`::`を使用して3つの利用可能なドキュメント形式のいずれかと連結し、もう一度`::`を追加して、URLを指定する必要があります。 -外部ドキュメントがホストされている場所です。 \ No newline at end of file +fq 名に一致する正規表現を取得し( javadoc の場合、`java.*` のようにワイルドカードにすることができる)、 ダブルコロン`::` を使用して3つの利用可能なドキュメント形式のいずれかと連結し、もう一度 `::` を追加して、URL を指定する必要がある。 +外部ドキュメントがホストされている場所だ。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/tooling-migration-mode.md b/_ja/overviews/scala3-migration/tooling-migration-mode.md index e31ce00f34..151bedd9ac 100644 --- a/_ja/overviews/scala3-migration/tooling-migration-mode.md +++ b/_ja/overviews/scala3-migration/tooling-migration-mode.md @@ -8,13 +8,13 @@ next-page: tutorial-intro language: ja --- -Scala 3 のコンパイラは移行を簡単にするためのいくつかの便利なutilitiesを提供します。 +Scala 3 のコンパイラは移行を簡単にするため、いくつかの便利な utilities を提供している。 -`scalac` を試すとそれらのutilitiesを垣間見ることができます: +`scalac` を試すとそれらの utilities を垣間見ることが可能だ: -> `scalac` は実行可能なScalaコンパイラであり、[Github](https://github.com/lampepfl/dotty/releases/)からダウンロードできます。 +> `scalac` は実行可能な Scala コンパイラであり、[Github](https://github.com/lampepfl/dotty/releases/)からダウンロードできる。 > -> また、Coursierと`cs install scala3-compiler`を用いることでインストールすることもでき、その場合は`scalac`は別名`scala3-compiler`となります。 +> また、Coursier と `cs install scala3-compiler` を用いることでインストールすることもでき、その場合は`scalac` は別名 `scala3-compiler` となる。 {% highlight text %} $ scalac @@ -35,29 +35,29 @@ where possible standard options include: ## 移行モード -`-source:3.0-migration` オプションは除去された機能の多くを許容し、エラーの代わりにWARNINGを出力します。 -各WARNINGは非推奨のコードに関して、クロスコンパイルに対応するコードを安全に書き換えられることを強く示しています。 +`-source:3.0-migration` オプションは除去された機能の多くを許容し、エラーの代わりにWARNINGを出力する。 +各WARNINGは非推奨のコードに関して、クロスコンパイルに対応するコードを安全に書き換えが可能だということを強調して示す。 -我々はこれを **Scala 3 migration compilation**とよんでいます. +我々はこれを **Scala 3 移行コンパイル**と呼ぶ。 ## 自動書き換え -一度マイグレーションモードでコンパイルすると、ほとんど全てのWARNINGはコンパイラによって自動的に解決されます。 -これを行うためには、再度コンパイルする必要があり、今回は、 `-source:3.0-migration` と　`-rewrite` オプションを使います。 +一度移行モードでコンパイルすると、ほとんど全てのWARNINGはコンパイラによって自動的に解決する。 +これを行うためには、再度コンパイルする必要があり、今回は、 `-source:3.0-migration` と　`-rewrite` オプションを使う。 -> コンパイラがコードを変更することに注意してください！ 安全を目的としています。 -> しかしながら、コンパイラによって適用された差分を出力し、必要ならばもとに戻せるように初期状態をコミットしておくことをおすすめします。 +> コンパイラがコードを変更することに注意してください！ 安全ではある。 +> しかし、コンパイラにより適用されたコード差分を出力し、必要ならばもとに戻せるように初期状態をコミットしておくことを勧める。 > #### 良い知らせ -> - rewriteはもしコードコンパイルにエラーが有った場合は適用されません。 -> - 適用するルールを自身で決めることはできなく、コンパイラがその全てを担います。 +> - rewrite はもしコードコンパイルにエラーがあった場合は適用されない。 +> - 適用するルールを自身で決めることはできなく、コンパイラがその全てを担う。 -[非互換性テーブル](incompatibility-table.html) を参考に、Scala 3 migration rewritesのリストを確認することができます。 +[非互換性テーブル](incompatibility-table.html) を参考に、Scala 3 migration rewrites のリストを確認することが可能だ。 ## エラーの説明 -`-source:3.0-migration` モードはたくさんの変更を処理できますが、全てではありません。 -コンパイラは`-explain` および `-explain-types` オプションを呼び出すときに、残りのエラーの詳細について与えてくれます。 +`-source:3.0-migration` モードはたくさんの変更を処理できますが、全てではない。 +コンパイラは `-explain` および `-explain-types` オプションを呼ぶと、残りのエラーの詳細について与えてくれる。 -> `-explain` および `-explain-types` オプションは、移行に限定されません。 -> 一般に、Scala 3での学習とコーディングを支援します。 +> `-explain` および `-explain-types` オプションは、移行に限定したオプションではない。 +> 一般に、Scala 3 での学習とコーディングを支援するものだ。 diff --git a/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md b/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md index 2f48ddb081..b7b8f8df3e 100644 --- a/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md +++ b/_ja/overviews/scala3-migration/tooling-syntax-rewriting.md @@ -1,29 +1,29 @@ --- -title: Scala 3 シンタックスの書き換え +title: Scala 3 構文の書き換え type: chapter -description: このセクションではScala 3のシンタックス書き換え機能について説明します +description: このセクションではScala 3の構文書き換え機能について説明します num: 13 previous-page: tutorial-macro-mixing next-page: incompatibility-table language: ja --- -Scala 3では新しい制御構文と重要なインデント構文でScala言語のシンタックスが拡張されています。 -どちらもオプションであるため、Scala 2コードスタイルはScala 3でも完全に有効です。 +Scala 3 では新しい制御構文と重要なインデント構文で Scala 言語の構文が拡張されている。 +どちらもオプショナルであるため、Scala 2 コードスタイルは Scala 3でも完全に有効だ。 -制御構造の新しいシンタックスにより、括弧を囲まずに、`if`式の条件、`while`ループの条件、または`for`式のジェネレータを記述することができます。 +制御構造の新しい構文により、括弧を囲まずに、`if` 式の条件、`while` ループの条件、または `for` 式のジェネレータを記述することができる。 -重要なインデント構文として、クラスとメソッドの本体、`if`式、`match`式など、多くの場合に中括弧は不要となります。 -完全な説明はScala3リファレンスウェブサイトの[オプションナルな中括弧](https://docs.scala-lang.org/scala3/reference/other-new-features/indentation.html) ページにあります。 +重要なインデント構文として、クラスとメソッドの本体、`if`式、`match` 式など、多くの場合に中括弧は不要だ。 +完全な説明は Scala3 リファレンスウェブサイトの[オプションナルな中括弧](https://docs.scala-lang.org/scala3/reference/other-new-features/indentation.html) ページにある。 -既存のScalaコードを手動で新しい構文に変換するのは面倒で、エラーが発生しやすくなります。 -この章では、コンパイラを使用して、コードを従来のScala 2スタイルから新しいコードスタイルに、またはその逆について、自動的に書き換える方法を示します。 +既存の Scala コードを手動で新しい構文に変換するのは面倒で、エラーが発生しやすくなる。 +この章では、コンパイラを使用して、コードを従来の Scala 2 スタイルから新しいコードスタイルに、またはその逆について、自動的に書き換える方法を示す。 -## シンタックス書き換えオプション +## 構文書き換えオプション -目的を達成することが可能になるコンパイラオプションを見ましょう。 -コマンドラインで`scalac`と入力するだけで、自由に使用できる全てのオプションが出力されます。 -ここでは5つのオプションを使用します。: +自動的な構文書き換えを達成するためのコンパイラオプションを見てみよう。 +コマンドラインで `scalac` と入力するだけで、自由に使用できる全てのオプションが出力される。 +ここでは5つのオプションを使用する: {% highlight text %} $ scalac @@ -43,7 +43,7 @@ where possible standard options include: {% endhighlight %} -最初の4つのオプションはそれぞれ、特定の構文に対応しています。: +最初の4つのオプションは、それぞれ特定の構文に対応している: | Syntax | Option | | - | - | @@ -56,12 +56,12 @@ where possible standard options include: | Classical Braces | `-noindent` | -さらに詳しく説明するように、これらのオプションを`-rewrite` オプションと組み合わせて使用すると、特定の構文への変換を自動的にできます。 -小さな例を使って、このオプションがどのように機能するか見てみましょう。 +さらに詳しく説明するように、これらのオプションを `-rewrite` オプションと組み合わせて使用すると、特定の構文への変換を自動的にできる。 +小規模な例を使って、このオプションがどのように機能するか見てみよう。 -## 新しいシンタックスの書き換え +## 新しい構文の書き換え -Scala 2スタイルで書かれたコードを下記に示します。 +Scala 2 スタイルで書かれたコードを下記に示す。 ```scala case class State(n: Int, minValue: Int, maxValue: Int) { @@ -82,23 +82,23 @@ case class State(n: Int, minValue: Int, maxValue: Int) { } ``` -我々は２つのステップで自動的に新しい構文に移動させることが可能です。: まずはじめに、`-new-syntax -rewrite`オプションで新しい構文に、そして、重要なインデントに関しては`-indent -rewrite`を書きます。 +2つのステップで自動的に新しい構文に移動させることが可能だ: まずはじめに、`-new-syntax -rewrite` オプションで新しい構文に、そして、重要なインデントに関しては `-indent -rewrite` オプションを使う。 -> `-indent` オプションは既存の制御構文上では動きません。 -> なので、2つのステップを正しい順序で実行するようにしてください。 +> `-indent` オプションは既存の制御構文上では動かない。 +> なので、2つのステップを正しい順序で実行すべきだ。 -> 残念ながら、コンパイラは両方の手順を同時に適用することはできません。: `-indent -new-syntax -rewrite`. +> 残念ながら、コンパイラは両方の手順を同時に適用することはできない: `-indent -new-syntax -rewrite`. ### 新しい制御構文 -scalacのリストに追加することで `-new-syntax -rewrite` オプションを使う事ができます。 +scalac のリストに追加することで `-new-syntax -rewrite` オプションを使う事ができる。 ```scala // build.sbt scalacOptions ++= Seq("-new-syntax", "-rewrite") ``` -コンパイル後のコードは、以下のような結果に見えるでしょう: +コンパイル後のコードは、以下のような結果に見えるだろう: ```scala case class State(n: Int, minValue: Int, maxValue: Int) { @@ -119,13 +119,13 @@ case class State(n: Int, minValue: Int, maxValue: Int) { } ``` -`n == maxValue` を囲む括弧と`i <- minValue to maxValue` 及び `j <- 0 to n` ジェネレーターを囲む中括弧が表示されなくなったことに注意してください。 +`n == maxValue` を囲む括弧と `i <- minValue to maxValue` 及び `j <- 0 to n` ジェネレーターを囲む中括弧が表示されなくなったことに注意せよ。 ### 重要なインデント構文 -最初の書き換えの後、重要なインデント構文を使用して、残りの中括弧を削除できます。 -これを行うには、`-indent` オプションを`-rewrite`オプションと組み合わせて使用します。 -この組み合わせで、さらなるバージョンに導きます: +最初の書き換えの後、重要なインデント構文を使用して、残りの中括弧を削除できる。 +これを行うには、`-indent` オプションを `-rewrite` オプションと組み合わせて使用する。 +この組み合わせで、さらなる変更を与える: ```scala case class State(n: Int, minValue: Int, maxValue: Int): @@ -144,12 +144,12 @@ case class State(n: Int, minValue: Int, maxValue: Int): do println(i + j) ``` -## 従来のシンタックスに切り戻す +## 従来の構文に切り戻す -コードサンプルの最新の状態から始めて、従来の状態に戻すことができます。 +コードサンプルの最新の状態から始めて、従来の状態に戻すことができる。 -新しい制御構文を維持しながら、中括弧を使用してコードを書き直してみましょう。 -`-no-indent -rewrite`オプションを使用してコンパイルすると、次の結果が得られます。: +新しい制御構文を維持しながら、中括弧を使用してコードを書き直してみよう。 +`-no-indent -rewrite` オプションを使用してコンパイルすると、次の結果が得られる: ```scala case class State(n: Int, minValue: Int, maxValue: Int) { @@ -171,7 +171,7 @@ case class State(n: Int, minValue: Int, maxValue: Int) { } ``` -`-old-syntax -rewrite`を使用してもう1度書き換えを適用すると、元のScala2スタイルのコードに戻ります。 +`-old-syntax -rewrite` を使用してもう1度書き換えの適用を行うと、元の Scala 2 スタイルのコードに戻る。 ```scala case class State(n: Int, minValue: Int, maxValue: Int) { @@ -193,21 +193,21 @@ case class State(n: Int, minValue: Int, maxValue: Int) { } ``` -この最後の書き直しで、完全に一周しました。 +この最後の書き直しで、完全に一巡した。 > #### 構文バージョンを循環するときにフォーマットが失われる > -> [scalafmt](https://scalameta.org/scalafmt)などのフォーマットツールを使用してカスタムフォーマットをコードに適用するとき、異なるScala 3シンタックス変位で行ったり来たりすると、循環するときに差分が生じる可能性があります。 +> [scalafmt](https://scalameta.org/scalafmt)などのフォーマットツールを使用してカスタムフォーマットをコードに適用する際、異なる Scala 3 構文変位で行ったり来たりすると、循環するときに差分が生じる可能性がある。 ## 特定の構文の適用 -古い構文と新しい構文を単一のコードベースに混在させることができます。 -けれども読みやすさが低下し、コードの保守が難しくなるため、おすすめはしません。 -よりよいアプローチは一つのスタイルを選択し、コードベース全体に一貫して適用することです。 +古い構文と新しい構文を単一のコードベースに混在させることができる。 +しかし可読性が低下し、コードの保守が難しくなるため、おすすめはしない。 +よりよいアプローチは一つのスタイルを選択し、コードベース全体に一貫して適用することだ。 -`-no-indent`, `-new-syntax` と `-old-syntax` をスタンドアロンオプションとして使用して、一貫した構文を適用できます。 +`-no-indent`, `-new-syntax` と `-old-syntax` をスタンドアロンオプションとして使用して、一貫した構文を適用できる。 -たとえば、 `-new-syntax`オプションを使用すると、コンパイラは、`if`条件を囲む括弧を検出するとエラーを発行します。 +たとえば、 `-new-syntax` オプションを使用すると、コンパイラは、`if` 条件を囲む括弧を検出するとエラーを発行する。 {% highlight text %} -- Error: /home/piquerez/scalacenter/syntax/example.scala:6:7 ------------------ @@ -217,4 +217,4 @@ case class State(n: Int, minValue: Int, maxValue: Int) { |This construct can be rewritten automatically under -new-syntax -rewrite -source 3.0-migration. {% endhighlight %} -> `-indent` シンタックスは常にオプショナルです、コンパイラによって強制することはできません +> `-indent` 構文は常にオプショナルなので、コンパイラによって強制することはできない。 diff --git a/_ja/overviews/scala3-migration/tooling-tour.md b/_ja/overviews/scala3-migration/tooling-tour.md index 919e9b7619..3b9a2ac0d2 100644 --- a/_ja/overviews/scala3-migration/tooling-tour.md +++ b/_ja/overviews/scala3-migration/tooling-tour.md @@ -10,83 +10,84 @@ language: ja ## Scalaコンパイラ -移行に関して、簡単でスムーズになるように、事前に2つのコンパイラが準備されています。 +移行に関して、簡単でスムーズに行えるように、事前に2つのコンパイラが準備している。 ### Scala 2.13コンパイラ -Scala 2.13コンパイラは `-Xsource:3`をサポートしています。これは、いくつかのScala 3のシンタックスや振る舞いを可能とするオプションです。: +Scala 2.13 コンパイラは `-Xsource:3` をサポートしている。これは、一部の Scala 3 の構文や振る舞いを可能とするオプションだ: + - ほとんどの非推奨の構文はエラーを生成する。 - 中置演算子":"は、複数行の式の途中で行を開始できる。 -- Implicit searchと過負荷問題の解決は、特異性のチェック時にScala 3が共変性を扱う処理に従います。 +- Implicit search と過負荷問題の解決は、特異性のチェック時に Scala 3 が共変性を扱う処理に従う。 -`-Xsource:3`オプションは、早期の移行を促進することを目的としています。 +`-Xsource:3` オプションは、早期の移行を促進することを目的としている。 ### Scala 3コンパイラ #### 移行モード -同様にScala 3コンパイラには`-source:3.0-migration` オプションが付いています。 -このモードから、Scala 2.13のシンタックスのいくつかを許容し、変更に関する説明をWarningとして出してくれます。 +同様に Scala 3 コンパイラには `-source:3.0-migration` オプションがある。 +このモードにより、Scala 2.13 の構文の一部を許容し、変更に関する説明をWarningとして出す。 -それ以上に、`-rewrite`を使うことで自動的にコードにパッチを当ててくれます。 +さらに、`-rewrite` を使うことで自動的にコードにパッチを当ててくれる。 -上記については[Scala 3移行モード](tooling-migration-mode.html) ページで学ぶことができます。 +上記については[Scala 3移行モード](tooling-migration-mode.html) のページで学ぶことができる。 -#### シンタックス書き換え +#### 構文書き換え -一度あなたのコードをScala3でコンパイルすると、[シンタックス書き換え](tooling-syntax-rewriting.html) オプションを使うことで新しくオプションであるScala 3シンタックスに変換されます。 +一度コードを Scala3 でコンパイルすると、[構文書き換え](tooling-syntax-rewriting.html) オプションを使うことで新しくオプショナルな Scala 3 構文に変換される。 ## ビルドツール ### sbt -> sbt 1.4は`sbt-dotty` プラグインを必要としています。 -> しかし1.5以降では必要なくなりました +> sbt 1.4 ではビルドする際、 `sbt-dotty` プラグインが必要だ。 +> しかし 1.5 以降では不要になった。 -sbt 1.5はScala 3をサポートしており、全ての共通タスクと設定は同じように動くことを目的としています。 -多くのプラグインも確実に同じように動くべきです。 +sbt 1.5 は Scala 3 をサポートしており、目的は全ての共通タスクと設定は同じように動くことだ。 +多くのプラグインも確実に同じように動くべきだ。 -移行のヘルプとして、sbt 1.5が紹介している新たなScala 3のクロスバージョンがこちらです: +移行のヘルプとして、sbt 1.5 が紹介している新たな Scala 3 のクロスバージョンを示す: ```scala -// Scala 3でScala 2.13ライブラリを使用する +// Scala 3 で Scala 2.13 ライブラリを使用する libraryDependency += ("org.foo" %% "foo" % "1.0.0").cross(CrossVersion.for3Use2_13) -// Scala 2.13でScala 3ライブラリを使用する +// Scala 2.13 で Scala 3 ライブラリを使用する libraryDependency += ("org.bar" %% "bar" % "1.0.0").cross(CrossVersion.for2_13Use3) ``` ### Mill -[Mill](https://github.com/com-lihaoyi/mill) 0.9.x からScala 3をサポートしています。 +[Mill](https://github.com/com-lihaoyi/mill) 0.9.x から Scala 3 をサポートしている。 ### Maven -Scala 3 サポートに関しては [scala-maven-plugin](https://github.com/davidB/scala-maven-plugin)がもう間もなく出てくるでしょう. +Scala 3 サポートに関しては [scala-maven-plugin](https://github.com/davidB/scala-maven-plugin)がもう間もなく出てくるだろう。 ## コードエディターとIDE ### Metals -[Metals](https://scalameta.org/metals/) VSコード、Vim， Emacs， SbulimeTextやEclips上で動くScala言語サーバーです。 +[Metals](https://scalameta.org/metals/)は VS Code、Vim、Emacs、SbulimeText や Eclips 上で動く Scala 言語サーバーだ。 -Scala 3 はすでにMetalsによって大変良くサポートされています。 -いくつかの新しいシンタックス変更や新機能といったマイナーアップデートは時期にでてきます。 +Scala 3 はすでに Metals によって大変良くサポートされている。 +いくつかの新しい構文変更や新機能といったマイナーアップデートは時期にでてくる。 ### IntelliJ IDEA -InteliJ用のScalaプラグインはScala3用の予備サポートが含まれています。 -本格的なサポートはJetBrainのチームよって行われています。 +InteliJ 用の Scala プラグインは Scala3 用の予備サポートが含まれている。 +本格的なサポートは JetBrain のチームよって行われている。 ## フォーマットツール ### Scalafmt -[Scalafmt](https://scalameta.org/scalafmt/) v3.0.0-RC3 はScala 2.13とScala 3の両方サポートしています。 +[Scalafmt](https://scalameta.org/scalafmt/) v3.0.0-RC3 は Scala 2.13 と Scala 3 の両方サポートしている。 -Scala 3 フォーマットを利用可能にするために、`.scalafmt.conf`ファイルに `runner.dialect = scala3`をセットしなければならないです。 +Scala 3 フォーマットを利用可能にするためには、`.scalafmt.conf` ファイルに `runner.dialect = scala3` を設定しなければならない。 -もし、あなたが選択的に設定したい場合は`fileOverride` 設定が可能です。: +もし、選択的に設定したい場合は `fileOverride` 設定が可能だ: ```conf //.scalafmt.conf @@ -101,38 +102,40 @@ fileOverride { ### Scalafix -[Scalafix](https://scalacenter.github.io/scalafix/) はScala用のリファクタリングツールです。 -一度書いてしまえば、Scala 2.13上で実行されます。 -しかし、Scala 3にジャンプする前にコードを準備しておくと便利です。 +[Scalafix](https://scalacenter.github.io/scalafix/) は Scala 用のリファクタリングツールだ。 +一度書いてしまえば、Scala 2.13 上で実行される。 +しかし、Scala 3 に移行する前にコードを準備しておくと便利である。 + +[Incompatibility Table](incompatibility-table.html) は既存の Scalafix ルールで修正できる非互換性が表示されている。 +これまでのところ、関連するルールは以下のとおりだ -[Incompatibility Table](incompatibility-table.html) は既存のScalafixルールで修正できる非互換性が表示されています。 -これまでのところ、関連するルールは以下のとおりです。 -- [手続きシンタックス](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html) +- [手続き構文](https://scalacenter.github.io/scalafix/docs/rules/ProcedureSyntax.html) - [明示的な結果の型](https://scalacenter.github.io/scalafix/docs/rules/ExplicitResultTypes.html) -- Eta-Expansion値: `fix.scala213.ExplicitNullaryEtaExpansion` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala) +- イータ展開の値: `fix.scala213.ExplicitNullaryEtaExpansion` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNullaryEtaExpansion.scala) - Lambdaパラメータのまわりの括弧: `fix.scala213.ParensAroundLambda` in [ohze/scala-rewrites](https://github.com/ohze/scala-rewrites/blob/dotty/rewrites/src/main/scala/fix/scala213/ParensAroundLambda.scala) -- Auto Application: `fix.scala213.ExplicitNonNullaryApply` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala) +- 自動適用: `fix.scala213.ExplicitNonNullaryApply` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/ExplicitNonNullaryApply.scala) - `any2stringadd` 変換: `fix.scala213.Any2StringAdd` in [scala/scala-rewrites](https://github.com/scala/scala-rewrites/blob/main/rewrites/src/main/scala/fix/scala213/Any2StringAdd.scala) -`sbt-scalafix` プラグインを使用して、これらのルールをsbtに適用できます。 -これらは、以下で説明する `sbt-scala3-migrate` でも内部的に使用されます。 +`sbt-scalafix` プラグインを使用して、これらのルールを sbt に適用できる。 +これらは、以下で説明する `sbt-scala3-migrate` でも内部的に使用される。 ### Scala 3移行プラグイン -[Scala 3移行](https://github.com/scalacenter/scala3-migrate) は移行期間中にアシストしてくれるsbt pluginがあります。 +[Scala 3移行](https://github.com/scalacenter/scala3-migrate) は移行期間中にアシストしてくれる sbt plugin がある。 + +そのプロセスは段階的なアプローチで下記のようになる: -そのプロセスは段階的なアプローチで下記のようになっています: - ライブラリの依存関係の移行: - Scala 3で利用可能なバージョンが有るかどうか、ライブラリ依存関係ごとにチェックします. -- Scalaのコンパイルオプション(`scalacOptions`)の移行: - Scala 2のいくつかのコンパイラのオプションは除去されたか、名前が変更した、もしくはそのままのものがあります。 - このステップはあなたのプロジェクトのコンパイラのオプションに適用させるのに役立ちます。 -- シンタックスの移行: - このステップはシンタックスの非推奨を修正するためにScalafixや既存ルールに依存します。 + Scala 3 で利用可能なバージョンが有るかどうか、ライブラリ依存関係ごとにチェックする。 +- Scala のコンパイルオプション(`scalacOptions`)の移行: + Scala 2 の一部のコンパイラのオプションは廃止したか、名前を変更した、もしくはそのままのものがある。 + このステップは自身のプロジェクトのコンパイラオプションに適用させるのに役立つ。 +- 構文の移行: + このステップは構文の非推奨を修正するために Scalafix や既存ルールに依存する。 - 型を明示してコードを移行: - Scala 3はあたらしい型インタフェースのアルゴリズムをもっており、Scala 2の推論とはわずかに異なります。 - 最後のステップでは、実行時の動作を変更せずにプロジェクトをScala 3でコンパイルできるように、型の最小セットを明示します。 + Scala 3 は新規の型推論のアルゴリズムをもっており、Scala 2 の推論アルゴリズムとはわずかに異なる。 + 最後のステップでは、実行時の動作を変更せずにプロジェクトを Scala 3 でコンパイルできるように、型の最小セットを明示する。 ## Scaladex -[Scaladex](https://index.scala-lang.org/)のScala 3のオープンソースライブラリのリストをチェックしてください +[Scaladex](https://index.scala-lang.org/)の Scala 3 のオープンソースライブラリのリストをチェックしてください。 \ No newline at end of file diff --git a/_ja/overviews/scala3-migration/tutorial-intro.md b/_ja/overviews/scala3-migration/tutorial-intro.md index 564ac0d0eb..8ec61d6e19 100644 --- a/_ja/overviews/scala3-migration/tutorial-intro.md +++ b/_ja/overviews/scala3-migration/tutorial-intro.md @@ -1,22 +1,22 @@ --- title: 移行チュートリアル type: chapter -description: この章はScala 2.13 projectをScala 3へ移行するチュートリアルを含みます +description: この章はScala 2.13 project を Scala 3 へ移行するチュートリアルを含みます num: 8 previous-page: tooling-migration-mode next-page: tutorial-prerequisites language: ja --- -Scala 3の移植の準備をしましょう！ +Scala 3 の移植の準備をしよう！ -最初のステップはプロジェクトの[前提条件](tutorial-prerequisites.html)を満たしていることを確認することです。 -次に、あなたが移行ワークフローについて[sbtプロジェクトの移行](tutorial-sbt.html) で学ぶことができます。 +移植の最初のステップはプロジェクトの[前提条件](tutorial-prerequisites.html)を満たしているかを確認することだ。 +次に、移行ワークフローについて、[sbtプロジェクトの移行](tutorial-sbt.html) で学ぶことができる。 -> **sbtを使ってない？** +> **sbtを使用していない？** > -> ワークフローが非常に似ていることから、[sbtプロジェクトの移行](tutorial-sbt.html)で学ぶことを強く助言します。 -> その前に、ビルドツールがScala 3対応しているバージョンか確認してください。 +> 移行ワークフローが非常に似ていることから、[sbtプロジェクトの移行](tutorial-sbt.html)で学ぶことを強くおすすめする。 +> その前に、ビルドツールが Scala 3 対応しているバージョンかを確認してください。 -[Cross-Building a Macro Library](tutorial-macro-cross-building.html) と [Mixing Scala 2.13 and Scala 3 Macros](tutorial-macro-mixing.html) ではScala 2マクロライブラリの移植をするための特別なチュートリアルです。 +[Cross-Building a Macro Library](tutorial-macro-cross-building.html) と [Mixing Scala 2.13 and Scala 3 Macros](tutorial-macro-mixing.html) では Scala 2 マクロライブラリの移植をするための特別なチュートリアルだ。 diff --git a/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md b/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md index ec229d213e..dd2f80382f 100644 --- a/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md +++ b/_ja/overviews/scala3-migration/tutorial-macro-cross-building.md @@ -8,17 +8,17 @@ next-page: tutorial-macro-mixing language: ja --- -マクロライブラリは0から再実装しなければなりません。 +マクロライブラリはゼロから再実装しなければならない。 -開始する前に[sbtプロジェクトの移行](tutorial-sbt.html)チュートリアルに記載しているScala3移行について理解しておく必要があります。 -このチュートリアルの目的としては、既存のScala 2.13のマクロライブラリをクロスビルドしScala 3とScala 2.13の両方で使用するためことです。 +開始する前に[sbtプロジェクトの移行](tutorial-sbt.html)チュートリアルに記載している Scala3 移行について理解しておく必要がある。 +このチュートリアルの目的は、既存の Scala 2.13 のマクロライブラリをクロスビルドし Scala 3 と Scala 2.13 の両方で使用することである。 -代替手法としてはマクロミクシングは[次のチュートリアル](tutorial-macro-mixing.html)で説明します。 -両方のソリューションを読んで、ニーズに最適な手法を選択することをおすすめします。 +代替手法としてはマクロミクシングは[次のチュートリアル](tutorial-macro-mixing.html)で説明する。 +両方の代替手法を読み、必要に合わせて最適な手法を選択することをおすすめする。 ## 導入 -このチュートリアルを例証するために、最小限のマクロライブラリの定義を下記で考えます。 +このチュートリアルを例証するために、最小限のマクロライブラリの定義を下記に示す。 ```scala // build.sbt @@ -54,27 +54,28 @@ object Macros { } ``` -ライブラリとのいくつかの類似点を認識する必要があります。: -一つ以上のマクロメソッド（この場合は`location`メソッド）はマクロコンテキストとこの`Context`からの`Tree`を返すことで実装されています。 +ライブラリとのいくつかの類似点を認識する必要がある: +例示したマクロメソッド（この場合は `location` メソッド）はマクロコンテキストを引数に、`Context` からの `Tree` を返すように実装されている。 -sbtが提供する[クロスビルディング手法](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)を使用して、このライブラリをScala 3ユーザが利用できるように吸うことができます。 +sbt が提供する[クロスビルディング手法](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)を使用して、このライブラリを Scala 3 ユーザが利用できるように扱うことができる。 -主要なアイデアは、アーティファクトを2回ビルドし、2つのリリース物を公開することです。: -- `example_2.13` はScala 2.13ユーザ用 -- `example_3` はScala 3ユーザ用 +主なアイデアとして、アーティファクトを2回ビルドし、2つのリリース物を公開することです。: + +- `example_2.13` は Scala 2.13 ユーザ用 +- `example_3` は Scala 3 ユーザ用 ![Cross-building Architecture](/resources/images/scala3-migration/tutorial-macro-cross-building.svg) ## 1. クロスビルディングの設定 -Scala 3に `crossScalaVersions` のリストを追加することができます。: +Scala 3 に `crossScalaVersions` のリストを追加することができる: ```scala crossScalaVersions := Seq("2.13.6", "3.0.0") ``` -`scala-reflect` の依存関係はScala 3では役に立ちません。 -次のような条件で条件付き削除を行います。: +`scala-reflect` の依存関係は Scala 3 では役に立たない。 +次のような条件で条件付き削除を行う: ```scala // build.sbt @@ -88,12 +89,12 @@ libraryDependencies ++= { } ``` -sbtの再起動後、`++3.0.0`を動かすことで、Scala 3コンテキストにスイッチできます。 -`++2.13.6`を実行するといつでもScala 2.13コンテキストに戻ることができます。 +sbt の再起動後、`++3.0.0` を動かすことで、Scala 3 コンテキストにスイッチできる。 +`++2.13.6` を実行するといつでも Scala 2.13 コンテキストに戻ることができる。 ## 2. バージョン固有のソースディレクトリでコードを再配置 -Scala 3でコンパイルしようとすると、あなたはいくつかの種類のエラーに遭遇するでしょう: +Scala 3 でコンパイルしようとすると、いくつかの種類のエラーに遭遇するだろう: {% highlight text %} sbt:example> ++3.0.0 @@ -109,13 +110,13 @@ sbt:example> example / compile [error] |To turn this error into a warning, pass -Xignore-scala2-macros to the compiler {% endhighlight %} -Scala 2の実装を維持しながらScala 3の代替手段を提供するために、バージョン固有のソースディレクトリでコードを再配置します。 -Scala 3コンパイラでコンパイルできないすべてのコードは、`src/main/scala-2` フォルダに移動します。 +Scala 2 の実装を維持しながら Scala 3 への代替手段を提供するために、バージョン固有のソースディレクトリでコードを再配置する。 +Scala 3 コンパイラでコンパイルできないすべてのコードは、`src/main/scala-2` フォルダに移動する。 -> Scalaのバージョン固有のソースディレクトリは、デフォルトで利用できるsbt機能です。 -> 詳細については[sbt documentation](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)で学ぶことができます。 +> Scala のバージョン固有のソースディレクトリは、デフォルトで利用できるsbt 機能だ。 +> 詳細については[sbt documentation](https://www.scala-sbt.org/1.x/docs/Cross-Build.html)で学ぶことができる。 -例として、`Location` クラスは`src/main/scala`フォルダに残りますが、`Macros` オブジェクトは`src/main/scala-2` フォルダに移動します。: +例では、`Location` クラスは `src/main/scala` フォルダに残るが、`Macros` オブジェクトは `src/main/scala-2` フォルダに移動する: ```scala // example/src/main/scala/location/Location.scala @@ -144,8 +145,8 @@ object Macros { } ``` -これで我々は`src/main/scala-3`フォルダにあるScala 3マクロ定義をそれぞれ初期化できます。 -それらは、Scala 2.13の対応物と全く同じシグネチャーを持っている必要があります。 +これで `src/main/scala-3` フォルダにある Scala 3 マクロ定義をそれぞれ初期化できる。 +ただし、Scala 2.13 の対応物と全く同じシグネチャーを持っている必要がある。 ```scala // example/src/main/scala-3/location/Macros.scala @@ -155,12 +156,12 @@ object Macros: def location: Location = ??? ``` -## 3. Scala 3マクロの実装 +## 3. Scala 3 マクロの実装 -Scala2マクロをScala3に移植するための魔法の公式はありません。 -新しい[メタプログラミング](compatibility-metaprogramming.html)機能について学ぶ必要があります。 +Scala 2 マクロを Scala 3 に移植するための魔法の公式は存在しない。 +新しい[メタプログラミング](compatibility-metaprogramming.html)機能について学ぶ必要がある。 -最終的に、この実装を思いつきます。: +最終的に、この実装を思いつくとする: ```scala // example/src/main/scala-3/location/Macros.scala @@ -181,9 +182,9 @@ object Macros: ## 4. マクロの交差検証 -いくつかのテストを加えることはマクロメソッドが両方のScalaのバージョンで動くかどうかの確認に重要です。 +いくつかのテストを加えることはマクロメソッドが両方の Scala のバージョンで動くかどうかの確認に重要だ。 -例として、一つのテストを追加します。 +例として、一つのテストを追加する。 ```scala // example/src/test/scala/location/MacrosSpec.scala @@ -196,7 +197,7 @@ class MacrosSpec extends munit.FunSuite { } ``` -あなたは両方のバージョンでテストを実行できるようになります。 +これで両方のバージョンでテストを実行できるようになる。 {% highlight text %} sbt:example> ++2.13.6 @@ -215,14 +216,15 @@ location.MacrosSpec: ## さいごに -あなたのマクロプエオジェクトは現在以下のソースファイルが含まれているでしょう: +あなたのプロジェクトは現在以下のソースファイルが含まれているだろう: - `src/main/scala/*.scala`: クロスコンパイルクラス群 -- `src/main/scala-2/*.scala`: Scala 2で実装されたマクロメソッド -- `src/main/scala-3/*.scala`: Scala 3で実装されたマクロメソッド +- `src/main/scala-2/*.scala`: Scala 2 で実装されたマクロメソッド +- `src/main/scala-3/*.scala`: Scala 3 で実装されたマクロメソッド - `src/test/scala/*.scala`: テスト ![Cross-building Architecture](/resources/images/scala3-migration/tutorial-macro-cross-building.svg) -これで、2つのリリースを作ることによってライブラリ公開の準備ができました: +これで、2つのリリース物を作ることにより、ライブラリ公開の準備ができた: + - `example_2.13` はScala 2.13ユーザ用 - `example_3` はScala 3ユーザ用 diff --git a/_ja/overviews/scala3-migration/tutorial-macro-mixing.md b/_ja/overviews/scala3-migration/tutorial-macro-mixing.md index fff362ddb8..81f7805eef 100644 --- a/_ja/overviews/scala3-migration/tutorial-macro-mixing.md +++ b/_ja/overviews/scala3-migration/tutorial-macro-mixing.md @@ -1,26 +1,26 @@ --- -title: Scala 2.13とScala 3マクロのミクシング +title: Scala 2.13 と Scala 3 マクロの mixing type: section -description: このセクションはScala 2.13とScala 3マクロの単一アーティファクトでのミクシングについて示します +description: このセクションはScala 2.13とScala 3マクロの単一アーティファクトでの mixing について示します num: 12 previous-page: tutorial-macro-mixing next-page: tooling-syntax-rewriting language: ja --- -このチュートリアルでは、Scala 2.13とScala 3マクロを単一アーティファクトでミックスする方法をお見せします。 +このチュートリアルでは、Scala 2.13 と Scala 3 マクロを単一アーティファクトで mixing する方法を見せる。 -これを使用して、新しいScala 3マクロライブラリを作り、それをScala 2.13ユーザでも利用可能にすることができます。 -それだけでなく、既存のScala 2.13マクロライブラリをScala 3に移植することも可能ですが、おそらくクロスビルドのほうが簡単です。 +この手法を用いて、新しい Scala 3 マクロライブラリを作り、それをScala 2.13 ユーザでも利用可能にする。 +それだけでなく、既存の Scala 2.13 マクロライブラリも Scala 3 に移植することは可能だが、その場合この手法よりクロスビルドのほうが簡単だ。 ## 導入 -Scala 2.13コンパイラはSala 2.13マクロを展開することができ、逆に、Scala 3コンパイラはScala 3マクロを展開することができます。 -マクロミクシングのアイデアは単一アーティファクトにある両方のマクロをパッケージ化し、マクロ展開のフェーズでコンパイラーに2つから選択させることです。 +Scala 2.13 コンパイラは Sala 2.13 マクロを展開することができ、逆に、Scala 3 コンパイラは Scala 3 マクロを展開することができる。 +mixing macro のアイデアは単一アーティファクトにある両方のマクロをパッケージ化し、マクロ展開のフェーズでコンパイラーに2つから選択させることだ。 -これはScala 3だけ可能で、なぜならScala 3のコンパイラはScala 2とScala 3の両方とも定義を読むことができるからです。 +これは Scala 3 だけ可能で、なぜなら Scala 3 のコンパイラは Scala 2 と Scala 3 の両方の定義を読むことができるからだ。 -以下のコードスケルトンで実際に考えてみましょう: +以下のコードスケルトンで実際に考えてみよう: ```scala // example/src/main/scala/location/Location.scala @@ -33,19 +33,20 @@ object Macros: inline def location: Location = ${ ??? } ``` -見ての通り、`location` マクロの定義は2つあります。: -- `def location: Location = macro ???` はScala 2.13マクロ定義です -- `inline def location: Location = ${ ??? }` はScala 3マクロ定義です。 +見ての通り、`location` マクロの定義は2つある: -`location` はオーバーロードされたメソッドではないです、なぜなら2つのシグネチャーは厳密には同一だからです。 -これは非常に驚くべきことです！ -コンパイラは同じ名前とシグネチャーを持つ2つのメソッドをどのように受け入れるのでしょうか？ +- `def location: Location = macro ???` は Scala 2.13 マクロ定義 +- `inline def location: Location = ${ ??? }` は Scala 3 マクロ定義 -現状のまとめとしては、最初の定義はScala 2.13のみであり、2番目の定義はScala 3のみであるということです。 +`location` はオーバーロードされたメソッドではない。なぜなら2つのシグネチャーは厳密には同一だからだ。 +これは非常に驚くべきことだ！ +コンパイラは同じ名前とシグネチャーを持つ2つのメソッドをどのように受け入れるのだろうか？ -## 1. Scala　3マクロの実装 +現状のまとめとしては、最初の定義は Scala 2.13 のみであり、2番目の定義は Scala 3 のみであるということだ。 -Scala3マクロ実装を定義の横に置くことができます。 +## 1. Scala 3 マクロの実装 + +Scala 3 マクロ実装を定義の横に配置できる。 ```scala package location @@ -65,11 +66,12 @@ object Macros: '{new Location($file, $line)} ``` -## 2. Scala　2マクロの実装 +## 2. Scala 2 マクロの実装 + +Scala 3 コンパイラは、ダブルクォートや reification が含まれていない場合、Scala 2 マクロ実装のコンパイルは可能だ。 -Scala 3コンパイラは, ダブルクォートまたは、reificationが含まれていない場合、Scala 2マクロ実装はコンパイルできます +たとえば、このコードは Scala 3 でコンパイルされるため、Scala 3 の実装と一緒に配置できる。 -たとえば、このコードはScala 3でコンパイルされるため、Scala 3の実装と一緒に配置できます。 ```scala import scala.reflect.macros.blackbox.Context @@ -81,7 +83,7 @@ def locationImpl(c: Context): c.Tree = { } ``` -しかしながら、多くのケースであなたはScala 2.13マクロ実装をScala 2.13サブモジュールに移動しなければならないでしょう。 +しかしながら、多くのケースで Scala 2.13 マクロ実装を Scala 2.13サブモジュールに移動しなければならないだろう。 ```scala // build.sbt @@ -99,9 +101,9 @@ lazy val `example-compat` = project.in(file("example-compat")) ) ``` -このような`example`では, この例では、Scala 3でコンパイルされたメインライブラリは、Scala 2.13でコンパイルされた`example-compat`に依存しています。 +この例の、`example` に関して、Scala 3 でコンパイルされたメインライブラリは、Scala 2.13でコンパイルされた `example-compat` に依存している。 -このような場合、Scala 2マクロの実装を`example-compat`にいれて、ダブルクォートを使用できます。 +このような場合、Scala 2 マクロの実装を `example-compat` にいれて、ダブルクォートを使用できる。 ```scala package location @@ -122,13 +124,13 @@ object Scala2MacrosCompat { } ``` -`Location`クラスを下流に移動させる必要があることに注意してください。 +`Location` クラスを下流に移動させる必要があることに注意してください。 ## 3. マクロの交差検証 -いくつかのテストを加えることはマクロメソッドが両方のScalaのバージョンで動くかどうかの確認に重要です。 +いくつかのテストを加えることはマクロメソッドが両方の Scala のバージョンで動くかどうかの確認に重要である。 -Scala 2.13とScala 3で実行したいので、クロスビルドモジュールを作ります。: +Scala 2.13 と Scala 3 で実行したいので、クロスビルドモジュールを作る: ```scala // build.sbt @@ -147,9 +149,10 @@ lazy val `example-test` = project.in(file("example-test")) .dependsOn(example) ``` -> `-Ytasty-reader`はScala 3アーティファクトを消費するためにScala 2.13上で必要です +> `-Ytasty-reader` は Scala 3 アーティファクトを消費するために Scala 2.13 上で必要だ + +例えば、テストは次のようになる: -例えば、テストは次のようになります。: ```scala // example-test/src/test/scala/location/MacrosSpec.scala package location @@ -161,7 +164,7 @@ class MacrosSpec extends munit.FunSuite { } ``` -これで両方のバージョンでテスト可能のはずです。 +これで両方のバージョンでテスト可能のはずだ。 {% highlight text %} sbt:example> ++2.13.6 @@ -180,16 +183,17 @@ location.MacrosSpec: ## さいごに -現在のライブラリの構成です: -- メインのScala 3モジュールはScala 3マクロ実装とミクシングしたマクロ定義が含まれています。 -- Scala 2.13の互換性のあるモジュールはScala 2.13マクロ実装を含んでいます。 -これは、コンパイラのマクロ展開フェーズでScala 2.13により消費されるでしょう +現在のライブラリの構成である: + +- メインの Scala 3 モジュールは Scala 3 マクロ実装と mixing したマクロ定義が含まれている。 +- Scala 2.13 の互換性のあるモジュールは Scala 2.13 マクロ実装を含んでいる。 +これは、コンパイラのマクロ展開フェーズで Scala 2.13 により消費されるだろう。 ![Mixing-macros Architecture](/resources/images/scala3-migration/tutorial-macro-mixing.svg) -これでライブラリを公開する準備ができました。 +これでライブラリを公開する準備ができた。 -Scala 3プロジェクトで利用可能ですし、または次の設定のScala 2.13プロジェクトでも利用できます。: +Scala 3 プロジェクトで利用可能であり、次の設定の Scala 2.13 プロジェクトでも利用可能だ: ```scala scalaVersion := "2.13.6" diff --git a/_ja/overviews/scala3-migration/tutorial-prerequisites.md b/_ja/overviews/scala3-migration/tutorial-prerequisites.md index 6b8c27242e..03c668aa63 100644 --- a/_ja/overviews/scala3-migration/tutorial-prerequisites.md +++ b/_ja/overviews/scala3-migration/tutorial-prerequisites.md @@ -1,50 +1,53 @@ --- title: 前提条件 type: section -description: このセクションはScala 3への移行の前提条件について詳細化します +description: このセクションは Scala 3 への移行の前提条件について詳細化します num: 9 previous-page: tutorial-intro next-page: tutorial-sbt language: ja --- -[互換性リファレンス](compatibility-intro.html)のページで示したように、Scala 3への移行に関してはScala 2.13とScala 3の相互互換性のおかげで容易であります。 +[互換性リファレンス](compatibility-intro.html)のページで示したように、Scala 3 への移行に関しては Scala 2.13 と Scala 3 の相互互換性のおかげで容易だ。 -しかしながら、Scala 3移植を始める前にかならず確認しなければならないScala 2.13プロジェクトの前提条件があります。: -- Scala 3にまだ移植されていないマクロライブラリに依存してはなりません -- Scala 3に同等のものがないコンパイラプラグインを使用してはなりません -- `scala-reflect`に依存してはなりません. +しかし、Scala 3 移植を始める前にかならず確認しなければならない Scala 2.13 プロジェクトの前提条件がある: -次の段落では、これらの前提条件を確認する方法と、それらが満たされていな場合の対処方法について説明します。 +- Scala 3 にまだ移植されていないマクロライブラリに依存してはならない +- Scala 3 に同等のものがないコンパイラプラグインを使用してはならない +- `scala-reflect` に依存してはならない -移植を続行する準備ができたら[sbt移行チュートリアル](tutorial-sbt.html)にジャンプできます。 +次の段落では、これらの前提条件を確認する方法と、満たされていない場合の対処方法について説明する。 + +移植作業を続ける準備ができたら[sbt移行チュートリアル](tutorial-sbt.html)に飛ぶことができる。 ## マクロの依存 -マクロライブラリはScalaのライブラリでマクロメソッドを公開しています。 +マクロライブラリは Scala のライブラリでマクロメソッドを公開している。 + +それらのライブラリは Scala 2 で幅広く使われている。 +例えば: -それらのライブラリはScala 2で幅広く使われています。 -例えば、: - [lightbend/scala-logging](https://index.scala-lang.org/lightbend/scala-logging) - [milessabin/shapeless](https://index.scala-lang.org/milessabin/shapeless) - [playframework/play-json](https://index.scala-lang.org/playframework/play-json) - [scalatest/scalatest](https://index.scala-lang.org/scalatest/scalatest) -しかしScala 3コンパイラはScala 2.13のマクロを展開することができません。 -なので、Scala3にジャンプする前に、あなたは移植されていないマクロライブラリに依存していないかを確認する必要があります。 +しかし Scala 3 コンパイラは Scala 2.13 のマクロを展開することができない。 +だから、Scala3 に移行する前に、移植されていないマクロライブラリに依存していないかを確認する必要がある。 + +多くのマクロの移行状態を[Scala Macro Libraries](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html) ページで確認することができる。 +幸いなことに、たくさんのライブラリはこの行を読むまでに移植されているだろう。 -あなたはたくさんのマクロの移行状態を[Scala Macro Libraries](https://scalacenter.github.io/scala-3-migration-guide/docs/macros/macro-libraries.html) ページで確認することができます。 -幸いなことにたくさんのライブラリはこの行を読むまでに移植されているでしょう。 +プロジェクト内のマクロの依存ごとに、クロスビルドバージョン、即ち Scala 2.13 と Scala 3 の両方で使用可能なバージョンにアップグレードする必要がある。 -プロジェクト内のこれらのマクロ依存ごとに、クロスビルドバージョン、すなわちScala 2.13とScala 3の両方で使用可能なバージョンにアップグレードする必要があります。 +いくつか例を上げてみる。 -いくつか例を上げてみましょう +`"scalatest" %% "scalatest" % "3.0.9"` への依存関係は、次の理由でアップグレードする必要がある: -`"scalatest" %% "scalatest" % "3.0.9"` への依存関係は、次の理由でアップグレードする必要があります。: -- `scalatest` API は一部のマクロ定義がベースになっているから。 -- `3.0.9` バージョンはScala 3用にパブリッシュされていないから. +- `scalatest` API は一部のマクロ定義がベースになっている。 +- `3.0.9` バージョンは Scala 3 用に公開されていない。 -`3.2.7`までアップグレードする必要があり、そしてそれは、Scala 2.13とScala 3のクロス公開されています。 +`3.2.7` までバージョンアップグレードする必要があり、このバージョンでは、Scala 2.13 と Scala 3 の両方で公開されている。 ```scala libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.7" @@ -52,9 +55,9 @@ libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.7" ## コンパイラプラグイン -Scala 2のコンパイラプラグインはScala 3との互換性がありません。 +Scala 2 のコンパイラプラグインは Scala 3 との互換性がない。 -コンパイラプラグインは一般的に`build.sbt`ファイルに設定されていて一つにまとまっています。: +コンパイラプラグインは一般的に `build.sbt` ファイルに設定されていて一つにまとまっている: ```scala // build.sbt @@ -64,9 +67,9 @@ libraryDependencies += addCompilerPlugin("org.typelevel" %% "kind-projector" % "0.11.0" cross CrossVersion.full) ``` -一部のコンパイラプラグインは自動的にsbtプラグインによって追加されるでしょう。 +一部のコンパイラプラグインは自動的に sbt プラグインによって追加されるだろう。 -自身のプロジェクトのコンパイラオブションを見ることによって設定されているプラグインを見つけることができるでしょう。 +自身のプロジェクトのコンパイラオブションを確認することで設定されているプラグインを見つけることが可能だろう。 {% highlight text %} sbt:example> show example / Compile / scalacOptions @@ -76,25 +79,26 @@ sbt:example> show example / Compile / scalacOptions [info] * -P:semanticdb:targetroot:/example/target/scala-2.13/meta {% endhighlight %} -上記の例では、wartremoverとsemanticdbの2つのコンパイラプラグインが使用されていることがわかります。 -これらのプラグインごとに、代替ソリューションがあることを確認するか、無効にする必要があります。 +上記の例では、wartremover と semanticdb の2つのコンパイラプラグインが使用されている。 +これらのプラグインごとに、代替方法があることを確認するか、無効にする必要がある。 -最もよく使用されるコンパイラプラグインの代替ソリューションを以下に示します。 +最もよく使用されるコンパイラプラグインの代替方法を以下に示す。 ### SemanticDB -[SemanticDB](https://scalameta.org/docs/semanticdb/guide.html) は現在Scala 3コンパイラに同梱されています。 +[SemanticDB](https://scalameta.org/docs/semanticdb/guide.html) は現在 Scala 3 コンパイラに同梱されている : -- `-Ysemanticdb` オプションはsemanticDBファイルを生成します。 -- `-semanticdb-target` オプションはsemanticDBファイルの出力ディレクトリを指定できます。 -sbtは`semanticdbEnabled := true`という単一の設定で、semanticDB設定を自動的に構成できます。 +- `-Ysemanticdb` オプションは semanticDB ファイルを生成する。 +- `-semanticdb-target` オプションは semanticDB ファイルの出力ディレクトリを指定できる。 + +sbt は `semanticdbEnabled := true` という単一設定で、semanticDB の設定を自動的に構成する。 ### Scala.js -Scala3上での[Scala.js](https://www.scala-js.org/) コンパイルはコンパイラプラグインに依存していないです。 +Scala3 上での [Scala.js](https://www.scala-js.org/) コンパイルはコンパイラプラグインに依存していない。 -Scala.jsプロジェクトをコンパイルするには`sbt-scalajs`プラグインバージョン`1.5.0`以上だと使用できます。 +Scala.js プロジェクトをコンパイルするには `sbt-scalajs` プラグインバージョン `1.5.0` 以上が必要である。 ```scala // project/plugins.sbt @@ -103,27 +107,27 @@ addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.5.0") ### Scala Native -Scala 3 はまだ[Scala Native](https://scala-native.readthedocs.io/en/latest/)をサポートしていません。 +Scala 3 はまだ[Scala Native](https://scala-native.readthedocs.io/en/latest/)をサポートしていない。 -もしScala Nativeにクロスビルドできていれば、Scala3移植は可能です。 -しかしまだNativeプラットフォーム用にコンパイルはできません。 +もし Scala Native がクロスビルドできれば、Scala3 移植は可能だ。 +しかし、まだ Native プラットフォーム用にコンパイルはできない。 ### Kind Projector -[the Kind Projector](https://github.com/typelevel/kind-projector) シンタックスの一部はScala 3の`-Ykind-projector` オプションによりサポートされています。 +[the Kind Projector](https://github.com/typelevel/kind-projector) 構文の一部は Scala 3 の `-Ykind-projector` オプションによりサポートされている。 + +加えて、多くの場合で `kind-projector` を不要にする機能がある: -加えて、多くの場合`kind-projector`を不要にする次の機能があります。: - [Type Lambdas](http://dotty.epfl.ch/docs/reference/new-types/type-lambdas.html) - [Polymorphic Functions](http://dotty.epfl.ch/docs/reference/new-types/polymorphic-function-types.html) - [Kind Polymorphism](http://dotty.epfl.ch/docs/reference/other-new-features/kind-polymorphism.html) -Kind Projectorの移行を学びたい方は [dedicated page](plugin-kind-projector.html)に。 +Kind Projector の移行について学びたい方は [dedicated page](plugin-kind-projector.html)に示されている。 ## Runtime reflection +`scala-reflect` は Scala3 に移植されないだろう。なぜなら Scala 3 には存在しない Scala 2 コンパイラの内部展開があるからだ。 -`scala-reflect` Scala3に移植されないでしょう、なぜならScala 3には存在しないScala 2コンパイラの内部展開をするからです。 - -もしあなたのプロジェクトが `scala-reflect`に依存している、または `Manifest`クラスのインスタンスを使用している場合、Scala 3コンパイラでコンパイルできません -この状況を改善する位は、Javaリフレクヨンまたは[Scala 3メタプログラミング機能](compatibility-metaprogramming.html)を使用して、コードの対応する部分を再実装してみてください。 +もしプロジェクトが `scala-reflect` に依存している、または `Manifest` クラスのインスタンスを使用している場合、Scala 3 コンパイラではコンパイルできない。 +この状況を打破するには、Java リフレクションまたは[Scala 3メタプログラミング機能](compatibility-metaprogramming.html)を使用して、再実装してください。 -`scala-reflect` がクラスパスに推移的に追加されている場合は、それをもたらす依存関係自体をアップグレードする必要があります。 +`scala-reflect` がクラスパスに推移的に追加されている場合は、それらの依存関係自体もアップグレードする必要がある。 diff --git a/_ja/overviews/scala3-migration/tutorial-sbt.md b/_ja/overviews/scala3-migration/tutorial-sbt.md index e26f4af61f..7c52256a3f 100644 --- a/_ja/overviews/scala3-migration/tutorial-sbt.md +++ b/_ja/overviews/scala3-migration/tutorial-sbt.md @@ -1,48 +1,50 @@ --- title: sbtプロジェクトの移行 type: section -description: このセクションはsbtプロジェクトの移行方法について示します +description: このセクションは sbt プロジェクトの移行方法について示します。 num: 10 previous-page: tutorial-prerequisites next-page: tutorial-macro-cross-building language: ja --- -> このチュートリアルでは、sbtについて記述しています。 -> といっても、Scala 3をサポートしてる限り、移行のアプローチは他のビルドツールと非常に似ています。 +> このチュートリアルでは、sbt について記述する。 +> といっても、Scala 3 をサポートしてる限り、移行のアプローチは他のビルドツールと非常に似ている。 -Scala3にジャンプする前に、最新版のScala 2.13.xとsbt 1.5.xであることを確認しましょう。 +Scala3 に移行する前に、最新版の Scala 2.13.x と sbt 1.5.x であることを確認すべきだ。 -それでは、プロジェクト全体をScala 3に移植するために必要な手順を見ていきましょう。 +それでは、プロジェクト全体を Scala 3 に移植するために必要な手順を見ていこう。 ## 1. プロジェクトの前提をチェック -プロジェクトが移行されるかの確認をしましょう: -- Scala 3にまだ移植されていないマクロライブラリに依存してはなりません。 -- Scala 3に同等のものがないコンパイラプラグインは使用してはなりません。 -- `scala-reflect`に依存してはなりません。 +プロジェクトが移行可能かの確認しよう: -これらの前提に関しては、[前のページ](tutorial-prerequisites.html)で詳しく話しています。 +- Scala 3 にまだ移植されていないマクロライブラリに依存してはならない。 +- Scala 3 に同等のものがないコンパイラプラグインは使用してはならない。 +- `scala-reflect` に依存してはならない。 + +これらの前提に関しては、[前のページ](tutorial-prerequisites.html)で詳しく話している。 ## 2. モジュールを選択する -Scala 2.13とScala 3の相互互換性のおかげで、あなたは全てのモジュールからでも移行を開始することができます。 -しかしながら、依存関係が最も少ないモジュールから始めるほうがおそらく簡単です。 +Scala 2.13 と Scala 3 の相互互換性のおかげで、全てのモジュールからでも移行を開始することができる。 +しかし、依存関係が最も少ないモジュールから始めるほうがおそらく簡単である。 -もしあなたがマクロ定義やマクロアノテーションを内部的に使っているのであれば、そこを始めに移植する必要があります。 +もし自身のプロジェクトでがマクロ定義やマクロアノテーションを内部的に使っているのであれば、そこを始めに移植する必要がある。 ## 3. クロスビルドのセットアップ -コードベースの移行の2つの主な課題は次のとおりです。: +コードベースの移行の2つの主な課題は次のとおりだ: + - コードコンパイルする - 実行時の動作で変更がされていないことの確認をする -クロスビルド戦略をおすすめしており、Scala 3とScala 2.13の両方でコンパイルすることです。 -背後にあるロジックは修正のたびにScala 2.13でテストを実行できるようにすることです。 -これにより、実行時の動作が変更されていなことを確認ですることができます。 -これは、非互換性を修正するときに発生する可能性のあるバグを回避するために重要です。 +クロスビルド戦略を勧めており、それは Scala 3 と Scala 2.13 の両方でコンパイルすることだ。 +背後にあるロジックは修正のたびに Scala 2.13 でテストを実行できるようにするべきだ。 +これにより、実行時の動作が変更されていなことを確認ですることができる。 +これは、非互換性を修正するときに発生する可能性のあるバグを回避するために重要である。 -sbtのクロスビルディング設定は以下の様にまとめられます。: +sbt のクロスビルディング設定は以下にまとめられる: ```scala scalaVersion := "3.0.0" @@ -50,45 +52,46 @@ crossScalaVersions ++= Seq("2.13.6", "3.0.0") ``` この設定の意味は: + - デフォルトバージョンは `3.0.0`。 -- 2.13.6 は `++2.13.6` コマンドを走らすことによってロードされます。 -- 3.0.0 は `++3.0.0` コマンドを走らすことによってロードされます。 +- 2.13.6 は `++2.13.6` コマンドを走らすことによってロードされる。 +- 3.0.0 は `++3.0.0` コマンドを走らすことによってロードされる。 -`reload` コマンドは常にデフォルトバージョンをロードすることに気をつけましょう、ここでは 3.0.0です。 +`reload` コマンドは常にデフォルトバージョンをロードすることに気をつけるべきで、ここでは 3.0.0 だ。 ## 4. 依存に対する準備 -このステージで、もしあなたが `compile`を走らせると, sbtが一部の依存関係が見つからないということについて忠告してくる可能性があります。 -これは依存関係の宣言されたバージョンがScala 3に対して公開されていないためです。 +この段階で、`compile` を走らせると, sbt が一部の依存関係が見つからないということについて忠告してくるかもしれない。 +これは依存関係の宣言されたバージョンが Scala 3 に対して公開されていないためだ。 -依存関係を新しいバージョンにアップグレードするか、ライブラリのScala 2.13 バージョンを使用するようにsbtに指示する必要があります。 +依存関係を新しいバージョンにアップグレードするか、ライブラリの Scala 2.13 バージョンを使用するように sbt に指示する必要がある。 -> ライブラリの依存関係を変更するときは、プロジェクトのすべてのモジュールに同じ変更を適用してください。 +> ライブラリの依存関係を変更するときは、プロジェクトのすべてのモジュールに同じ変更を適用する必要がある。 -ライブラリの利用可能なScala3バージョンがあるかどうかを確認します。 -これを行うには、[Scaladex](https://index.scala-lang.org/)のバージョンマトリックスを使用できます。 -ライブラリのプロジェクトページに移動し、バージョンマトリックスボタンをクリックして、Scala 3とScala 2.13でフィルター処理します。 +ライブラリの利用可能なScala3バージョンがあるかどうかを確認する。 +これを行うには、[Scaladex](https://index.scala-lang.org/)のバージョンマトリックスが使用できる。 +ライブラリのプロジェクトページに移動し、バージョンマトリックスボタンをクリックして、Scala 3 と Scala 2.13 でフィルター処理を行う。 #### 1. ライブラリにScala3バージョンが有る場合 -我々は強く利用可能なバージョンを使うことを提案します。 -ただ、選択したものが破壊的変更をもたらさないことは確認してください。 +利用可能なバージョンを使うことを強く勧める。 +ただ、選択したものが破壊的変更をもたらさないことは確認すべきだ。 #### 2. ライブラリにScala3バージョンがない場合 -あなたはScala2.13のバージョンのライブラリを使うことができます。 そのときのシンタックスは以下のようになります。: +Scala2.13 のバージョンのライブラリを使うことができる。 そのときの構文は以下のようになる: ```scala ("com.lihaoyi" %% "os-lib" % "0.7.7").cross(CrossVersion.for3Use2_13) ``` -Scala.jsの依存関係は以下のようになります。: +Scala.js の依存関係は以下のようになる: ```scala ("com.lihaoyi" %%% "os-lib" % "0.7.7").cross(CrossVersion.for3Use2_13) ``` -一度あなたが全ての未解決の依存関係について修正したら、Scala 2.13でテストがまだ通るかどうかのチェックが可能になります。: +全ての未解決の依存関係について修正したら、通過済みの Scala 2.13 のテストが通るかどうかのチェックが可能になる: {% highlight text %} sbt:example> ++2.13.6 @@ -101,12 +104,13 @@ sbt:example> example / test ## 5. Scala3コンパイラの設定 -Scala3コンパイラオプションはScala2,13のオプションとは異なり、いくつかに関しては変名したり、未だサポートされてなかったりします。 -[Compiler Options Lookup](options-lookup.html) ページでScala3へ`scalacOptions` が適応されているかのリストを見ることができます。 +Scala 3 コンパイラオプションは Scala 2.13 のオプションとは異なり、一部に関しては変名したり、未だサポートされてなかったりする。 +[コンパイラオプションのルックアップテーブル](options-lookup.html) ページで Scala 3 へ `scalacOptions` が適応されているかのリストを見ることができる。 -あなたは一般的なオプションのリスト、Scala 2.13固有のオプションリスト、 およびSala3固有のオプションリストを考え出す必要があります。 +一般的なオプションのリスト、Scala 2.13 固有のオプションリスト、および Sala 3 固有のオプションリストを考える必要がある。 + +典型的な設定は以下のようになる: -典型的な設定は以下のようになります: ```scala scalacOptions ++= { Seq( @@ -132,12 +136,12 @@ scalacOptions ++= { } ``` -`-source:3.0-migration` オプションを追加することで, [Scala 3移行モード](tooling-migration-mode.html)に切り替わります。 -また、移行モードと自動書き換えを最大限に活用するには、`-Xfatal-warnings`を無効にする必要があります。 +`-source:3.0-migration` オプションを追加することで、 [Scala 3移行モード](tooling-migration-mode.html)に切り替わる。 +また、移行モードと自動書き換えを最大限に活用するには、`-Xfatal-warnings` を無効にする必要がある。 ## 6. 非互換性の解消 -Scala 3でコンパイルするときが来ました: +Scala 3 でコンパイルする時が来た: {% highlight text %} sbt:example> ++3.0.0 @@ -148,29 +152,30 @@ sbt:example> example / compile sbt:example> example / Test / compile {% endhighlight %} -> `example / compile` はプロジェクトの `main`ソースをコンパイルします。 -> 厳密には `example / Compile / compile`と等価です。 +> `example / compile` はプロジェクトの `main` ソースをコンパイルする。 +> 厳密には `example / Compile / compile` と等価だ。 > -> `example / Test / compile`は `test` ソースをコンパイルします。 +> `example / Test / compile` は `test` ソースをコンパイルする。 + +コンパイラは2つの異なるレベルのコンパイル結果を生成する: -コンパイラは２つの異なるレベルの診断を生成します。: -- *Migration Warning*: `-rewrite` オプションにてコンパイルしたときに自動的に適用される警告。 -- *Error*: どこかしらでコードがコンパイルできなかったときに出るもの。 +- *Migration Warning*: `-rewrite` オプションでコンパイルしたときに自動的に適用される警告。 +- *Error*: どこかしらでコードがコンパイルできなかったときに出る。 -コンパイラが自動的に修正をかますのでMigration Warningに関しては無視することもできます。. -しかしながら、非互換性のエラーは必ず手動でケアせねばなりません。 +コンパイラが自動的に修正を適用するのでMigration Warningに関しては無視することもできる。 +しかしながら、非互換性のエラーは必ず手動でケアしなければならない。 -多くの既知の非互換性が[非互換性テーブル](incompatibility-table.html)にリストされています。 -ここで、エラーの説明といくつかの提案された解決策を見つけることができます。 +多くの既知の非互換性が[非互換性テーブル](incompatibility-table.html)にリストされている。 +ここで、エラーの説明といくつかの提案された解決策を見つけることができる。 -可能であれば、コードのバイナリ互換性を最もよく維持する修正を見けるようにしてみるべきです。 +可能であれば、コードのバイナリ互換性を最もよく維持する修正を見けるべきだ。 プロジェクトが公開ライブラリである場合は、このことは特に重要です。 -> マクロの非互換性は解決が簡単にはできないです。 -> 多くのコードは0からの書き直しが必要です。 +> マクロの非互換性は解決が簡単にはできない。 +> 多くのコードはゼロからの書き直しが必要だ。 > [メタプログラミング](compatibility-metaprogramming.html)を見てください。 -非互換性を修正した後は、あなたはScala 2.13でテストを実行することで検証できます。 +非互換性を修正した後は、Scala 2.13 でテストを実行することで検証できる。 {% highlight text %} sbt:example> ++2.13.6 @@ -183,9 +188,9 @@ sbt:example> example / test 定期的に変更をコミットすることを検討してください。 -全てのエラーの修正が完了したらScala 3でコンパイルを行う事ができるでしょう。 -ただMigration Warningだけがのこっていると思います。 -`-source:3.0-migration -rewrite` オプションとコンパイルで自動的にパッチが当てれるでしょう。 +全てのエラーの修正が完了したら Scala 3 でコンパイルを行う事ができるだろう。 +Migration Warningだけが残るだろう。 +`-source:3.0-migration -rewrite` オプションとコンパイルで自動的にパッチが当てれるはずだ。 {% highlight text %} sbt:example> ++3.0.0 @@ -197,15 +202,15 @@ sbt:example> example / compile [success] {% endhighlight %} -ここで`-source:3.0-migration` オプションお削除する必要があります。また、`-Xfatal-warnings` オプションを再度追加することもできます。 -リロード、忘れずに。 +ここで `-source:3.0-migration` オプションを削除する必要がある。また、`-Xfatal-warnings` オプションを再度追加することもできる。 +ただし再起動は忘れないように。 ## 7. 移行の検証 -まれに、異なるImplicit値が解決され、実行時の動作が変更される可能性があります。 -良いテストはそのようなバグが見過ごされないようにする唯一の保証です。 +まれに、異なる Implicit 値が解決され、実行時の動作が変更される可能性がある。 +良いテストはそのようなバグが見過ごされないようにする唯一の保証だ。 -Scala 2.13とScala 3でテストか通るかどうか確認してください。 +Scala 2.13 と Scala 3 でテストか通るかどうか確認すべきだ。 {% highlight text %} sbt:example> ++2.13.6 @@ -218,13 +223,13 @@ sbt:example> example / test [success] {% endhighlight %} -もしCIパイプラインがあれば、Scala 3用にセットアップするときが来ました。 +もし CI パイプラインがあれば、Scala 3 用にセットアップする時が来た。 ## 8. さいごに -おめでとう！これで、モジュールがScala 3に移行できたはずです。 -プロジェクトがScala 3に完全移行されるまで、モジュールごとに同じプロセスを繰り返すことができます。 +おめでとう！これで、モジュールが Scala 3 に移行できたはずだ。 +プロジェクトが Scala 3 に完全移行されるまで、モジュールごとに同じプロセスを繰り返すだろう。 -プログラムを相互公開するかどうかに応じてSala 2.13クロスビルディング構成を保持、または削除できます。 +プログラムを相互公開するかどうかに応じて Sala 2.13 クロスビルディング構成を保持、または削除できる。 -これでsbtプロジェクトの移行についての説明は終わりです。 +これで sbt プロジェクトの移行についての説明は終わりだ。 From 9b9e1f4049fb3832b32c08a628924277a85a2dcb Mon Sep 17 00:00:00 2001 From: arata-honda Date: Sun, 5 Dec 2021 10:41:38 +0900 Subject: [PATCH 9/9] Apply the advice on tooling-tour.md given by eed3si9n --- .../incompat-contextual-abstractions.md | 2 +- .../incompat-dropped-features.md | 10 ++-- .../incompat-other-changes.md | 4 +- .../scala3-migration/incompat-syntactic.md | 10 ++-- .../scala3-migration/incompatibility-table.md | 8 ++-- .../scala3-migration/options-intro.md | 2 +- _ja/overviews/scala3-migration/options-new.md | 4 +- .../tooling-migration-mode.md | 14 +++--- .../scala3-migration/tooling-tour.md | 48 +++++++++---------- .../scala3-migration/tutorial-sbt.md | 4 +- 10 files changed, 53 insertions(+), 53 deletions(-) diff --git a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md index f8acac3e8f..2b5e3dcd11 100644 --- a/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md +++ b/_ja/overviews/scala3-migration/incompat-contextual-abstractions.md @@ -39,7 +39,7 @@ def pretty[A](a: A)(implicit ev: A => Pretty): String = a.print // Error: value print is not a member of A ``` -[Scala 3 移行コンパイル](tooling-migration-mode.html)で、これらのケースについてWARNINGを出すが、直すことはできない。 +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)で、これらのケースについて警告を出すが、直すことはできない。 この非互換性により、実行時の非互換性を引き起こし、プログラムが破損する可能性があることに注意すべきだ。 実際、コンパイラはより広いスコープで別の暗黙的変換を見つけることができる。 diff --git a/_ja/overviews/scala3-migration/incompat-dropped-features.md b/_ja/overviews/scala3-migration/incompat-dropped-features.md index d0666b3a89..34b8d5b687 100644 --- a/_ja/overviews/scala3-migration/incompat-dropped-features.md +++ b/_ja/overviews/scala3-migration/incompat-dropped-features.md @@ -9,7 +9,7 @@ language: ja --- 一部の機能は言語の簡略化のため削除した。 -殆どの変更は、[Scala 3 移行コンパイル](tooling-migration-mode.html)中に自動的に処理できることに注意してください。 +殆どの変更は、[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)中に自動的に処理できることに注意してください。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | @@ -34,7 +34,7 @@ val values: Map[Symbol, Int] = Map('abc -> 1) val abc = values('abc) // Migration Warning: symbol literal 'abc is no longer supported ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} val values: Map[Symbol, Int] = Map(Symbol("abc") -> 1) @@ -61,7 +61,7 @@ do { // Migration Warning: `do while ` is no longer supported } while (f(i) == 0) ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: ```scala while ({ { @@ -84,7 +84,7 @@ object Hello { println(Hello.message) // Migration Warning: method message must be called with () argument ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} object Hello { @@ -109,7 +109,7 @@ val x = 1 val f: () => Int = x _ // Migration Warning: The syntax ` _` is no longer supported; ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードを以下のように書き換える: {% highlight diff %} val x = 1 diff --git a/_ja/overviews/scala3-migration/incompat-other-changes.md b/_ja/overviews/scala3-migration/incompat-other-changes.md index f41e51e875..3a247230f9 100644 --- a/_ja/overviews/scala3-migration/incompat-other-changes.md +++ b/_ja/overviews/scala3-migration/incompat-other-changes.md @@ -66,7 +66,7 @@ object B { | and inherited subsequently in class C {% endhighlight %} -[Scala 3移行コンパイル](tooling-migration-mode.html) は`println(x)` を `println(this.x)` に置き換えることで自動的に曖昧性解消を行う。 +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html) は`println(x)` を `println(this.x)` に置き換えることで自動的に曖昧性解消を行う。 ## プライベートクラスのNon privateなコンストラクタ @@ -90,7 +90,7 @@ private class Bar private[foo] () {} | in its type signature (): foo.Foo.Bar ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では自動的には書き換えが行われずWARNINGが与えられる。 +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html) では自動的には書き換えが行われず警告が表示される。 クラスはプライベートであるため、解決策はコンストラクタをプライベートにすることだ。 diff --git a/_ja/overviews/scala3-migration/incompat-syntactic.md b/_ja/overviews/scala3-migration/incompat-syntactic.md index 0665f300ed..55ccb1128e 100644 --- a/_ja/overviews/scala3-migration/incompat-syntactic.md +++ b/_ja/overviews/scala3-migration/incompat-syntactic.md @@ -13,7 +13,7 @@ Scala 3では括弧がオプションナルな構文と新しい制御構造の 他の構文の変更は、意外性を減らし、一貫性を高めることを目的としている。 -殆どの変更は、[Scala 3移行コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意すべきだ。 +殆どの変更は、[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)に自動的に処理できることに注意すべきだ。 |Incompatibility|Scala 2.13|Scala 3 Migration Rewrite|Scalafix Rule| |--- |--- |--- |--- | @@ -50,7 +50,7 @@ object given { // Error: given is now a keyword } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html) では以下のようにコードが書き直される: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html) では以下のようにコードが書き直される: {% highlight diff %} -object given { @@ -76,7 +76,7 @@ object Bar { } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる。 +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる。 {% highlight diff %} object Bar { @@ -96,7 +96,7 @@ object Bar { val f = { x: Int => x * x } // Error: parentheses are required around the parameter of a lambda ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる: +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではコードはこのように書き換わる: {% highlight diff %} -val f = { x: Int => x * x } @@ -116,7 +116,7 @@ test("my test") } ``` -[Scala 3移行コンパイル](tooling-migration-mode.html)ではブロックの最初の行をインデントする。 +[Scala 3 マイグレーション・コンパイル](tooling-migration-mode.html)ではブロックの最初の行をインデントする。 {% highlight diff %} test("my test") diff --git a/_ja/overviews/scala3-migration/incompatibility-table.md b/_ja/overviews/scala3-migration/incompatibility-table.md index 40db412f23..8f3fb2aa77 100644 --- a/_ja/overviews/scala3-migration/incompatibility-table.md +++ b/_ja/overviews/scala3-migration/incompatibility-table.md @@ -16,15 +16,15 @@ language: ja それぞれの非互換性は以下のように説明している: - 詳細な説明と提案された解決策へのリンクを含む名前 - - Scala 2.13 コンパイラが非推奨または機能WARNINGを発するかどうか - - 非互換性に関しての[Scala 3移行](tooling-migration-mode.html)ルールの存在 + - Scala 2.13 コンパイラが非推奨または機能に関する警告を発するかどうか + - 非互換性に関しての[Scala 3 マイグレーション](tooling-migration-mode.html)ルールの存在 - 非互換性に関して修正できる Scalafix ルールの存在 -> #### Scala2.13の非推奨と機能WARNING +> #### Scala2.13の非推奨と警告機能 > 2.13 コンパイルを `-source:3` で実行すると非互換性のコードを見つける。 > #### Scala 3移行とScalafix書き換えの比較 -> Scala 3 移行モードはすぐに使用できる。 +> Scala 3 マイグレーション・モードはすぐに使用できる。 > それに対して、Scalafix は手動でインストールして構成する必要があるツールだ。 > ただし、Scalafix には独自の利点がある: > diff --git a/_ja/overviews/scala3-migration/options-intro.md b/_ja/overviews/scala3-migration/options-intro.md index 6a42bbcdde..2e7d58279f 100644 --- a/_ja/overviews/scala3-migration/options-intro.md +++ b/_ja/overviews/scala3-migration/options-intro.md @@ -15,7 +15,7 @@ Scala 2.13 プロジェクトを Scala 3 に移植した際、コンパイラオ 適用させるために[ルックアップテーブル](options-lookup.html)を参照してください。 > 利用できないオプションを Scala 3 コンパイラーに渡しても、失敗することはない。 -> WARNINGを出力し、指定したオプションを無視します。 +> 警告を出力し、指定したオプションを無視します。 [新しいコンパイラオプション](options-new.html)のページで、Scala 2.13 にはない Scala 3 の新しいオプションを見つけることができる。 diff --git a/_ja/overviews/scala3-migration/options-new.md b/_ja/overviews/scala3-migration/options-new.md index 2c9feff6f7..2725efa39d 100644 --- a/_ja/overviews/scala3-migration/options-new.md +++ b/_ja/overviews/scala3-migration/options-new.md @@ -87,11 +87,11 @@ language: ja | `-Yprint-pos` | ツリーの場所を表示する | | `-Yprint-pos-syms` | シンボル定義の場所を表示する | | `-Yprint-syms` | ツリーをプリント出力する場合、ツリー内の対応する情報ではなく、シンボルで情報をプリント出力する | -| `-Yrequire-targetName` | @targetName アノテーションなしで定義しているのがあればWARNINGを出す | +| `-Yrequire-targetName` | @targetName アノテーションなしで定義しているのがあれば警告を出す | | `-Yretain-trees` | ClassSymbol＃tree からアクセス可能なトップレベルクラスのツリーを保持する | | `-Yscala2-unpickler` | Scala2 シンボルをどこから取得できるかを制御する。 "always"、 "never"、 またはクラスパスのどれかを指定する。 Default: always | | `-Yshow-print-errors` | ツリーのプリント出力時に投げられる例外を抑制しないようにする | -| `-Yshow-suppressed-errors` | 通常は抑制されている後続のエラーとWARNINGを表示する | +| `-Yshow-suppressed-errors` | 通常は抑制されている後続のエラーと警告を表示する | | `-Yshow-tree-ids` | デバッグ出力ですべてのツリーノードに一意にタグを付ける | | `-Yshow-var-bounds` | 型変数とその境界をプリント出力する | | `-Ytest-pickler` | 関数的な pickling における自己テスト; -Ystop-after:pickler と一緒に使われるべきだ | diff --git a/_ja/overviews/scala3-migration/tooling-migration-mode.md b/_ja/overviews/scala3-migration/tooling-migration-mode.md index 151bedd9ac..bdb374dadf 100644 --- a/_ja/overviews/scala3-migration/tooling-migration-mode.md +++ b/_ja/overviews/scala3-migration/tooling-migration-mode.md @@ -1,7 +1,7 @@ --- -title: Scala 3移行モード +title: Scala 3 マイグレーション・モード type: chapter -description: このセクションではScala 3コンパイラの移行モードについて記述します +description: このセクションではScala 3コンパイラのマイグレーション・モードについて記述します num: 7 previous-page: tooling-tour next-page: tutorial-intro @@ -33,16 +33,16 @@ where possible standard options include: ... {% endhighlight %} -## 移行モード +## マイグレーション・モード -`-source:3.0-migration` オプションは除去された機能の多くを許容し、エラーの代わりにWARNINGを出力する。 -各WARNINGは非推奨のコードに関して、クロスコンパイルに対応するコードを安全に書き換えが可能だということを強調して示す。 +`-source:3.0-migration` オプションは、コンパイラを廃止された機能の多くに対して寛容にして、エラーの代わりに警告を出力する。 +各警告は非推奨のコードに関して、クロスコンパイルに対応するコードを安全に書き換えが可能だということを強調して示す。 -我々はこれを **Scala 3 移行コンパイル**と呼ぶ。 +我々はこれを **Scala 3 マイグレーション・コンパイル**と呼ぶ。 ## 自動書き換え -一度移行モードでコンパイルすると、ほとんど全てのWARNINGはコンパイラによって自動的に解決する。 +一度マイグレーション・モードでコンパイルすると、ほとんど全ての警告はコンパイラによって自動的に解決する。 これを行うためには、再度コンパイルする必要があり、今回は、 `-source:3.0-migration` と　`-rewrite` オプションを使う。 > コンパイラがコードを変更することに注意してください！ 安全ではある。 diff --git a/_ja/overviews/scala3-migration/tooling-tour.md b/_ja/overviews/scala3-migration/tooling-tour.md index 3b9a2ac0d2..645eb5e48f 100644 --- a/_ja/overviews/scala3-migration/tooling-tour.md +++ b/_ja/overviews/scala3-migration/tooling-tour.md @@ -8,34 +8,34 @@ next-page: tooling-migration-mode language: ja --- -## Scalaコンパイラ +## 2系列の Scala コンパイラ -移行に関して、簡単でスムーズに行えるように、事前に2つのコンパイラが準備している。 +移行が簡単でスムーズになるように、2系と3系両方コンパイラにおいて周到にマイグレーションの準備が進められてきた。 -### Scala 2.13コンパイラ +### Scala 2.13 コンパイラ -Scala 2.13 コンパイラは `-Xsource:3` をサポートしている。これは、一部の Scala 3 の構文や振る舞いを可能とするオプションだ: +Scala 2.13 コンパイラは `-Xsource:3` というオプションをサポートして、一部の Scala 3 構文や振る舞いを先取りできるようになっている: - ほとんどの非推奨の構文はエラーを生成する。 -- 中置演算子":"は、複数行の式の途中で行を開始できる。 -- Implicit search と過負荷問題の解決は、特異性のチェック時に Scala 3 が共変性を扱う処理に従う。 +- 複数行にまたがる式の途中の行頭に中置演算子を置いて新しい行を始めることができる。 +- implicit 検索とオーバーロード解決は、Scala 3 が型のどちらがより特化されているかを判定するときに用いる反変性処理にならう。 `-Xsource:3` オプションは、早期の移行を促進することを目的としている。 -### Scala 3コンパイラ +### Scala 3 コンパイラ -#### 移行モード +#### マイグレーション・モード 同様に Scala 3 コンパイラには `-source:3.0-migration` オプションがある。 このモードにより、Scala 2.13 の構文の一部を許容し、変更に関する説明をWarningとして出す。 -さらに、`-rewrite` を使うことで自動的にコードにパッチを当ててくれる。 +さらに、`-rewrite` と合わせて使うことで自動的にコードにパッチを当ててくれる。 -上記については[Scala 3移行モード](tooling-migration-mode.html) のページで学ぶことができる。 +上記については[Scala 3 マイグレーション・モード](tooling-migration-mode.html) のページで解説する。 #### 構文書き換え -一度コードを Scala3 でコンパイルすると、[構文書き換え](tooling-syntax-rewriting.html) オプションを使うことで新しくオプショナルな Scala 3 構文に変換される。 +いったんコードが Scala 3 でコンパイルが通るようになると、次に[構文書き換え](tooling-syntax-rewriting.html)オプションを使って、オプショナルな Scala 3 新構文へと変換することができる。 ## ビルドツール @@ -44,10 +44,10 @@ Scala 2.13 コンパイラは `-Xsource:3` をサポートしている。これ > sbt 1.4 ではビルドする際、 `sbt-dotty` プラグインが必要だ。 > しかし 1.5 以降では不要になった。 -sbt 1.5 は Scala 3 をサポートしており、目的は全ての共通タスクと設定は同じように動くことだ。 -多くのプラグインも確実に同じように動くべきだ。 +sbt 1.5 は追加設定無しで Scala 3 をサポートしており、よく使われるタスクやセッティングは全て従来と同じように動作することを意図した設計となっている。 +多くのプラグインも同じように振る舞うはずだ。 -移行のヘルプとして、sbt 1.5 が紹介している新たな Scala 3 のクロスバージョンを示す: +マイグレーションの役に立つように、sbt 1.5 は新たに Scala 3 専用のクロスバージョンを導入した: ```scala // Scala 3 で Scala 2.13 ライブラリを使用する @@ -69,14 +69,14 @@ Scala 3 サポートに関しては [scala-maven-plugin](https://github.com/davi ### Metals -[Metals](https://scalameta.org/metals/)は VS Code、Vim、Emacs、SbulimeText や Eclips 上で動く Scala 言語サーバーだ。 +[Metals](https://scalameta.org/metals/)は VS Code、Vim、Emacs、SublimeText や Eclipse 上で動く Scala 言語サーバーだ。 Scala 3 はすでに Metals によって大変良くサポートされている。 いくつかの新しい構文変更や新機能といったマイナーアップデートは時期にでてくる。 ### IntelliJ IDEA -InteliJ 用の Scala プラグインは Scala3 用の予備サポートが含まれている。 +現行の InteliJ Scala プラグインに含まれる Scala 3 のサポートは暫定的なものだ。 本格的なサポートは JetBrain のチームよって行われている。 ## フォーマットツール @@ -103,8 +103,8 @@ fileOverride { ### Scalafix [Scalafix](https://scalacenter.github.io/scalafix/) は Scala 用のリファクタリングツールだ。 -一度書いてしまえば、Scala 2.13 上で実行される。 -しかし、Scala 3 に移行する前にコードを準備しておくと便利である。 +本稿を書いている時点では、Scala 2.13 のみで実行することができる。 +しかし、Scala 3 に移行する前の準備としては役に立つかもしれない。 [Incompatibility Table](incompatibility-table.html) は既存の Scalafix ルールで修正できる非互換性が表示されている。 これまでのところ、関連するルールは以下のとおりだ @@ -119,22 +119,22 @@ fileOverride { `sbt-scalafix` プラグインを使用して、これらのルールを sbt に適用できる。 これらは、以下で説明する `sbt-scala3-migrate` でも内部的に使用される。 -### Scala 3移行プラグイン +### scala3-migrate プラグイン -[Scala 3移行](https://github.com/scalacenter/scala3-migrate) は移行期間中にアシストしてくれる sbt plugin がある。 +[scala3-migrate](https://github.com/scalacenter/scala3-migrate) という sbt プラグインがあり、Scala 3 へのマイグレーションをアシストしてくれる。 そのプロセスは段階的なアプローチで下記のようになる: -- ライブラリの依存関係の移行: - Scala 3 で利用可能なバージョンが有るかどうか、ライブラリ依存関係ごとにチェックする。 +- ライブラリ依存性の移行: + ライブラリごとに、Scala 3 で利用可能なバージョンが有るかどうかチェックする。 - Scala のコンパイルオプション(`scalacOptions`)の移行: Scala 2 の一部のコンパイラのオプションは廃止したか、名前を変更した、もしくはそのままのものがある。 このステップは自身のプロジェクトのコンパイラオプションに適用させるのに役立つ。 - 構文の移行: このステップは構文の非推奨を修正するために Scalafix や既存ルールに依存する。 -- 型を明示してコードを移行: +- 明示的な型の表記（コードの移行）: Scala 3 は新規の型推論のアルゴリズムをもっており、Scala 2 の推論アルゴリズムとはわずかに異なる。 - 最後のステップでは、実行時の動作を変更せずにプロジェクトを Scala 3 でコンパイルできるように、型の最小セットを明示する。 + 最後のステップでは、実行時の動作を変更しない形でプロジェクトを Scala 3 でコンパイルするのに最低限必要な型の明示的な表記を行う。 ## Scaladex diff --git a/_ja/overviews/scala3-migration/tutorial-sbt.md b/_ja/overviews/scala3-migration/tutorial-sbt.md index 7c52256a3f..3df7662813 100644 --- a/_ja/overviews/scala3-migration/tutorial-sbt.md +++ b/_ja/overviews/scala3-migration/tutorial-sbt.md @@ -136,8 +136,8 @@ scalacOptions ++= { } ``` -`-source:3.0-migration` オプションを追加することで、 [Scala 3移行モード](tooling-migration-mode.html)に切り替わる。 -また、移行モードと自動書き換えを最大限に活用するには、`-Xfatal-warnings` を無効にする必要がある。 +`-source:3.0-migration` オプションを追加することで、 [Scala 3 マイグレーション・モード](tooling-migration-mode.html)に切り替わる。 +また、マイグレーション・モードと自動書き換えを最大限に活用するには、`-Xfatal-warnings` を無効にする必要がある。 ## 6. 非互換性の解消