HN 日本語サマリー

← 一覧へ戻る
プログラミング

Fortranの近代化という forlorn hope(絶望的な希望)

A Forlorn Hope of Fortran Modernisation (amenzwa.github.io)

19 pointsby Elzair7 コメント

要約

この記事は、科学技術計算におけるFortranの重要性を強調しつつ、若手プログラマーの不足という現状と、その解決策として依存型Fortranの提案を探求しています。Fortranは依然として大規模並列科学技術計算に不可欠ですが、その古いイメージと学習者の減少が課題となっています。

全文翻訳

Fortran近代化への儚い希望

依存型Fortranの提案

[TOC]

IT業界では何十年もの間、Fortranの終焉を語られてきました。しかし、この古い言語は今も生き続けています。近年、Fortranコミュニティは警鐘を鳴らし始めています。Fortranを使用する組織では、引退していくベテランプログラマーに代わる若いプログラマーを見つけるのに苦労しています。なぜなら、若い世代はこの時代遅れの言語にキャリアを捧げることを望まないからです。現在、長期間にわたる大規模で並列性の高い科学技術・工学アプリケーションの実装において、Fortranに匹敵する、ましてや凌駕する言語は存在しません。CやC++でさえもです。しかし、現代のプログラマーはFortranについて何も知らず、関心もありません。Fortranにはイメージの問題があると言えば十分でしょう。

この記事では、Fortranの人気が低下した原因を探り、その解決策を議論します。ここで述べる主なポイントは以下の通りです。

  • Fortranは科学技術計算における並列処理に不可欠である
  • 業界はFortranプログラマーの不足に直面している
  • 業界には、その層を補充するための実行可能な計画が存在しない

対象読者は以下のグループを想定しています。

  • Fortran言語標準を維持するコンピュータ科学者
  • Fortranを使用して科学ソフトウェアを実装する科学者・技術者
  • 並列処理と科学プログラミングに関心のあるSTEM分野の学生・研究者

なお、この記事は、プログラミングを数学的目標達成の手段としか見なさない、数学を職業とする科学者や技術者を対象としています。また、関連するトピックの広さと深さを考慮すると、読者は手続き型言語と関数型言語の両方における経験豊富な並列プログラマーであり、単純型理論、パラメトリック型理論、依存型理論に関する実用的な知識を有していることが期待されます。

この半世紀前の言語を21世紀の過酷な現実に適合させるための強化は、狂気の沙汰のように思えるかもしれません。しかし、そうではありません。私はFortranの近代化は価値があり、必要であると主張します。ただし、2020年代に向けてFortranを刷新することは、現時点では儚い希望に過ぎないことを認めます。

本題に入る前に、Fortranとの関わりについて背景を説明します。1980年代初頭、私は他の電気工学の学部生と同様に、大学でFORTRANを学びました。DEC VAX-11/780でFORTRAN 1977を使用しました。当時、FORTRANは電子回路シミュレーション、デジタル信号処理(DSP)、有限要素法(FEM)、計算流体力学(CFD)などの工学計算を行うための主要言語であったため、学習が必須でした。

しかし、当時、多くのSTEM分野の学生は、手に入るあらゆるプログラミング言語を学ぼうとしていました。科学技術分野で広く使われていた言語は、LISP、FORTRAN、C、Pascal、ML、Prologの数種類しかありませんでした。これらの言語の良いコンパイラはミニコンピュタでしか利用できず、これらの大型で高価なマシンにアクセスできる唯一の場所は大学のコンピュータセンターでした。希少性が需要を生むのだと思います。私は主に好みの言語であるLISP、C、MLで作業を行いました。そのため、FORTRANの経験はクラスの課題に限られていました。

その後、コンピュータサイエンスの大学院で、私の研究はCRAY Y-MPに接続されたT3D上のFortran 90へと私を導きました。1990年代半ばに学界を離れて産業界に移ったとき、Fortranとの専門的な関わりは終わりました。その頃でさえ、IT業界でFortranを使っている人はいませんでした。しかし、個人的な興味から、長年にわたりFortranの進化を追い続けてきました。したがって、ここで提示する私の見解は、古いFORTRANでの時代遅れの実際的な経験、現代Fortranの窮状に対する現在の認識、そして何十年にもわたる多数の現代的および古代のプログラミング言語での実際的な経験に基づいています。そして、実用的なレベルではFortranのファンではありませんが、その独創性、長寿命、歴史に対して知的なレベルではFortranを高く評価していることを認めます。

さて、本題に入りましょう。

昨日

現代のコンピュータという概念は、1930年代後半に数学者たちの心の中で生まれました。そして、1940年代半ばに、現代コンピュータの実装が電気技術者たちの手によって実現されました。当初、プログラミングは回路の配線によって行われていました。次に、ハードウェアスイッチを使用してレジスタにバイナリワードを入力することが続きました。その後、シンボリックアセンブリ言語が発明されました。そして1957年、コンピュータ科学の卓越した人物であるBackusとIBMの彼の同僚たちは、世界初の高水準プログラミング言語であるFORTRANを作成しました。その目的は、科学者がアセンブリ言語という外国語ではなく、母語である数学的記法を使用して科学アプリケーションを実装できるようにすることでした。

過去70年以上にわたり、Fortranは数十年にわたる進歩を取り込みながら進化し続けてきました。Fortranには、1966年、1977年、1990年、1995年、2003年、2008年、2018年、2023年といった数多くの標準化されたバージョンが存在します。2024年初頭の執筆時点での最新標準バージョンであるFortran 2023(ドラフト)は、強力な静的型システム、ユーザー定義型、末尾再帰呼び出しの除去、オブジェクト、モジュール、ガベージコレクション、そしてパーティションドグローバルアドレス空間(PGAS)並列プログラミング機能を備えた、完全にモダンな言語です。現在に至るまで、Fortranは組み込みの並列処理機能を持つ唯一の標準化された言語です。その年齢にもかかわらず、数十年にわたる蓄積にもかかわらず、Fortranは本質的に非プログラマーがすぐに使えるようになるシンプルな言語であり続けています。その意味で、FortranはPythonのように使いやすいです。しかし、Pythonとは異なり、Fortranは科学技術計算における並列処理においては、Pythonよりも、さらには強力なCよりも高速です。

今日、モダンFortranは、科学技術計算の主力である大規模で超並列なアプリケーションにおいて、依然として主要な選択言語です。世界の一部のエリート工学大学では、コンピュータサイエンスの学生がこの言語を聞いたことがない場合でも、工学部の学部生にFortranを教えています。スーパーコンピュータ上での高性能並列科学計算においては、Fortranと競合できる現代言語は存在しません。これはモダンCobolにも当てはまります。学部生がそれを大学で学ぶことはないでしょうが、多くの大規模金融機関は依然として大量のトランザクション処理のためにCobolに大きく依存しています。メインフレーム上での高スループットリアルタイムトランザクション処理においては、Cobolと競合できる現代言語はありません。

第一世代の高水準プログラミング言語は、1950年代後半から1960年代初頭にかけて登場しました。FORTRAN(1957年)は科学技術計算専用に設計された最初の高水準言語でした。LISP(1958年)は記号計算と自動定理証明のために設計された最初の関数型プログラミング(FP)言語でした。ALGOL(1958年)は最初の手続き型プログラミング(PP)言語でした。COBOL(1959年)は最初の目的特化型ビジネスコンピューティング言語でした。Simula(1962年)は最初のオブジェクト指向(OO)言語でした。これらのOG(オリジナルギャングスタ)言語は、何らかの形で生き残っています。モダンFORTRANはFortran 2023です。モダンLISPはCommon Lisp R2005です。モダンALGOLは本質的にすべての現代PP言語であり、その代表格はC 2023です。モダンCOBOLはCobol 2023です。モダンSimulaはすべての現代OO言語であり、最も人気のあるのはC++ 2023です。

LISPは、1970年代から1980年代にかけてルールベースの人工知能(AI)が隆盛を極めた時期に絶大な人気を博しました。今日、その最もよく知られた用途は、比類なきEmacsエディタのスクリプト言語としてです。そして、最初のFP言語として、OCamlやHaskellのようなすべての現代FP言語は、その精神的な子孫です。ALGOLは学術界から抜け出すことはありませんでしたが、その影響はPascal、C、そしてRust、Odin、Zigのような他の現代システムプログラミング言語を含む、後続のすべてのPP言語のデザインに見られます。Cは、コンパイラ、ライブラリ、オペレーティングシステムなどのシステムプログラミングで依然として広く使用されています。その最も有名な用途はLinuxカーネルの実装です。Simulaも主に学術研究言語でした。しかし、SmalltalkやC++に大きな影響を与えました。Smalltalkは、Objective-CやJavaに影響を与えました。C++は、Cの効率性とSimulaのオブジェクトを組み合わせ、伝統的にPPドメインであったシステムプログラミングに多くの有用なOO概念を注入しました。今日、C++は速度が不可欠なほぼすべてのアプリケーションドメインで使用されています。したがって、LISP、ALGOL、Simulaは、たとえかなり異なる姿形であっても、生き残っています。

しかし、FORTRANとCOBOLは、約70年間、本質的に変化していません。それらの標準委員会は、完全な後方互換性を維持することを選択しました。例えば、Fortran 2023コンパイラは、FORTRAN 1977のコードを(変更なしで)コンパイルできます!

元の様式化された名前「FORTRAN」は、Fortran 1990標準の公開とともに、現代の形式「Fortran」に変更されたことに注意してください。ちなみに、FORTRANは「formula translator」の略であり、その数学的な系譜を示唆しています。

後方互換性の利点は、寿命と信頼性の両方の点で、信頼性です。ほとんどのバグは時間とともに根絶され、組織はこの長寿命言語の継続的な存在に依存できます。後方互換性の欠点は、もちろん、これらの古い言語の誕生から数十年後に登場した新しい概念が、その設計に無理やり押し込まれなければならず、構文的にも意味論的にもかなり不自然な感じになることです。そのため、モジュールやオブジェクトのようなこれらの言語の言語拡張は、モダンであっても、やはりぎこちなく時代遅れに感じられます。結果として、FORTRANとCOBOLは、現代の目には古臭く、時代遅れに見えます。

このセクションの残りの部分では、Fortranに焦点を当てます。しかし、ここで提示する議論と結論は、類推によってCobolにも同様に適用されます。

今日

モダンFortranがイメージの問題に悩まされていることは否定できません。IT業界に入ってくる若いプログラマーは、この先駆的な言語を古臭いと正しく認識しています。その認識は現実を反映していますが、これらの若者は、この古い言語が古代の、未熟な形態のままであり、Fortranに将来はなく、最新の言語だけを学ぶべきだと誤って推測しています。その推測は単に間違っているだけでなく、現実とは正反対です。

ITは、現代のデジタルコンピュータの出現とともに、1950年代に専門分野となりました。しかし、私たちが現在知っているような現代のITは、集積回路(IC)の広範な使用により、DEC、Data General、IBMなどのメーカーのミニコンピュタが手頃な価格になった1970年代まで現れませんでした。ITのこの急速な拡大は、PP言語の台頭と一致しました。Cは1970年代初頭に導入されました。そして1980年代初頭までには、業界で支配的な言語としての地位を確立し、その支配は1980年代後半まで続きました。C++は1990年代初頭に王座を奪いました。Javaは10年足らずでほぼ一夜にして現れ、2000年代初頭までにトップの座を占めました。2010年代には、Web 2.0に牽引されてJavaScriptが飛躍的に台頭しました。今日、2020年代には、Pythonが機械学習とデータサイエンスでの人気により王様です。人気の高い産業用言語の支配期間は、ローマ皇帝の支配期間とほぼ同じ長さのようです。

これはFortranの軌跡とは stark contrast です。50年以上前のCの台頭以来、Fortranの人気は着実に低下してきました。この低下は、フリーソフトウェア運動が主流になり、多くの新しい言語の高品質なコンパイラが無料で利用可能になった1980年代半ばに加速しました。また、この時期のホームコンピュータの台頭は、新しい言語を学びたいと願う多くの新しいプログラマーを生み出しました。そして、その人気のピーク時でさえ、Fortranは科学技術計算という狭いが深い専門分野を占めていました。これらの専門的なアプリケーションは、ごく一部のエリート大学、最大の企業、最も資金力のある政府機関以外にはアクセスできなかったスーパーコンピュータと切り離せないものでした。これらの要因の組み合わせが、Fortranの人気を低下させる原因となりました。しかし、科学技術計算においては依然としてしっかりと根付いています。

そしてここに問題があります。Fortranに依存している組織は、この古い言語にキャリアを捧げることを望む若いプログラマーを見つけることができなくなりました。この言語は、彼らの繊細なPython的な感性を不快にさせます。また、今日のほとんどのプログラマーはスーパーコンピュータを見たことがありません。大学はもはや従来のコンピュータセンターを運営していません。なぜなら、学校のITニーズは現在クラウドによって満たされており、すべての学生がラップトップ、タブレット、モバイル端末を所有しているからです。これらの要因は、学生がFortranエコシステムを探求することを妨げます。結果として、Fortranにミッションクリティカルなコードを依存している組織は、引退間近またはすでに引退した高齢プログラマーの減少する人口を置き換える新しいプログラマーを見つけることができなくなっています。

明日

Fortranの人気低下が加速し続けると、やがてミッションクリティカルな既存コードの大量を維持するのに十分なプログラマーがいなくなるでしょう。「明日」というセクションのタイトルは誇張ではありません。この問題は差し迫っています。

そして、業界リーダーたちがこの問題について過去30年間懸念を増大させているにもかかわらず、それを是正するための業界全体の協調的な努力は行われていません。実際、実行可能な計画は存在しません。Fortranのような根付いた長寿命言語から移行するには、少なくとも数十年かかります。したがって、この状況は持続不可能です。

考えられる選択肢はいくつかしかありませんが、問題を無視して現状を維持することは賢明な選択ではありません。

  • Fortranを新しい、人気のある言語に手動で翻訳する
  • Fortranを新しい、人気のある言語に自動で翻訳する
  • 学術界と産業界で体系的に促進することにより、Fortranを受け入れる
  • 既存のモダン言語からFortranをターゲットにする
  • Fortranを徹底的に近代化し、過去への感情的な執着をすべて捨てる

これらの選択肢を詳しく見ていきましょう。

選択肢

このドキュメントは、議論を促進するために書かれたものであり、新しいFortranの設計ドキュメントではありません。つまり、ここで与えられる推奨事項は断片的なアイデアであり、確定的な命令ではありません。実際、以下の構文の文法には曖昧さが存在する可能性があります。私の目的は正確さではなく、Fortranコードの腐敗という迫り来る暗闇について考え、話し、懸念を伝えるための基盤を築くことです。

手動で翻訳

FortranプログラムをC++、Java、Pythonなどのモダンな言語に手動で翻訳することは可能です。結局のところ、アルゴリズムは実装言語に関係なくアルゴリズムです。

しかし、このような手動翻訳は経済的でないだけでなく、極めて危険です。使用されているほとんどのFortranプログラムは数十年前から実装されており、プログラムを設計した科学者や技術者はすでに引退しており、要件や設計に関する組織的な知識も彼らとともに失われています。そのようなプログラムは、誰かの研究や実験から生まれ、それほど大規模で長期間続くように設計されたものではありません。そのため、コードとシステムは通常文書化されていません。そのドメインの専門的な性質を考えると、昔ながらのFortranプログラマーは孤立した集団です。彼らは新しい言語やライブラリを知らないか、知っていても、それらの大規模で複雑な並列科学アプリケーションを現代のコンピューティングインフラストラクチャ上で再実装するために必要なスキルを持っていません。逆に、ほとんどのC++やJavaプログラマーはFortranコードを見たことがありません。そして典型的なFortranコードは並列実行のために高度に最適化されていますが、現代のプログラマーは並列コンピューティングの経験がありません。さらに、現代の言語には標準化された組み込み並列処理機能がありません。そのため、リードプログラマーは、MPI、OpenMP、OpenCL、OpenACC、Vulkan、CUDA、Metal、その他無数のAPIの中から1つを選択し、実験し、選択する必要があります。さらに、並列コードは通常、基盤となるアルゴリズムを不明瞭にするデータ分散と制御同期プロトコルの層で覆われています。これらのアルゴリズムは、たとえ単純な逐次形式であっても、科学技術の背景を持たないITコーダーが理解する機会がないほど専門的で洗練されています。

したがって、大規模で複雑なFortranコードベースを理解できる唯一の人々は、引退間近の古い科学者や技術者です。しかし、キャリアの晩年において、彼らは作業を妨げるであろう新しい、能力の低い言語に切り替える動機がありません。そして、古いFortranプログラムを新しい言語に翻訳できるのは、Fortranを習得するためにキャリアの10年以上を費やすことを望まない典型的なITコーダーです。これは古典的なキャッチ22です。

自動で翻訳

手動翻訳のより現実的な代替案は、既存のFortranコンパイラを活用した自動翻訳です。例えば、常に人気のあるGNU Fortranコンパイラ(フリーソフトウェアでもあります)は、FORTRAN 1977コードをCに翻訳できます。しかし、モダンな並列Fortranコードをコンパイルできる一方で、その新しいコードをCに翻訳することはできません。これは主に、Cが公然と逐次的な言語であるためです。したがって、最先端のコンパイラでさえ、古い逐次FORTRAN 1977コードしか自動的に変換できません。

もう一つの可能な道は、2017年に初めて公開された大規模言語モデル(LLM)を使用することです。2022年末にChatGPTがリリースされたとき、それはIT全体と世界全体を揺るがしました。今日、ITはLLMで賑わっています。コード生成、自動チャット、テキスト要約、スプレッドシート分析、画像注釈などです。そして最近では、LLMは学術AI研究の分野をほぼ席巻しています。現在、テキスト操作において最も有能で適応性の高い機械学習アルゴリズムであると言えます。

プログラミング言語に特化したLLMは数多く存在します。それらは数万の言語で書かれた数兆行のコードでトレーニングされています。しかし、最も高度なLLMでさえ、既知のアルゴリズムの独立したコードスニペットを生成する以上のことはできませんでした。コードスニペットをさまざまな言語に翻訳できるLLMもいくつかあります。しかし、それらも少量のコードの翻訳に限定されています。今日現在、最も有能なLLM翻訳者は、主張する言語で数千行のコードを提示されると失敗します。そして、それらは並列プログラミングについては何も知りません。

さらに、LLMには、克服が不可能ではないにしても困難である可能性のある根本的な弱点があります。すべてのニューラルネットワークと同様に、非決定性はLLMに固有のものです。さらに、LLMは幻覚を起こしやすく、これは非公式なビジネスコミュニケーションでは面白いかもしれませんが、生命に関わる工学アプリケーションでは許容できません。結論として、LLMのコード生成および翻訳能力の精度を評価するための直接的な統計的尺度はありません。したがって、LLMが奇跡的に並列Fortranコードを新しい言語に翻訳する能力を獲得したとしても、翻訳されたコードの意味論的忠実性を評価する数学的な手段はありません。そして、生命や身体が危険にさらされる場合、自動テストは、このアプリケーションドメインで要求される100%の正確性を保証するには全く不十分であることはよく知られています。

将来、AIがプログラムの機械翻訳を実行できるようになるかもしれません。しかし、それはまだ数十年かかるかもしれません。その頃には、AIプログラマーは高水準プログラミング言語を必要としなくなるため、高水準言語の機械翻訳はまったく必要なくなるでしょう。その場合、人間のプログラマーを雇用することは経済的に無意味になります。したがって、将来AIが機械をプログラミングするために使用される場合(これは十分にあり得る)、リソースを、ハードウェア固有のバイナリコード、あるいはおそらくハードウェア記述言語(HDL)で直接プログラムするAIを作成することに集中する方が、はるかに賢明なリソースの利用法です。したがって、FortranのAI翻訳もキャッチ22です。

Fortranを受け入れる

私がずっと昔、学部生の工学学生だった頃、Fortranは私たちが学ぶ必要のある唯一のプログラミング言語でした。実際、当時、科学者や技術者が使用していた唯一の言語でした。すぐに、CはFortranの伝統的な領域の大部分を引き継ぎました。そして今日、ほとんどの科学者や技術者はPythonを排他的に使用しています。一方、Fortranは静かに進化を続け、モダンなプログラミング言語の概念、そして最も重要なことに、コアレイとして知られる並列プログラミング機能を取り込みました。Coarray Fortran(CAF)はCRAYで1990年代初頭に開発され、最終的にFortran 2008標準に組み込まれました。

コアレ並列プログラミング機能は、まさに比類のない快適さと利便性を超並列コードの実装に提供します。今日まで、他のどの言語も、そのような洗練された並列プログラミング体験を提供できていません。Coarrayは他の方法よりも明確な利点があります。それは、高性能科学技術計算専用に設計された言語であり、科学者や技術者がコンピューティングについて考える方法に対応し、70年間科学技術計算で継続的に使用されてきた言語であるFortranに構文的・意味論的に結びついています。また、CAFはパーティションドグローバルアドレス空間(PGAS)モデルの並列プログラミングを採用しています。多くの並列プログラミングモデルの中で、PGASは一般的に最も自然で直感的な使用方法の1つと考えられています。したがって、CAFはプログラマーにとって自然であるだけでなく、現場で実証された信頼性と安定性も享受しています。Fortranが科学技術計算における並列処理で今日でも成功し続けていることは驚くことではありません。

しかし、前述したように、Fortranのより広範な学術界および産業界での人気は、ずっと前に衰退しました。科学技術計算コミュニティがFortranプログラマー不足という差し迫った問題をこれほど長い間無視してきたことは残念です。この問題を解決するための最もシンプルで最も現実的な方法は、Fortranをより広範なSTEM学部カリキュラムに再導入することです。

しかし、現時点では、STEM教育におけるその神聖な場所をPythonが占めています。実際、ほとんどのSTEM学部生は高校時代からPythonに慣れているため、古臭いFortranを彼らに押し付けるのは冒涜的でしょう。Fortranが主にスーパーコンピュータで使用されており、ほとんどの大学はスーパーコンピュータにアクセスできないという事実は、Fortranの状況を助けません。

しかし、希望の光があります。今日、モバイルフォンを含むすべてのコンピュータは、マルチコア、共有メモリマシンです。つまり、それらは並列コンピュータです。しかし、これらの強力な並列マシンは現在、並列プログラミングがITで普及していないため、逐次プログラミング言語で書かれたシングルスレッドアプリケーションを実行しています。現在の産業用言語の在庫を使用して並列コードを実装するには、かなりの知識、スキル、機知、そして努力が必要です。Web開発者がFortranを採用することはないでしょうが、一部の科学技術学部生が、GPU搭載のマルチコアラップトップなどでCAFを使用して、特にコードが変更なしでスーパーコンピュータ上で実行される場合、大規模でディープラーニングAIモデルをより効率的に実装・トレーニングするように説得される可能性は否定できません。そして、現在のFortranの強力なユーザー(NVIDIA、IBM、NASA、NOAA、DoDなど)の支援を得て、同様の教育イニシアチブを産業界でも追求できます。

率直に言えば、このアプローチはFortranの汚れた人気をかつての輝きに戻すためのマーケティングキャンペーンに過ぎません。しかし、それは粗雑であると同時に達成も容易です。数年あれば十分です。さらに、Fortranの並列処理概念に慣れることは、手首の上であろうとクラウドであろうと、マルチコア、マルチプロセッサマシンしか利用できない将来のキャリアにおいて、若いプログラマーに大いに役立つでしょう。これは、マーケティングキャンペーンが若者に6桁のPythonの仕事の波に逆らってFortranを試してみるよう説得できれば、Fortranショップと若いプログラマーの両方にとって、Win-Winのシナリオになり得ます。それは、大きな「もし」です。

Fortranをターゲットにする

今日、プログラミング言語設計における一般的な慣行は、マシン言語ではなく、「十分に低い」高水準言語をターゲットにすることです。1980年代の最初のC++コンパイラであるAT&T Cfrontは、C++をCにトランスパイルし、次にプラットフォームのCコンパイラを呼び出してネイティブバイナリを生成しました。新しいPP言語であるNimもCにトランスパイルされます。活気に満ちた純粋関数型Webフロントエンド言語であるElmは、Webのアセンブリ言語であるJavaScriptにトランスパイルされます。したがって、新しい、より人気のある言語からFortranにトランスパイルすることは、現在の業界トレンドに沿ったものです。

ただし、トランスパイルは一方向であることに注意することが重要です。それは高抽象度言語から低抽象度言語へのみ行われます。つまり、下方向へのトランスパイルは抽象度を失います。Cのような低抽象度言語をHaskellのような高抽象度言語にトランスパイルすることは実質的に不可能ですが、HaskellをCにトランスパイルすることは比較してはるかに簡単です。抽象度の損失を軽減する1つの方法は、高抽象度から自動的に回復できる低レベルコードにメタデータを注入することです。しかし、これらの技術は効果的でも効率的でもありません。しかし、意味論的に近い言語間、例えばCとPascalの間、JavaとC#の間、またはOCamlとReasonの間での翻訳は簡単です。Fortranは、現代のFP言語と比較して低抽象度の言語です。そして、Fortranのアプリケーションドメインである科学技術計算は、非常に数学的です。したがって、数学的な傾向を持つ既存のFP言語(Haskell、OCaml、F#など)は、比較的容易にFortranをターゲットにすることができます。実際、これらの言語はすでにCとJavaScriptをターゲットにしているため、下方向へのトランスパイルは彼らにとって馴染みのない慣行ではありません。プログラマーは常にエレガントな構文と説得力のある意味論を持つ言語を好みます。したがって、彼らは、たとえ古臭いFortranエコシステム内で作業する必要があったとしても、Fortranをターゲットにできる人気のあるFP言語を学ぶことに異議はないでしょう。

しかし、より実用的なアプローチは、すべての科学者や技術者が使用する言語、すべてのジュニアコーダーが知っている言語、すべての高校生が愛する言語であるPythonを活用することです。PythonはすでにCとJavaScriptをターゲットにしているため、Fortranターゲットを追加しても負担にはなりません。さらに重要なことに、Pythonの最も人気のある科学技術計算ライブラリ(NumPy、SciPyなど)は、外部関数インターフェースを介して、LAPACKやBLASのような高度に最適化された低レベルライブラリ(Fortranで書かれている)を呼び出します。遅いインタープリタ型Pythonコードが高速コンパイル型Fortranバイナリを呼び出すのではなく、PythonコードをFortranにトランスパイルでき、アプリケーション全体が高速なコンパイル型Fortranバイナリになります。PGASをPythonに統合し、並列Pythonコードを直接並列Fortran PGASコードにトランスパイルすることは、Win-Winの状況になるでしょう。

Fortranを近代化する

その長い存在期間を通じて、Fortranは1950年代にその生命を与えた元の設計概念と哲学に頑固に固執してきました。実際、すべてのモダンFortranコンパイラは、FORTRAN 1977コードをコンパイルできます。このレベルの後方互換性は、長年にわたりこの一連の言語標準をキュレーションし、導いてきた人々にとって驚くべき成果です。

しかし、1957年以来、コンピューティングの世界は大きく変化しました。前述のように、後方互換性は鋭い先端を持つ両刃の剣です。Fortranの後方互換性への単一目的の追求は、その寿命を延ばしました。最初の高水準プログラミング言語であるにもかかわらず、今日でも積極的に使用されています。しかし、この設計上の選択は、Fortranを冗長で時代遅れなものにもしました。初期の頃、プログラマー階級が出現する前は、英語のような冗長性は、その認識可能な理解しやすさのために価値がありました。当時、高水準プログラミング言語がどのようなものであるべきか、誰も本当には知りませんでした。また、ハードウェアの制約により、プログラムは数百行のコードに制限され、実質的に一度きりのツールとなっていました。しかし今日、プロジェクトが日常的に百万行を超え、数十年続くようになると、冗長性は理解性と保守性を著しく低下させます。そのため、Fortranの冗長な性質は、現代のプログラマーにとって受け入れがたいものとなり、彼らの目にはモダンFortranはモダンとは程遠いものとなっています。

successive 標準がFortranを近代化し、そのアプリケーションドメインを拡大しようと試みたにもかかわらず、Fortranが汎用言語(GPL)、システム言語、エンタープライズ言語、Web開発言語、またはモバイル開発言語ではなく、純粋に科学プログラミング言語であることは否定できません。実際、構文に並列プログラミング機能を組み込んだ唯一の標準化されたプログラミング言語です。したがって、Fortranは究極の科学技術ドメイン固有言語(DSL)です。

すべてのモダンソフトウェア開発プロジェクトは、それぞれ特定の目的に使用される複数の異なるプログラミング言語を採用しています。例えば、今日のあらゆる大規模ソフトウェア開発プロジェクトにおいて、プログラミング言語間の以下の専門化は標準的な慣行です。Web UIにはJavaScriptまたはTypeScriptで拡張されたHTMLを使用します。フロントエンドバックグラウンドサービスおよびバックエンドリモートサービスには、WebAssemblyをターゲットとするモダンで産業強度の高い高水準言語を使用します。JupyterではPythonを対話的なデータ分析に使用します。システム統合にはC、C++、Rust、またはZigを使用します。データ処理にはGraphQLを使用します。データウェアハウジングにはSQLを使用します。これらの言語のほとんどはGPLですが、それらはその傾向に最も適した目的で使用されます。同様に、大規模な科学ソフトウェア開発プロジェクトも、目的ごとに複数の言語を使用するという業界標準の慣行に従うべきです。Fortranがプロジェクト全体で使用される唯一の言語である必要はありません。代わりに、Fortranは科学技術および工学の並列アルゴリズムを実装するためにのみ使用されるべきです。

このシナリオでは、Fortranのコアは、数十年にわたって蓄積された不要なものを削ぎ落とし、かつての洗練された姿に戻され、その構文は現代の言語設計思想を反映するようにオーバーホールされるべきです。Fortranの現在の肥大化の多くは、近代化に追いつこうとする必死の試みと、それをGPLに変えようとする誤った努力から来ています。究極の科学技術DSLとしてのFortranの運命を受け入れることは、言語をよりコンパクトにし、元の目的に再び適したものにします。実際、Python、C++、または他のどのモダンGPLよりも、科学技術DSLの役割に適しているでしょう。

冗長な構文とFortranの余分な機能を削減することは、実行可能であるだけでなく、最も賢明な選択肢です。この「新しいFortran」は、Haskell、OCaml、F#のようなモダンFP言語に似た構文と意味論を採用し、Agda、Idris、Coq、F*、Leanのようなモダンな証明支援ツールの機能を取り込みます。しかし、Fortranの配列操作と並列プログラミング機能は保持します。それでも、それはFortranのコア意味論の上に、受け入れやすい代替構文の薄いベニヤに過ぎません。構文的な違いの点で、この努力はC++がCであることと同様です。意味論的な違いの点で、それはAgdaがHaskellであることのようなものです。コンパイラは、この新しい、より高抽象度の言語をコアFortranにトランスパイルし、次にFortranコンパイラを呼び出して高品質なネイティブバイナリを生成します。これはAgdaがHaskellを介してコードをコンパイルし、バイナリ実行可能ファイルを生成する方法です。そして、C++が既存のCライブラリとネイティブにやり取りできるのと同じように、この新しい言語は既存のFortranライブラリとネイティブにやり取りできます。

この近代化の後、結果として得られる言語は本質的には依然としてFortranです。つまり、組み込みの並列プログラミング機能を備えた、強力で静的な型付けの科学技術DSLですが、数十年前の殻はありません。そして、今日のプログラマーが愛する、馴染みのあるモダンな快適さと付属品を提供します。さらに重要なことに、Fortranとの共存は、Fortranを将来にわたって維持するのに役立ちます。この言語を「新しいFortran」と呼ぶことを不快に感じる人は、Fortranと関数型のルーツにちなんで、単に$𝓕$または$\Phi$と呼ぶことができます。

近代化

現代のプログラミング言語の中で特異なことに、Fortranは宗教的に後方互換性があります。50年前のコードでも、時間とともに追加された他の多くの構文拡張とともに、有効なモダンFortranコードです。この完全な後方互換性への執着は、Fortranを現代のプログラマーにとって忌避すべきものにしています。

確かに、言語設計者や保守者は時々間違いを犯します。それは人間性の本質です。設計更新の目的は、それらの間違いを是正することであり、増幅することではありません。何があっても、数十年前の設計との後方互換性を頑固に維持することは、後から見れば恐ろしい間違いです。怠惰または吝嗇のために古い、しかし依然としてミッションクリティカルなコードベースの更新を避けるアプリケーションオーナーを可能にすることは無意味です。もはや誰も理解していないミッションクリティカルなコードの継続的な使用は、そのミッション自体を危険にさらします。この行動は抑止されなければなりません。したがって、Fortranの歴史的なゴミは、他の多くの言語(CやC++を含む)によって採用されている通常の計画的陳腐化のパスに従い、モダンなプログラミング概念を受け入れることによって清掃されなければなりません。

構文を劇的に変更しながら意味論的コアを変更しない言語の例がありました。C 1978とC 1989の違いは顕著でしたが、計画的陳腐化は移行を円滑に進めました。Python 2からPython 3への移行はかなり厄介でしたが、最終的には完了しました。最近、プラスチック手術を受けた言語は、人気のFP言語であるScalaです。Scalaは2004年にJavaの全盛期にリリースされました。そのため、Scala 1の構文はJavaとほぼ同一でした。しかし、Scala 3が2021年にリリースされた頃には、Pythonが熱く燃えており、構文はJavaよりも明らかにクリーンなPythonに似るように大幅に変更されました。プログラミング言語の寿命において20年はほぼ永遠です。Scalaの設計者は、古くなったファッションにしがみつくのではなく、言語の継続的な成功を確保するために進化させることを選択しました。ある時点で、過去とのクリーンなブレークが必要とされます。Fortranが新しいプログラマーを引き付け続けるためには、同様のプラスチック手術を受ける必要があります。

プログラマーにとって、構文は言語との親密な接点です。そのため、プログラマーは、主にその魅力的で直感的な構文のために、言語に感情的に愛着を持つようになります。もちろん、意味論もプログラマーにとって重要であり、仕事を正しく行うためには不可欠です。高水準プログラミング言語が使用されてきた3/4世紀にわたり、いくつかの設計哲学と実装慣行が支配的なものとして浮上しました。現代の言語は、実行効率とプログラマーの生産性を促進するために、それらの良い原則に従わなければなりません。したがって、Fortranの時代遅れの構文的なぎこちなさと時代遅れな意味論的な癖の両方を近代化することが重要です。

このセクションでは、MLファミリーのFP言語に似た構文を持つ近代化されたFortran構文を提案します。この選択は意図的です。第一に、MLファミリーはISWIMという画期的なFP研究言語の、煩雑さのないオフサイドルール(意味のある空白)を使用しています。PythonはOO系統ですが、オフサイドルールに従っています。Pythonにマークを付けます。第二に、FortranはFP言語と同様に数学に大きく依存しており、FPパラダイムで最も確立された言語はMLファミリーに属しています。第三に、オフサイドルールは、慎重に選択された構文ルールの小さなコレクションとともに、Hope、Clean、Miranda、Haskell、Agda、Idris、Caml、OCaml、Coq、F*、Lean、およびMLの子孫によって実証されているように、括弧、波括弧、コンマ、セミコロン、その他の構文ノイズのない、クリーンで明確で説得力のある構文を生み出します。

このセクションで提案されている構文的および意味論的な変更は、すべてのそのような提案と同様に、「単なる好み」として却下される可能性があります。その後、会話は誰がより良い味を持っているかについての戦いにすぐに発展します。それを避けるために、私はすべての選択について理由を提供したので、それは合理的な批判の対象とすることができます。しかし、「古いやり方でやってきたので、新しいものを拒否する」と言って提案を却下することは、合理的でも有効でもありません。また、「不要で無関係な古い構文を削除する」という提案は、「私たちはそれが欲しい」という反論で対抗することはできません。なぜなら、欲求は必要ではないからです。私は絶対的な後方互換性の優位性をすでに論破しました。最後に、「Fortranでも同様のことができるが、はるかに多くの文字が必要だ」と主張しても、その議論で「Fortran」の代わりに「アセンブリ」や「0と1」を代入できるのと同じくらい無意味です。

ゴミを洗い流す

固定フォーマットの削除—モダンFortranは、テレタイプライターのために開発された1950年代のコードフォーマット規則である固定フォーマットを引き続きサポートしています。厳格な後方互換性は、モダンFortranコンパイラにこの時代遅れの規則をサポートすることを要求します。しかし、現代のプログラミングプラクティスでは、このフォーマットは恣意的で、負担が大きく、無関係です。したがって、この規則は破棄されなければなりません。

implicit none の削除—implicit noneコンパイラディレクティブは、I、J、K、L、M、Nで始まるすべての識別子をINTEGER型に、その他のすべての変数をREAL型に自動的に割り当てる古いFORTRANの機能を無効にします。テレタイプライターの時代には、この暗黙の型付け機能はキーストロークを節約するのに望ましいものでした。しかし、現代のプログラミング言語(モダンFortranを含む)の強力な静的型付けの哲学に反します。そのため、すべてのモダンFortranモジュールファイルは、暗黙の型付けを無効にするために、この呪文で始まります。

この機能は、CやC++を含む数え切れないほどの他の言語で採用されている計画的陳腐化プロセスを通じて、ずっと前に削除されるべきでした。例えば、The C Programming Language、第1版(1978年)に登場した元のC構文は、1990年代初頭まで使用されていましたが、2020年代初頭のモダンCコンパイラではもはや受け入れられません(そして受け入れられるべきではありません)。実際、ほとんどの現代のCプログラマーは、1970年代スタイルのCコードを理解できません。しかし、絶対的な後方互換性への非合理的な固執は、モダンFortranプログラマーにすべてのモジュールにimplicit noneを挿入することを義務付けています。

implicit noneは、Fortranの近代化への長い道のりに散らばる多くの悪い設計上の決定の1つです。暗黙の型付けの無効化は、ファイル名の拡張子(例: .f90)やコンパイラフラグ(例: --ImplicitNone)からトリガーされるべきであり、ずっと前に言語から削除されるべきでした。しかし、設計者はこの余分な機能を永久に保持し、プログラマーにすべてのモジュールで手動で暗黙の型付けを無効にすることを強制することを選択しました。結果として、このステートメントはコード内でdoやifと同じくらい一般的ですが、実質的な作業は行いません。このような無意味で難解な呪文は、モダンFortranを冗長にするだけでなく、いかなる相殺する利益も提供せずに、その可読性を低下させます。

肥大化をトリミング

型定義のトリミング—プログラムを読みやすくするためには、構文から冗長性を排除する必要があります。モダンFortranは、ユーザー定義の積型(product type)をサポートしており、これを派生型と呼びます。以下のような肥大化したコードを見かけることは珍しくありません。

type :: point3d
  integer, parameter :: k8 = selected_real_kind(8)
  real(kind=k8) :: x
  real(kind=k8) :: y
  real(kind=k8) :: z
end type point3d

type(point3d) :: p

p = point3d(3.0, 2.0, 1.0)

この冗長性は、過剰で、退屈で、混乱を招き、読みにくく、エラーを起こしやすいです。上記のコードは、新しい言語の以下のHaskell風構文に削減できます。

Point3D : point3d {x y z : ℝ} ## レコード型を宣言
p = point3d {x = 3.0, y = 2.0, z = 1.0} ## レコード値を定義

上記の宣言Point3D : point3d {x y z : ℝ}では、左側のPoint3Dは型コンストラクタであり、右側のpoint3dは{x y z : ℝ}の形状のレコードを受け取る値コンストラクタです。これは、3つの名前付き$\mathbb{R}$型の値のレコードです。簡単にするために、型エイリアスにも同じ構文が使用されます。2行目では、値コンストラクタpoint3dがレコード値pを構築するために値${3.0, 2.0, 1.0}$に適用されます。このレコードのフィールドはp.x、p.y、p.zとしてアクセスされます。

Haskellのような単純な型システムを持つ言語では、型と値は異なるドメインに存在するため、型コンストラクタ(Point3D)とその関連値コンストラクタ(point3d)に同じ名前を付けることができます。しかし、私たちの依存型言語では、型が値に依存できるため、型コンストラクタ(Point3D)とその関連値コンストラクタ(point3d)には異なる名前が必要です。

慣例として、型コンストラクタは大文字で表記し、値コンストラクタは小文字で表記します。値コンストラクタは通常の関数であるため、これは関数名を大文字にしないというHaskellの慣例に従っています。

kindの削除—歴史的な理由から、Fortranはkind選択と呼ばれる複雑で混乱を招くメカニズムを通じて、いくつかの異なる数値表現をサポートしています。上記のpoint3d例では、selected_real_kind(8)は8バイトの倍精度浮動小数点kindセレクタをk8(型はinteger)として定義するために使用され、k8は次にx、y、zという3つの倍精度浮動小数点変数を定義するために使用されます。この構文は、控えめに言っても過剰です。この混乱の主な目的は、プログラマーが望む精度に必要な最小バイト数を選択できるようにし、それによってメモリ使用量を節約することです。しかし、複数の数値型表現を許可することは、ハードウェアプラットフォーム間で互換性の問題を引き起こす可能性があります。そして、メモリ節約がもはや最優先事項ではない現代のプログラミングプラクティスでは、これらのバイトレベルの懸念は不要です。

さらに、「kind」という言葉は現代の型理論における専門用語です。これは高階型、つまりHaskellにおける「型の型」を指します。つまり、値が型によって分類されるのと同じように、型はkindによって分類されます。したがって、数値表現を参照するために「kind」という用語を使用することは、1つの数値型に対して複数の互換性のない表現を許可するという古風な慣行とともに放棄されるべきです。

ビット操作の削除—C、C++、Odin、Zigのようなシステムプログラミング言語はビットを操作する必要がありますが、Fortranのような科学技術DSLはビット操作演算子(&、|、~など)を必要としません。結局のところ、ビットはハードウェアレベルの概念です。したがって、ビット操作を使用して、増分的な線形速度向上を得る、ハードウェアエミュレーションを実行する、またはネットワークパケットやメディアファイルからバイナリデータを読み取るなどのタスクは、真のシステムプログラミング言語に任せるのが最善です。そのような機能は、私たちの数学的なDSLには属しません。

オブジェクトの削除—Fortranのような科学技術DSLはOOを必要としません。通常の和型(sum types)、積型(product types)、関数、汎関数(functionals)、型クラス、モジュールは、数学的および科学的な概念をモデル化するのに十分以上です。オブジェクトは、相互に作用するビジネスプロセスの巨大な絡み合いをモデル化し、それらの複雑な状態の相互変更を隠すためによく使用されます。オブジェクトは、単一プロセッサで実行される大規模な逐次ビジネスアプリケーションを実装する概念を表し、コードを整理するのに便利(つまり、都合が良い)です。しかし、オブジェクトの性質そのもの—変更の相互作用を隠蔽する傾向—は、マルチプロセッサで実行される大規模な並列科学アプリケーションの実装には不向きです。

Fortran 2003標準で導入された主な機能はオブジェクトでした。OOは2000年代初頭の支配的なパラダイムであったため、この標準への拡張は当時歓迎されました。しかし今日では、OOの隠された状態変更がコードの可読性と実行の並列化に有害であることが確立されています。私の見解では、FortranのOOの採用は誤りでした。Fortranは、Simula、Smalltalk、Objective-C、C++、Java、Python、および最初からオブジェクト指向である他の多くの現代言語とは異なり、OOの腕前で知られていませんでした。さらに、単にオブジェクトを標準に投げ込んでも言語がOOになるわけではありません。構文はオブジェクトの作成と操作を便利で楽なものにしなければなりません。SmalltalkとPythonはその点で優れていますが、Fortranは大きく不足していました。それはさておき、Fortranの数学的な傾向を考えると、FPはFortranにとってOOよりも優れた求婚者です。

変数宣言のトリミング—以下は、モダンFortranで2次元浮動小数点配列を宣言および定義する方法です。

real, dimension(:, :), allocatable :: y ! 行列を宣言

allocate(y, 2, 3) ! 初期化されていない2x3行列を割り当て

以下は、標準ライブラリの依存型 Matrix ℝ 2 3([ℝ 2 3]とエイリアス化)を使用した新しい言語での同等の配列定義です。これは要素型$ℝ$でパラメータ化され、サイズ値で二重にインデックス付けされています。また、以下のコードスニペットでは、行列yの要素は自動的に$0.0$に初期化されます。これはほとんどの場合、プログラマーが望むことです。

y : [ℝ 2 3] ## 要素が0.0に初期化されたℝ型2x3行列を定義

関数定義のトリミング—以下は、モダンFortranでのクイックソートの実装です。簡単のため、この実装はナイーブな二重再帰を使用し、整数配列のみを引数として受け取ります。

recursive function qsort(x) result(y)
  integer, dimension(:), intent(in) :: x
  integer, dimension(1:size(x)), intent(out) :: y
  if (size(x) > 1) then
    y = (/ qsort(pack(x(2:), x(2:) < x(1))), & 
           x(1), & 
           qsort(pack(x(2:), x(2:) >= x(1))) /)
  else
    y = x
  end if
end function qsort

上記の通り、この単純な関数の構文には多くのゴミがあります。対照的に、新しい構文での同等の実装は簡潔であり、さらに重要なことに、可読性と理解しやすさがあります。

qsort : (n : ℕ) ⇒ [ℤ n] → [ℤ n]
  | [] → []
  | x,xx → qsort [l | l ← xx, l < x] + [x] + qsort [g | g ← xx, g ≥ x]

上記のように、クイックソートアルゴリズムは、Fortranの構文的なスパイクをたどる必要なしに、新しい構文で読者にすぐに目に飛び込んできます。上記のx,xxという表記は、要素がxで、残りがxxというサブベクトルであるベクトルを指します。型注釈には:を、クラスインスタンス化には::を使用する(下記参照)ため、ベクトルの要素を区切るには,を使用します。

型宣言qsort : (n : ℕ) ⇒ [ℤ n] → [ℤ n]は、関数qsortがサイズnの整数ベクトルを引数として受け取り、同じサイズの整数ベクトルを返すことを示しています。ここで、[ℤ n]は依存型Vector ℤ nのショートハンド構文です。そして、二重矢印構文(n : ℕ) ⇒はnの型を$\mathbb{N}$に制約します。したがって、標準ライブラリで定義されているこのベクトル型は、型$ℤ$でパラメータ化され、型$\mathbb{N}$の変数nの値でインデックス付けされています。この単一行の関数型宣言は、かさばる3行のFortranコードを置き換えます。

recursive function qsort(x) result(y)
  integer, dimension(:), intent(in) :: x
  integer, dimension(1:size(x)), intent(out) :: y

このqsort実装では、最初の節のパターンパラメータ[]は空ベクトル引数にマッチします。ソートされた空ベクトルのソートバージョンは空ベクトルであるため、最初の節は単に値[]を返します。2番目の節のパターンパラメータx,xxは非空ベクトル引数にマッチし、変数xは最初の要素に、変数xxは残りの要素に束縛されます。[l | l ← xx, l < x]は、数学における$L =$ {$ l \mid l \in X, l \lt x$}の集合内包表記のアナログであるベクトル内包表記構文です。このフレーズは、ピボット要素xよりも小さい要素をフィルタリングしたベクトルを動的に構築します。同様に、ベクトル[g | g ← xx, g ≥ x]、またはそのアナログである集合$G =$ {$g \mid g \in X, g \ge x$}は、xxのx以上でフィルタリングされた要素を保持します。次に、ソートされた小さいベクトル、ピボット要素xを含む単集合ベクトル[x]、およびソートされた大きいベクトルが、オーバーロードされた+演算子を使用して結果ベクトルに連結され、この結果が2番目の節から返されます。このバージョンのqsortは、アルゴリズムの数学的記述のように読めます。ハードウェアビットではなく、数学的議論への近さが、FP言語の推進力です。そして、Fortranのような科学技術DSLは、この設計を採用すべきです。

上記のx,xx構文では、演算子,は標準ライブラリのベクトルコンストラクタ関数consにエイリアスされています。この関数を要素xとベクトルxxに適用すること(cons x xx)は、LISPの伝統に従って、慣例的にFP言語でxxの先頭にxを付加します。FPではこの構成が頻繁に発生するため、x,xxというショートハンド構文があります。,はベクトルリテラルコンストラクタとしてもオーバーロードされていることに注意してください(例: [1, 2, 3])。算術演算子+も同様にオーバーロードされています。これは標準ライブラリのベクトル連結関数catにエイリアスされています。したがって、cat u vはu + vと同じです。これらのシンボルがベクトル操作のコンテキストで現れる場合、,をcons(LISPの伝統に従って)と発音し、+をcat(UNIXの伝統に従って)と発音します。

古い記憶を忘れる

手動メモリ管理の削除—手動メモリ管理は、ランタイムエラーの主な原因であることが長年知られています。手動メモリ管理は、大規模なコンピュータがわずか数キロバイトのRAMしか持たなかった時代や、モダンで効率的なガベージコレクション(GC)技術が登場する前に不可欠でした。LISPが最初にGCを採用したことに注意してください。しかし、GCがメインストリームの産業用言語で使用できるほど高速になったのは1990年代になってからです。

今日では、Haskell、Java、C#、Kotlin、Go、Swiftなど、ほとんどの言語がGCによる自動メモリ管理を備えています。手動メモリ管理に依存している言語(必要性から)は、C、Odin、Zigのようなシステムプログラミング言語だけです。Nimは自動メモリ管理を備えていますが、必要に応じてプログラマーが制御できるようにしています。Rustの所有権モデルは、アフィン型(部分構造型システム)に基づいています。これは、オブジェクトが常に1つの所有者によって所有(参照)されていることをコンパイラが自動的に保証するために、プログラマーがコードにヒントを手動で提供することを要求します。したがって、コンパイラはもはや使用されていないオブジェクトを自動的に解放できます。この動作は一般的に「参照借用」と呼ばれます。

不動産法用語では、借用は所有権ではなく、単なる占有権です。したがって、「所有権モデル」というラベルは技術的には不正確です。しかし、脱線します。

ある意味で、Fortranの現在のメモリ管理アプローチはNimのものに似ています。しかし、私はFortranがさらに一歩進むべきだと主張します。手動メモリ管理を完全に放棄することです。第一に、Fortranはシステムプログラミング言語ではないため、メモリ管理のようなハードウェアレベルの懸念をいじるべきではありません。第二に、大規模ビジネスアプリケーションのメモリアクセスパターンは外部イベントによって駆動されるため無秩序ですが、大規模科学アプリケーションのメモリアクセスパターンは内部ロジックによって駆動されるため順序付けられています。このような単純なメモリ使用パターンは、最新のコンパイラやGCによって容易に最適化できます。第三に、最新の自動メモリ管理技術は、GCが手作業で調整されたメモリ管理コードを上回るパフォーマンスを発揮できるレベルまで進歩しています。

ポインタの削除—不注意なプログラマーは日常的にプログラムを破壊します。彼らが選ぶ犯罪現場は、手動メモリ管理の領域です。彼らが好む凶器は、古代からプログラム暗殺者に人気のある、針のように鋭いポインタです。

ポインタはシステムプログラミングでは非常に役立ちます。熟練したプログラマー(少数派)の手にかかれば、ポインタはおそらく効率的なメモリアクセスのための最も便利なツールです。しかし、通常のプログラマー(大多数)は、ハードウェアからその最後のわずかな効率を引き出すのに十分なスキルがなく、最適化に関しては、平均的なコンパイラよりも優れることはほとんどありません。キロバイト時代の後の手動ポインタ操作の得失のバランスは、大幅に損失に傾いています。そのため、ほとんどの現代言語はポインタを廃止しました。Fortranもそうすべきです。それに、Fortranではポインタの使用は後付けです。実際、ポインタの使用は、Fortranではコードを遅くすることがあります!

私は、現代のFortranプログラマーが計算に対する見方を根本的、哲学的なレベルで変えることを強く勧めます。彼らはプログラミングの古代の「システムアプローチ」を捨て、現代の「関数型アプローチ」を採用すべきです。FPプログラマーは1970年代と1980年代にこのパースペクティブシフトを経験しました。今日、彼らはそのおかげでより良くなっています。なぜなら、ハードウェア技術とソフトウェア技術が彼らの願望に追いついたからです。Fortranプログラマーもまた、メモリ節約やポインタ操作のような、数多くのハードウェアレベルの懸念に対する制御を手放すことに慣れる必要があります。彼らの時間と労力は、オーダー数桁高速な優れた並列アルゴリズムの設計と、メモリ消費のオーバーヘッドはあるものの、はるかに読みやすいコードに費やす方が収益性が高いです。さらに重要なことに、ポインタによるエイリアス参照は型安全性に損害を与えます。メモリ使用量の制御を手放す代わりに、プログラミングの利便性、コードの明瞭さ、ソフトウェアの保守性、およびランタイムの安全性を得られます。

明示的なポインタの最も明白な代替手段は、もちろん、暗黙の参照です。ほとんどの現代言語はこのアプローチを採用しています。

現代性を受け入れる

モダンなコメントスタイルを使用する—ドキュメンテーションコメントを#<と#>で区切ります。<と>のシンボルは開いた本を連想させます。ブロックコメントを#{と#}で区切ります。{と}のシンボルはCコードブロックを連想させます。両方の開始と終了コメントマーカーは#シンボルで始まることに注意してください。これは一貫性のためです。インラインコメントは##で開始します。#シンボルを二重にすることで、コードの背景に対して視覚的に目立ち、すべてのコメントシンボルがペアになるため、一貫性のマークとなります。

また、過剰で目立つコメントは避けてください。以下に示す叫ぶようなコメントは無視できないかもしれませんが、読者に洞察に満ちた情報を提供しません。

!*********************************************************************
!* FILE: QUICKSORT.F90                                               *
!* This function sorts an input array using the quicksort algorithm. *
!* It accepts a 1D array and returns a sorted 1D array.              *
!*********************************************************************

微妙さが美徳です。コードのコメントに関しては、モジュールのブロックコメントで、アクセスしやすい権威あるソースを参照する方が、理解不能で形式的な説明を詰め込むよりも良いでしょう。

#< GraphSearch.f
This module implements bread-first and depth-first
graph searching algorithms as described in
Chapter 20 Elementary Graph Algorithms of
"Introduction to Algorithms", 4ed (2022), Cormen et al. #>

一般的なプリミティブ型を使用する—多くのモダンな高水準言語は、ブール値、文字、整数、自然数、浮動小数点数のみを使用します。ブール値は1バイト、自然数はネイティブバイナリで表現された符号なし64ビット値、整数は2の補数バイナリで表現された符号付き64ビット値、浮動小数点数はIEEE 754形式で表現された64ビット値です。これらのプリミティブデータ型は科学技術計算には十分です。これらをそれぞれBol、Nat、Int、Fltと呼びます。より高い精度を持つ大きなデータ型は標準ライブラリで定義されています。無限精度整数はInteger、128ビット整数はInt128、128ビット浮動小数点数はFlt128です。Nat、Int、Int128、Integer、Flt、Flt128の型は数値クラスNumを構成します。Character型はUnicodeで表現される可変バイト値であり、String型はUnicode文字列です。

新しい言語では、$\mathbb{N}$はゼロベースの自然数(インデックス番号)の集合を表し、範囲は$[0, \infty]$です。ここで$∞$は表現可能な最大数にエイリアスされます。$\mathbb{Z}$は整数${-∞, +∞}$の集合を表し、$\mathbb{R}$は実数${-∞, +∞}$の集合を表します。

標準ライブラリは、利便性のために追加の型エイリアスを定義しています。

ℤ⁻ : (n : ℤ) < 0
ℤ⁺ : (n : ℤ) > 0
ℤ± : (n : ℤ) ≠ 0
ℝ⁻ : (r : ℝ) < 0.0
ℝ⁺ : (r : ℝ) > 0.0
ℝ± : (r : ℝ) ≠ 0.0

$\mathbb{Z}^-$はゼロでない負の整数の集合、$\mathbb{Z}^+$はゼロでない正の整数の集合(計数)、$\mathbb{Z}^\pm$はゼロでない整数の集合を表します。同様に、$\mathbb{R}^-$はゼロでない負の実数、$\mathbb{R}^+$はゼロでない正の実数、$\mathbb{R}^\pm$はゼロでない実数の集合を表します。

$\mathbb{R}^\pm$型を使用すると、例えば、ランタイムでの$⊥$(未定義値)を心配することなく、実数xの逆数を表現できます。なぜなら、型システムがそれを保証するからです。

x : ℝ± ## xは0.0であってはならない
...
1 / x ## ⊥の危険はない

有理数、複素数、四元数のデータ型は、標準ライブラリのレコードとして実装されています。

Rational : rational {n : ℤ, q : ℤ±} ## qは0であってはならない
ℚ : Rational

Complex :
  | rectangular {x y : ℝ}
  | polar {r 𝜑 : ℝ}
ℂ : Complex

Quaternion :
  | rectangular {a : ℝ, v : [ℝ 3]}
  | polar {m 𝜃 : ℝ, n : [ℝ 3]}
ℍ : Quaternion

上記では、型Rationalをレコード{n : ℤ, q : ℤ±}として定義しました。これは数学的量$n/d$を表し、$n ∈ \mathbb{Z}$およびゼロでない$d ∈ \mathbb{Z}^\pm$です。左側のRationalは型コンストラクタであり、右側のrationalは{n : ℤ, q : ℤ±}の形状のレコードを返す値コンストラクタです。型Complexは、2つの積型、rectangularとpolarの和として定義されます。つまり、Complexは和積型です。同様に、型Quaternionもそうです。

レコード型の要素を宣言するために,区切り文字を使用していることに注意してください。例えば、上記のComplex型では、{x : ℝ, y : ℝ}のように、rectangularレコードのxとy要素は、同じ型の要素間の,区切り文字なしで、より簡潔に{x y : ℝ}として宣言できます。

利便性と簡潔さのために、以下のショートハンド型エイリアスが提供されています。$\mathbb{B}$はBol、$\mathbb{U}$はUnicode Character、$\mathbb{S}$はUnicode String(Unicode文字のリスト[𝕌])、$\mathbb{N}$はNat、$\mathbb{Z}$はInt、$\mathbb{Q}$はRational、$\mathbb{R}$はFlt、$\mathbb{C}$はComplex、$\mathbb{H}$はHamiltonian Quaternion、$\mathbb{V}$はVector、$\mathbb{M}$はMatrix、$\mathbb{T}$は3次元以上のTensorです。標準ライブラリは、String型をCharacter値のVectorとして定義しています。慣例として、プリミティブ型にはBolやIntのような短い名前を使用しますが、非プリミティブ型にはIntegerやVectorのような長い名前を使用します。

システムGPL(Cなど)でのビット操作に役立つunsigned型は、自然数$\mathbb{N}$と計数$\mathbb{Z}^+$を表す場合を除き、Fortranのような科学技術DSLでは役に立ちません。新しい言語は自然数と計数の両方をサポートしますが、Cのようなビットレベルのunsigned型はサポートしません。

Unicodeシンボルは、$\pi$、$\sigma$、$\le$、$\ge$、$\sqrt{}$、$∞$、$⊥$、$⊤$、$\lnot$、$\land$、$\lor$、$\emptyset$、$\otimes$、$\oplus$などの識別子名としてコードで使用できます。これらのシンボルは、Agdaで行われるように、標準の$\LaTeX$コマンドを使用して入力されます。IDEはショートカットキーを提供できます。

派生型(derived type)の名称変更—ユーザー定義の積型を「派生型」と呼ぶのは、OOの専門用語であり、今日Fortranの新規参入者のほとんどがすでにOOをよく知っているため、トラブルを招きます。代わりに、ユーザー定義の積型を、他のすべてのモダン言語と同様に、単に「レコード」と呼びましょう。単に異なるためにバズワードを再定義することは、利益を提供せずに混乱を引き起こします。

大文字小文字の区別なしの削除—Fortranは、その半世紀前の言語的ルーツを維持しており、大文字小文字を区別しません。これは、現代のプログラミング言語の慣例に沿っていません。大文字小文字の区別なし、より正確にはすべて大文字の使用は、テレタイプライターしか大文字しか印刷できなかったため、コンピューティングの初期には一般的でした。しかし今日、それらは可読性の低下のため避けられています。

命名規則の標準化—Fortranには、一貫した業界標準の命名規則がありません。そこで、新しいFortranのために一貫した命名規則を採用します。可読性のために、Smalltalk、Java、Haskellに似た命名規則を採用します。この規則は、簡潔、一貫性、説得力、理解しやすさによって、数十年にわたってその価値を証明してきました。

  • -区切り文字、_区切り文字、ALL_CAPS、その他のノイズの多い命名規則は避けてください。代わりに、より読みやすいPascalCaseとキャメルケースを使用してください(コンパイラは識別子名からそのようなノイズを強制的に削除します)。
  • 型名にはPascalCaseを使用してください:Vector、Matrix、Point2D
  • 型パラメータ名には小文字のギリシャ文字を使用してください:Point2D (𝛼 : Num)、ここで𝛼はNat、Int、Int128、Flt、Flt128、またはIntegerを含むNumクラスの数値型に置き換えることができます。
  • 変数名と関数名にはキャメルケースを使用してください。
  • ファイル名にはPascalCaseを使用し、モジュール名は自動的にファイル名と同じになります。
  • .fファイル拡張子を新しい言語のために再利用します。

フォーマットの標準化—インデント時には、4スペースではなく2スペースを使用し、タブは使用しません。モダンIDEはインデントされたコードを区切る垂直線を表示するため、伝統的な深いインデントはもはや可読性のために必要ありません。単に水平画面領域を奪うだけです。空白行は可能な限り避けてください。それらは明瞭さを助けず、単に垂直画面領域を奪うだけです。

これらのフォーマットガイドラインは、コードを水平方向と垂直方向の両方で縮小するのに役立ち、画面あたりのコード量を増やします。一度に画面で見えるコード量が増えると、認知負荷と過剰なスクロールが軽減されます。

ユーザー定義のシンボリック演算子の許可—最初の高水準言語として、Fortranは算術演算子、関係演算子、論理演算子を発明しましたが、<には.LT.、==には.EQ.、>には.GT.などを使用しました。これらのドット付き演算子は、当時使用されていたテレタイプライターには数学記号や小文字をサポートする機能がなかったため、奇妙に見えるかもしれませんが、必要でした。やがて、言語は演算子のためのモダンなシンボリック規約に収束しました。Fortranでさえ、最終的には古いスタイルのドット付き単語演算子を放棄し、モダンなシンボリック演算子を採用しなければなりませんでした。

今日、多くの言語はプログラマーが独自のシンボリック演算子を定義することを許可しています。例えばHaskellでは、多くの標準演算子は言語に組み込まれているのではなく、有名なモナドbind演算子とそのシンボリックエイリアス>>=のような標準ライブラリモジュールで定義されています。しかし、Fortranは、読みにくく制約的で、相殺する利益のない、ユーザー定義演算子のためのドット付き単語の古い規約を使用することを主張しています。

新しい言語では、演算子はAgdaスタイルのミックスフィックス構文を使用して導入されます。ここでは、_シンボルが引数プレースホルダーを表します。

Bol :
  | false
  | true
𝔹 : Bol

¬_ : 𝔹 → 𝔹
  | false → true
  | true → false

_∧_ : 𝔹 → 𝔹 → 𝔹
  | false ∧ _ = false
  | true ∧ b = b

_∨_ : 𝔹 → 𝔹 → 𝔹
  | false ∨ b = b
  | true ∨ _ = true

p, q : 𝔹
...
¬ p
p ∧ q
p ∨ q

上記では、プレフィックス演算子$\neg$とインフィックス演算子$\land$および$\lor$を定義しました。そして、次のようにポストフィックスの階乗ユーザー定義演算子!を実装できます。

_! : ℕ → ℕ
  | 0 → 1
  | n → n * (n - 1)!

バッククォート演算子は、通常の二項関数funcをインフィックス関数に変換するために使用できます。このインフィックス関数は、シンボリック演算子にエイリアスすることができます。

func : 𝛼 → 𝛼 → 𝛼 | a b → ...
_⊛_ : `func`
...
x ⊛ y ## func x y を呼び出すのと同じ

レコードフィールドへのアクセスに.演算子を使用する—Fortranが使用する%演算子ではなく、事実上の業界標準である.演算子をレコードのフィールドにアクセスするために使用します。この方法でのFortranの%の使用は残念です。なぜなら、現代の言語では%シンボルはモジュロ演算子を表すからです。さらに、Fortran構文record%field%subfieldは、一般的な構文record.field.subfieldと比較して見苦しいです。

行優先順序を使用する—すべての人気のあるモダン言語は、多次元配列に行優先順序を使用します。つまり、多次元配列の最も右のインデックスが最も速く変化します。これは、オドメーターの最も右の桁が最も速く変化するのと同じように、またはターミナルのカーソルが最初に画面を水平方向に移動し、次に垂直方向に移動するのと似ています。

Fortranは常に列優先順序を使用してきました。なぜなら、数学的な慣習ではベクトルを列ベクトルとして定義するからです。コンピューティングの初期には、確立されたメモリレイアウトの慣習はありませんでした。しかし今日、列優先順序は、行優先順序を採用しているモダン言語にすでに精通している新規参入者にとって混乱の原因となっています。

関数に固執する

命令形(imperative)の削除—FP言語の最も重要な側面の一つは、純粋な副作用のない式をサポートすることであり、それによって純粋関数が構築されます。純粋関数はプログラマーにとって理解しやすく、コンパイラにとって並列化しやすいことが長年知られています。副作用のある命令文は避けるべきです。なぜなら、それらは副作用のない宣言的な式とうまく連携しないからです。したがって、Fortranの命令型制御文は式に変換され、命令型のループ構造は再帰に置き換えられる必要があります。そして、究極の命令型構造であるgotoはゴミ箱行きです。

宣言形(declarative)を受け入れる—1977年のACM チューリング賞受賞講演で、FORTRANの父であるBackusは、プログラミングがより高次の平面に進むためには、命令型PPを捨てて宣言型FPを採用しなければならないと述べました。これは、FORTRAN 1977という第二標準が公開された年でもありました。しかし、50年後、Fortranは命令型パラダイムに頑固に留まっていますが、ほとんどの現代言語は、部分的にまたは完全に宣言型パラダイムに移行しています。

汎関数(functionals)のサポート—FPを受け入れることは、高階関数(関数)をサポートすることを意味します。これは、関数が他の関数を第一級の値として受け取り、返すものです。通常の関数$f : x \to y$は、プリミティブ、タプル、レコード、または列挙型である通常の値 $x$と$y$を受け取り、返します。そして、汎関数$h : f \to g$は、関数値 $f$と$g$を受け取り、返します。例えば、微積分では、微分演算子$\frac{d}{dx}$を$sin(x)$関数に適用すると、$cos(x)$関数が結果として得られます。関数を受け取り別の関数を返す微分演算子は、汎関数です。匿名関数(𝜆関数)をその場で作成することもFPの不可欠な部分です。同様に、関数合成演算子—左パイプ<|(数学的演算子∘と同じ)、右パイプ|>(数学的演算子$;$およびUnixシェルパイプ|と同じ)—もFPイディオムの不可欠な部分です。以下のコードは、新しい言語でサポートされている𝜆関数構成の使用方法を示しています。fold-left標準ライブラリ汎関数foldlは、𝜆関数、初期値、およびベクトルを受け取ります。𝜆関数は、アキュムレータaとベクトル要素xを引数として取ります。

foldl (𝜆 a x → a + x) 0 [3, 5, 7, 9] ## 24を返す

上記のコードの関数適用構文に注意してください。関数foldlは、𝜆関数、初期値0、およびベクトル[3, 5, 7, 9]の3つの引数に適用されます。関数を引数に適用する際に括弧は不要です。したがって、数学では関数適用が$f(x)$と書かれるのに対し、Haskellではf xと書かれます。この構文は明確で、簡潔で、静かです。ちなみに、ベクトル、初期値、および𝜆関数は、まとめてモノイドと呼ばれる代数的構造を形成します。

<|および|>合成演算子は次のように使用されます。

g <| f x ## g ∘ f と同じ、「g after f」と読む
f x |> g ## f ; g と同じ、「f then g」と読む

Fortranも関数を引数として渡すことをサポートしています—まあ、ある意味では。Fortranのpackプロシージャは、FP言語のfilter汎関数のアナログです。packという名前は、結果配列が元の引数配列よりも小さい場合に占めるメモリの圧縮を反映していることに注意してください。ハードウェアレベルの懸念に対するこの過度の執着は、科学技術DSLにはふさわしくありません。以下は、配列から5より大きい要素をフィルタリング(選択)するためのFortranコードです。

integer :: xx(:) = (/ 6, 1, 3, 7, 4, 8, 5, 2, 9, 0 /)
integer, allocatable :: packed(:)
packed = pack(xx, xx > 5) ! (/ 6, 7, 8, 9 /) を返す

そして、これが新しい構文での同等のコードです。filter標準ライブラリ汎関数は、𝜆関数とベクトルを受け取ります。𝜆関数は、ベクトルxxから順次引き出される要素である引数xを取ります。

xx = [6, 1, 3, 7, 4, 8, 5, 2, 9, 0] ## 型は[ℕ 10]と推論される
filtered = filter (𝜆 x → x > 5) xx ## [6, 7, 8, 9] を返す

科学技術DSLとして、新しい言語はFPを完全にサポートする必要があります。そのため、関数の定義(抽象化)と呼び出し(適用)のための簡潔で便利な構文を提供します。しかし、Fortranの現在のFPサポートは、大いに改善の余地があります。ラムダ抽象のサポートなし、関数合成演算子のサポートなし、そしてサポートされているわずかな関数機能も構文的に煩雑です。

節関数(clausal functions)のサポート—名前付き関数は、Standard MLの関数定義と同様の方法で、複数節のパターンマッチングによって定義できます。以下は、複素数の絶対値演算子の定義であり、実数の絶対値演算子(絶対値)を使用しています。

## 実数の絶対値演算子
|_| : ℝ → ℝ
  | a < 0.0 → 0.0 - a
  | _ → a

## 複素数の絶対値演算子
|_| : ℂ → ℝ
  | rectangular {x, y} → √ (x² + y²) ## _² は _^2 と書く
  | polar {r, _} → |r|

c = rectangular {x = 4.0, y = 3.0}
mod = |c| ## mod は 5.0

上記の演算子は両方とも複数節関数です。標準ライブラリは演算子√を関数sqrtにエイリアスしています。2番目の節でPolarレコードの$\phi$フィールドを使用する必要がないため、_シンボルを使用して無視します。また、|_|でのこのシンボルのオーバーロードされた使用に注意してください。ここでは、絶対値演算子の単一引数のプレースホルダーとして使用されています。

上記のコードは次のように読むことができます。

  • 複素数の絶対値演算子|_|は$\mathbb{C}$型の引数を取り、$\mathbb{R}$型の値を返します。
  • 引数がrectangular形式$x + iy$の場合、結果は$\sqrt{x^2 + y^2}$です。
  • しかし、引数がpolar形式$r\angle{\phi}$の場合、結果は$\lvert r \rvert$であり、これはオーバーロードされた実数の絶対値演算子|_|を使用して計算されます。

id関数(下記で定義)は、単一節関数の例です。ここには1つの節しかないにもかかわらず、視覚的な一貫性のために、節の開始シンボル|を使用します。

id : 𝛼 → 𝛼
  | x → x

引数を変換しない関数であるidの有用性は何でしょうか?関数型言語は、データとコードの両方を操作します。つまり、言語は値と関数の代数であり、idは、演算子+の恒等値が$0$、*の恒等値が$1$であるのと同じように、汎関数(高階関数)の恒等関数です。1977年のACMチューリング賞受賞講演で、FORTRANの父であるBackusは、プログラミングが高次の平面に進むためには、命令型PPを捨てて宣言型FPを採用しなければならないと述べました。これは、FORTRAN 1977という第二標準が公開された年でもありました。しかし、50年後、Fortranは命令型パラダイムに頑固に留まっていますが、ほとんどの現代言語は、部分的にまたは完全に宣言型パラダイムに移行しています。

ラベル付き引数のサポート—OCamlスタイルのラベル付き関数引数は、呼び出しサイトでそれらの引数の意味を明確にするのに役立ちます。

filter : selector~(𝛼 → 𝔹) → vector~[𝛼] → [𝛼]
...
filter selector~(𝜆 x → x > 5) vector~xx

ラベル付き引数のもう一つの用途は、部分適用です。以下では、同じ部分適用関数(selectedPeople)に異なるセレクタ述語(child?とtall?)を渡すことで、複数のフィルタリングされたリスト(childrenとlongshanks)を作成しました。

pp : [Person]
...
selectedPeople = filter vector~pp
child? = 𝜆 p → p.age < 18 ## 18歳未満
tall? = 𝜆 p → p.height >= 1.8 ## 身長1.8m以上
...
children = selectedPeople selector~child?
longshanks = selectedPeople selector~tall?

上記では、ラベル付き引数構文により、最初の位置引数selectorをスキップし、2番目の位置引数vectorに人物のリストppを適用して、部分適用関数selectedPeopleを作成できます。ラベル付き引数は、ラベル付きレコードフィールドが順序付けられたタプルフィールドに追加する柔軟性と同様に、それ以外は厳密に順序付けられた関数引数に柔軟性を追加します。

オプション引数のサポート—もう一つのOCamlからの機能であるオプション引数(デフォルト値付き)をサポートしています。以下では、関数wordsは、入力文字リストを単語のリストに分割します。デフォルトの区切り文字はスペースです。呼び出し元は区切り文字のリストを指定できます。

words : separator~[𝕌]=[' '] → stream~[𝕌] → [𝕊]
...
cc = ... ## Unicode文字のストリーム
words stream~cc ## デフォルトの' '区切り文字を使用
words [' ', ',', ';', ':', '.'] cc ## 指定された区切り文字を使用

純粋関数のサポート—Fortranは関数にpureキーワードをマークすることを許可しています。新しい言語では、すべての関数はデフォルトで純粋です。

内部関数のサポート—Fortranは、多くの小さな単回使用関数で名前空間を汚染するのを避けるのに役立つ内部関数の定義方法も提供します。Fortranでは、内部関数は内部プロシージャと呼ばれます。しかし、その内部プロシージャ構文は、それに見合うだけの価値がある以上の手間がかかります。以下に、Fortranで内部関数がどのように定義され、呼び出されるかを示す創作例を示します。

pure function external(i) result(o)
  real, intent(in) :: i
  real, intent(out) :: o
  o = g(i) - 2.0

  contains
    pure function internal(x) result(y)
      real, intent(in) :: x
      real, intent(out) :: y
      y = x**3.0
    end function internal
end function external

この醜く肥大化したFortranコードを、新しい言語の同等の、洗練されたコードと比較してください。

external : ℝ → ℝ
  | i → internal i - 2.0
    where internal : ℝ → ℝ | x → x³

このコードのwhere句は、数学の$where$句に似ています。ローカル定義を作成する簡潔な方法を提供します。関数internalのスコープは、関数externalの本体です。

where句の代わりに、let-in構成を使用してinternal関数を導入できることに注意してください。

external : ℝ → ℝ
  | i → let internal : ℝ → ℝ | x → x³
        in internal i - 2.0

Haskellと同様に、let-inとwhereの間には微妙な違いがあります。

  • let-inは現在のスコープ内に新しいブロックを作成し、導入されたローカル定義のスコープはその新しいブロックです。
  • whereは関数内でのみ使用でき、導入されたローカル定義のスコープは関数の本体全体です。

ちなみに、let-inはJavaScriptのlet宣言に、whereはJavaScriptのvar宣言に似ています。

副作用のある関数をマークする—前述のように、新しい言語ではすべての関数はデフォルトで純粋です。しかし、さまざまなデータ構造間でデータを交換する副作用のある関数は、科学技術計算における一般的なプログラミングプラクティスです。そのため、新しい言語は副作用のある関数をサポートしています。しかし、それらは並列化を低下させるため、副作用のある関数は控えめに使用されるべきです。

副作用のある関数(副作用を持つ関数)は、そのような副作用のある関数の驚くべき(予測不可能な)性質を示唆する!シンボルでマークされなければなりません。これはSchemeの慣例ですが、新しい言語では必須です。視覚的には、副作用のある関数に!記号を付けることは、ほとんどの言語の慣例であるis...プレフィックスで述語関数に名前を付けるよりも、簡潔でより特徴的です。

以下は、引数n(型はn > 1という依存型 (n : ℕ) ⇒ n > 1)が素数であるかどうかをチェックする述語関数prime?の型宣言です。prime? 1やprime? 0のように、引数が$\le 1$の関数を呼び出すと、型エラーのためコンパイルされないことに注意してください。

prime? : (n : ℕ) ⇒ n > 1 → 𝔹

この述語は、if-then-else条件文で使用できます。

n = 7
...
if prime? n then ... else ...

述語関数をマークする—引数に条件をチェックし、$\mathbb{B}$値を返す述語関数は、述語関数の質問的な性質を示す?シンボルでマークされなければなりません。これもSchemeの慣例ですが、新しい言語では必須です。視覚的には、ほとんどの言語の慣例であるis...プレフィックスで述語関数に名前を付けるよりも、簡潔でより特徴的です。

以下は、引数n(型はn > 1という依存型 (n : ℕ) ⇒ n > 1)が素数であるかどうかをチェックする述語関数prime?の型宣言です。prime? 1やprime? 0のように、引数が$\le 1$の関数を呼び出すと、型エラーのためコンパイルされないことに注意してください。

prime? : (n : ℕ) ⇒ n > 1 → 𝔹

この述語は、if-then-else条件文で使用できます。

n = 7
...
if prime? n then ... else ...

様式規約—関数型言語では、操作される値は、関数が動作を制御するパラメータの後に、最後の引数として関数に渡されます:f p1 p2 value。これはUnixコマンドがファイルに適用される方法に似ています:cmd -p1 -p2 file。この規約により、関数が制御パラメータで部分適用され(カリー化され)、パイプラインに合成されるデータ処理パイプラインを作成できます。この事前構築されたパイプラインは、値に適用できます。例えば、value |> f p1 p2 |> g p1 p2 p3または同等のg p1 p2 p3 <| f p1 p2 <| valueです。どちらもg p1 p2 p3 (f p1 p2 value)よりも読みやすいです。

自由メソッド—純粋関数型言語であるため、関数値を変数に保持できます。つまり、メソッドのような、関数値を持つレコードを定義できます。しかし、FP言語はデータをモデル化するためにそのようなOO技術に依存しません。したがって、Car型にdriveメソッドを実装し、carオブジェクトに呼び出す(car.drive)のではなく、Carモジュールにdrive関数を実装し、それをcarレコードに適用します(drive car)。また、振る舞いを共有するためにOOクラス継承に依存せず、代わりに和積型と型クラスを使用します。

依存型に依存する

依存型(dependent types)のサポート—FP言語では、関数は第一級なので、関数は変数に保持され、他の値と同様に他の関数によって操作できます。依存型言語では、型も第一級なので、型は変数に保持され、関数によって操作できます。この静的依存型言語では、型も値です。この型と値の間の均一性は、クラスも(実行時に)オブジェクトであるSmalltalkのような動的強型言語にも現れることに注意するのは有益です。

パラメトリック型システムでは、型は他の型でパラメータ化できます。つまり、型は他の型に依存できます:Vector 𝛼は「$\alpha$型の要素の任意の長さのベクトル」を意味します—本質的にはリストです。依存型システムでは、型はさらに値に依存する(インデックス付けされる)ことができます:Vector 𝛼 n、ここでnは$\mathbb{N}$型の値です。これは「サイズ$n$の$\alpha$型の要素のベクトル」を意味します。慣例として、依存型の型パラメータには小文字のギリシャ文字$\alpha$、$\beta$などを、値インデックスには小文字のローマ字m、nなどを使用します。私たちはコンピュータ科学者は古典主義者を賞賛しますが、時には少しやりすぎるほどです。

新しい言語では、HaskellやFortranの::の代わりに、型を変数に割り当てるために:演算子を使用します。依存型言語では、型は第一級の値であるため、型を含む式は非常に一般的です。そのため、型割り当てにはノイズの少ない:を使用します。この規約は、Coq、F*、Lean、Agda、Idrisを含む依存型言語で一般的です。

私たちの言語は、Martin-Löfの直観主義型理論、GirardのSystem F、またはCoquandの構成計算論のような型理論に基づいた、強力で静的な依存型システムを採用しています。標準ライブラリのVector型は、依存型の例です。

Vector 𝛼 (n : ℕ) :
  | [] : Vector 𝛼 0
  | _,_ : (n : ℕ) ⇒ 𝛼 → Vector 𝛼 n → Vector 𝛼 (n+1)

上記では、型コンストラクタVectorは要素型のための型パラメータ$𝛼$でパラメータ化され、サイズのための数値nでインデックス付けされています。ここで、$\alpha$は制約のない型パラメータであり、nは自然数型$ℕ$の値です。値コンストラクタ[]はサイズ0のベクトルを作成します。値コンストラクタ_,_は、$𝛼$型の値をサイズ$n$のベクトルに前置し、新しいサイズ$n+1$のベクトルを返します。ベクトルxの$i$番目の要素はx[i]と書かれ、ここで0ベースのインデックス$i ∈ [
0, n)$
であり、その要素x[i]の型は$\alpha$です。

Vector依存型([𝛼 n]とエイリアス化)を使用して、自動的に$0.0$に初期化される$\mathbb{R}$型のサイズ3ベクトルを次のように定義できます。

x = [ℝ 3] ## 要素は自動的に0.0に初期化される

ベクトル連結演算子+の型を次のように宣言できます。

_+_ : (n m : ℕ) ⇒ [ℝ m] → [ℝ n] → [ℝ (m + n)]

上記の依存型関数宣言により、コンパイラはサイズ$m$のベクトルとサイズ$n$のベクトルを連結すると、サイズ$m+n$のベクトルが得られることを保証できます。コードにはパフォーマンスを低下させるランタイムサイズチェックを含める必要はありません。

headおよびtailベクトル関数を次のように定義できます。

head : (n : ℤ⁺) ⇒ [𝛼 n] → 𝛼
  | x,_ → x

tail : (n : ℕ) ⇒ [𝛼 n] → [𝛼 (n - 1)]
  | [] → []
  | _,xx → xx

ML、OCaml、Haskellのような単純型システムを採用している言語では、空リスト[]を渡すとhead関数はランタイムで$⊥$をスローします。しかし、依存型言語では、型式により、コンパイル時に空ベクトル[]をheadに渡すことができなくなり、パフォーマンスを低下させるランタイムチェックが排除されます。これがどのように機能するかを見てみましょう。

上記のベクトル型の定義では、インデックス変数nは自然数型$\mathbb{N}$であるため、ゼロベースです。しかし、headの型式にある二重矢印型制約構文(n : ℤ⁺) ⇒は、nの型を非ゼロ整数$\mathbb{Z}^+$にローカルに変更します。したがって、サイズ0のベクトルをheadに渡すと、サイズ値$n = 0 ∉ \mathbb{Z}^+$となるため、型エラーになります。コンパイラは、headに渡された引数ベクトル[𝛼 n]が空でないことをすでに保証しているため、headはランタイムサイズチェックなしで、引数ベクトルから最初の要素xを安全に抽出できます。これは、関数の事前条件を正確に指定するために依存型引数を使用する例です。

tail関数の型と節実装は、次のように保証します。引数ベクトルがサイズ$n = 0$の場合、結果ベクトルは[]になります。しかし、引数ベクトルがサイズ$n > 1$の場合、結果ベクトルはサイズ$n - 1$になります。これは、関数の事後条件を正確に指定するために依存型結果を使用する例です。

標準ライブラリがプリミティブ型$\mathbb{N}$とその減算演算子-を定義する方法について、さらに細かい点があります。$\mathbb{N}$の-演算子の定義は、最小結果を$0$にクランプします。したがって、定義により$0 - k = 0$となります。これは、$\mathbb{N}$上の-演算子の定義により、$n - 1 = 0 - 1 = 0$となるため、空ベクトル[](長さ0のベクトル)にtailを適用すると型チェックされることを意味します。

次に、標準ライブラリのMatrix依存型([𝛼 m n]とエイリアス化)を使用して、以下のように自動的に$0.0$に初期化される$\mathbb{R}$型の$2 \times 3$行列を定義できます。

[𝛼 m n] : Matrix 𝛼 (m n : ℕ)

y = [ℝ 2 3] ## 要素は自動的に0.0に初期化される

転置ᵀおよび加算+行列演算子は次のように宣言されます。

_ᵀ : (m n : ℕ) ⇒ [𝛼 m n] → [𝛼 n m]
_+_ : (m n : ℕ) ⇒ [𝛼 m n] → [𝛼 m n] → [𝛼 m n]

上記の関数宣言により、コンパイラは、$m \times n$サイズの行列yをyᵀと呼び出して転置すると、$n \times m$サイズの行列が得られることを検証できます。また、コンパイラは、行列加算式y1 + y2の引数行列の要素型とサイズが一致することを保証します。しかし、単純型システムを持つ言語では、これらの検証はパフォーマンスを低下させるランタイムサイズチェックによってのみ行うことができます。

依存型システムは、単純型システム(Hindley-Milnerなど)では不可能な高度な型を提供します。依存積型 $\Pi$(つまり、依存関数型)は、述語論理の普遍量化$∀$に対応します。依存和型 $\Sigma$(依存ペア型)は、存在量化$∃$に対応します。

$\Pi$型は、結果型が引数値に依存する(インデックス付けされる)汎関数です。例:$f : (x : \alpha) \to \beta[x]$、ここで$𝛼$は引数型であり、$𝛽$は型$𝛼$の値$x$に依存する結果型です。$\Sigma$型は、右要素の型が左要素の値に依存する(インデックス付けされる)汎ペアです。例:$(x : \alpha, \beta[x])$、ここで$𝛼$は左要素型であり、$𝛽$は型$𝛼$の値$x$に依存する結果型です。

型チェック中、依存型システムは型と値の両方を含むコンパイル時分析を実行しますが、単純型システムは型のみのコンパイル時分析を実行します。Smalltalkのような動的強型言語では、依存型システムと同様の振る舞いを達成できますが、実行時にリフレクション機能を介してのみ可能であり、これによりエンドユーザーは開発者がキャッチできなかった型エラーにさらされます。しかし、新しい言語では、プログラマーは依存型を使用して高精度な静的型仕様を表現でき、型システムはコードがこれらの仕様を満たすことを自動的に保証します。

Fortranの一部の型には、依存型のニュアンスがあります。例えば、固定サイズの配列型は、その長さを指定する整数値に依存すると考えることができます。real, dimension(3) :: xの定義では、変数xは要素がreal型のサイズ3の配列です。しかし、この長さの値はコンパイル時に知られている必要があります。依存型システムにはそのような制限はありません。

プログラミング言語の現代のトレンドは、ますます型付けが進む方向への徐々な移行です。型はもはや、ある型の値を別の互換性のない型の値と混合することを禁止する値の単純な分類ではなくなりました。型は現在、コンピューティングのすべての側面に深く関わっています。コード補完、コードリファクタリング、正しさ検証、ランタイム安全性、パフォーマンス最適化などです。したがって、私たちプログラマーは型に対する見方を変えなければなりません。型を、私たちの自由を制限し生産性を低下させる敵対的なガードとして見るのではなく、より高速で安全で検証済みの、理解しやすく保守しやすいソフトウェアを作成するのに役立つガイドとして頼ることを学ぶ必要があります。

さて、少し告白します。以前qsortを提示したとき、その型をqsort : (n : ℕ) ⇒ [ℤ n] → [ℤ n]と宣言しましたが、これはqsortが入力ベクトルのソートされたバージョンを返すという事実を表現していないため、完全に依存型ではありませんでした。以前の段落の主なポイントは、新しい言語の簡潔さであり、その依存型システムの精度ではなかったため、より単純な型を使用しました。結果のソート性を主張する完全に依存型バージョンはqsort : (n : ℕ) ⇒ [ℤ n] → (xx : [ℤ n], Sorted? xx)です。ここで、戻り値の型(xx : [ℤ n], Sorted? xx)は、qsortがサイズ$n$のベクトル値であるペアの最初の要素xx : [ℤ n]と、ベクトル値xxでインデックス付けされた依存型であり、その依存型の値がxxのソートされたバージョンであることを主張する2番目の要素Sorted? xxを返すことを指定します。これは必然的に同じ長さになります。標準ライブラリは述語型Sorted?を定義しています。

また、自然数の素数性をチェックするには述語関数を適用すること(prime? nなど)ができ、素数性をアサートするにはPrime?の型を持つ値を作成できることにも注意してください。したがって、p : Prime? 7は型チェックされますが、n : Prime? 10は型チェックされません。

代数的データ型(ADTs)のサポート—上記で、レコードとタプルの積型、および列挙型の和型について議論しました。積型と和型は型に対する代数演算と解釈できるため、代数的データ型(ADT)と呼ばれます。抽象データ型(ADT)の概念と代数的データ型(ADT)の概念の両方が「ADT」という名称を使用していますが、それらは異なる概念であることに注意してください。

パターンマッチングのサポート—FPにおける「パターンマッチング」とは、ADTの構造を使用してデータ構造をその構成要素に分解(分析)することを意味します。データ構造をランタイムで「生きている」と見なす場合、ランタイムパターンマッチングは分解ではなく、データの生体解剖です。

新しい言語は、case制御構造による構造的パターンマッチングをサポートする必要があります。

c : ℂ
...
case c
  | rectangular {x, y} → ...
  | polar {r, 𝜑} → ...

パターンマッチングのもう一つの用途は、レコードフィールドの抽出です。以下に示します。

c = rectangular {x = 2.0, y = 3.0}
...
{x, y} = c ## cは分解され、x=2.0、y=3.0となる

時には、パターンマッチされたデータ構造全体を参照する機能が便利です。これはアズパターンと呼ばれ、@シンボルを使用します。

f x,xx @ v → ... ## 全引数ベクトルはf内でvとして参照可能

型クラス(type classes)、オブジェクトクラスではない)のサポート—Fortranは科学技術DSLであり、依存代数的データ型は科学技術データをモデル化するのに十分以上です。そのため、Fortranがオブジェクトモデリング機能を提供する必要はありません。抽象データ型によるデータ隠蔽を実装するために、きめ細かい可視性修飾子(private、protected、public)を持つOOクラスの代わりに、より粗いがより単純な代替手段に依存します。つまり、選択的にエクスポートされる型と値を含むモジュールです。そして、アドホック多相性を実装するために、OOオブジェクト継承の代わりに、同等に表現力豊かなHaskellスタイルの型クラスに依存します。

型クラスはJavaのinterfaceに大まかに対応します。これは、型が望ましい型クラス(インターフェース)のインスタンス(実装)になることによって再利用(継承)できる関数のコレクション(振る舞い)を定義します。以下では、主な振る舞いが、ある型$\alpha$の値をUnicode文字列表現に変換することであるShow型クラスを宣言します。

Show 𝛼 :: ## Show クラスを宣言
  show : 𝛼 → 𝕊 ## show 関数を宣言

型クラス宣言の構文と型宣言の構文は非常に似ています。型クラスを宣言するには::を使用しますが、型を宣言するには:を使用します。上記のComplex型の型宣言構文を思い出してください。

Complex : ## Complex 型を宣言
  | rectangular {x y : ℝ}
  | polar {r 𝜑 : ℝ}
ℂ : Complex ## ℂ 型のエイリアス

ここで、複素数型$\mathbb{C}$をShow型クラスのインスタンスにし、複素数値フォーマット文字列表現に変換するshow関数を実装します。このメカニズムは、概念的にはJavaのimplementsに似ています。もう一つの構文的類似点に注意してください。値に型をアタッチするために単一コロン構文value : Typeを使用するのと同じように、型を型クラスのインスタンスにするために二重コロン構文Type :: Classを使用します。したがって、値、型、クラスの階層は、$value ∈ Type ∈ Class$です。

ℂ :: Show ## ℂ 型を Show 型クラスのインスタンスにする
  show : ℂ → 𝕊 ## 複素数型の show 関数を実装
    | rectangular {x, y} → "Rectangular " + show x + "+𝒾" + show y
    | polar {r, 𝜑} → "Polar " + show r + "∠" + show 𝜑

log! : ℂ → IO Unit
  | c → show c |> print! ## フォーマットされた複素数値を表示

Fortranは多相性をサポートしています。Fortranにおけるパラメトリック多相性はジェネリクスと呼ばれます。例えば、selected_real_kind()プロシージャを使用すると、プログラマーはデータ構造やプロシージャの浮動小数点精度を選択できます。Fortranにおけるアドホック多相性はオーバーロードと呼ばれます。これはC++の演算子オーバーロードに匹敵します。そして、Fortran 2003標準へのOOの追加により、C++の継承に似たもの(多相的な和型ADTを実装するOOの方法)をFortranで実装できるようになりました。それにもかかわらず、多相性はFortranに複雑な方法で後付けされたため、使用するのがかなり扱いにくいです。

ちなみに、新しい言語は、モダンな言語で一般的に知られている便利な機能である文字列補間をサポートしており、これを使用して上記のshow文字列変換関数を次のように実装できます。

ℂ :: Show
  show : ℂ → 𝕊
    | rectangular {x, y} → "Rectangular `show x`+𝒾`show y`"
    | polar {r, 𝜑} → "Polar `show r`∠`show 𝜑`"

文字列補間をサポートする言語では、{...}構文は、結果のサブ文字列を評価し、文字列に変換し、それを周囲の文字列に挿入するために使用されます。しかし、{と}は印刷されたメッセージで値をグループ化するためによく使用されるため、波括弧をエスケープする必要があり(\{...\}のように)、文字列補間の利便性が低下します。そのため、新しい言語では、Unix bashシェルと同様に、あまり使用されないバッククォートを使用します。

測定単位のサポート—人気のあるものの中で、F#は組み込みの測定単位サポートを持つ唯一のGPLです。科学技術計算および工学アプリケーションでは、単位は基本的な重要性を持っています。これは、単位の不注意な混合が生命、身体、または財産の損失につながる可能性のある安全クリティカルなアプリケーションでは特にそうです。測定単位は、依存型のライブラリとして実装できます。そのような型付き測定は、メートルとフィート、またはリットルとガロンの混合のような一般的なエラーを排除します。

しかし、さまざまな言語での測定単位の既存の実装は、構文的に負担が大きい傾向があり、その使用はしばしば計算の意味論を不明瞭にします。十分な使いやすさを提供する単位ライブラリを発見したら、このセクションを更新します。

必須の明示的型付けの削除—古いスタイルの明示的型付けを破棄し、単純な値の型を自動的に推論する強力で静的な依存型システムを採用して、明示的型付けの負担を軽減します。

しかし、単純型理論とは異なり、依存型理論における型推論は困難なタスクです。この困難さは、依存型システムの表現力の結果です。複雑なランタイム計算を型レベルに引き上げることは、型推論がコンパイル時に未決定になるという効果をもたらします。これは、ランタイムでの停止問題の未決定性と同様です。技術的には、この問題は依存型理論における等価性決定一般アルゴリズムの欠如に起因します。

しかし、実際には、Agda、Idris、Coq、F*、Leanなどの依存型言語は、双方向型チェックを採用しており、型システムは、トップレベル関数によって値がどのように操作されるかに基づいて、低レベル値の型を推論します。したがって、プログラマーはこれらのトップレベル関数の型を指定する必要があります。しかし、これは負担ではありません。なぜなら、単純な推論型システムを持つMLファミリーの関数型言語でさえ、プログラマーは可読性を助けるために、トップレベル関数の型を形式的に提供するからです。

依存関係の困難さ—コンピューティングにおける利益は無料ではありません。依存型も、単純さと利便性を奪うことによってプログラミングを損なう傾向があります。依存型システムは、おそらく今日使用されている型システムの中で最も複雑です。ベクトルや行列のような基本的な依存型でさえ、プログラマーをつまずかせる可能性があります。また、依存型システムの力の源である依存という概念自体が、抽象化の壁を破ると指摘されています。証明の正しさの負担は、証明支援ツールの助けにもかかわらず、依然としてプログラマーの肩にかかっており、依存型システムは状況によってはそれをより重くする可能性があります。それにもかかわらず、依存型は科学技術計算に多くの利点を提供するため、その使用はさらなる調査に値します。この記事をレビューし、依存型の具体性に伴う困難さについての洞察を提供してくれた@XY@mastodon.mit.eduに感謝します。

しかし、希望はあります。依存型システムはプログラマーに盲目的な服従を要求しません。すべての型が完全に依存した装飾を必要とするわけではありません。つまり、プログラマーは望ましいレベルの型特異性を選択します。例えば、qsortを徐々に細かい特異性で型付けできます。

  • 単純なパラメータ化型—qsort : [ℤ] → [ℤ]
  • 依存パラメータ化インデックス型—qsort : (n : ℕ) ⇒ [ℤ n] → [ℤ n]
  • 完全依存パラメータ化インデックス述語型—qsort : (n : ℕ) ⇒ [ℤ n] → (xx : [ℤ n], Sorted? xx)

もちろん、完全な依存から後退するほど、型仕様は不正確になり、その正しさ保証は弱くなります。

抽象化リークに関しては、コード保守に及ぼす悪影響を軽減するために、古くからあるソフトウェア設計原則に頼ることができます。つまり、より広範で高レベルの概念をより抽象的に(より具体性を低く)、より狭い低レベルの概念をより具体的に(より具体性を高く)します。

したがって、依存型システムの力を振るうことは、判断の行使です。つまり、特異性と実用性のバランスを取ることです。これは経験豊富なプログラマーが当然のこととして行うことです。さらに、新しい言語は科学技術DSLであり、狭く焦点を絞った使用法を持っています。したがって、標準ライブラリの設計者が、必要な証明と規定された使用法とともに、依存型と述語型の標準的なコレクションを蓄積することは完全に可能です。標準ライブラリによって提供される再利用は、前述の段階的特異性の設計原則と相まって、日常的な科学技術アプリケーションの実装における多くの苦痛を軽減するでしょう。

コンテナ型を提供する

コンテナ—最初から、FP言語はシーケンス(モノイド)に依存しており、リストデータ構造で表現されていました。実際、LISPは「リストプロセッサ」の略です。しかし、FORTRANは常に別の種類のシーケンス、つまり配列に依存してきました。ハードウェアレベルでは、配列はメモリセルの連続したシーケンスです。配列データ構造は、キャッシュやベクトルプロセッサに親和性があります。科学技術計算では、ほとんどすべてのデータがシーケンスとして表現されます。ビジネスコンピューティングに固有の複雑なレコード階層は、科学技術計算ではほとんど使用されません。したがって、配列処理はFortranの中心的な教義です。新しい言語もシーケンス処理を採用しています。

しかし、Fortranが配列のみを使用し、他のFP言語がリストのみを使用するのとは異なり、シーケンスを表現するために固定サイズのベクトルのみを使用します。ベクトルは、行列やテンソルに自然に拡張され、これらはすべて科学技術計算全体で一般的に使用されています。シーケンスデータ構造は、FPの不変性の精神に従って固定サイズです。

ベクトル—ベクトルは、固定サイズの1次元値シーケンスです。Vector依存型は標準ライブラリで定義されています。これは型パラメータ$\alpha$でパラメータ化され、サイズnでインデックス付けされています。標準ライブラリは、利便性のために短いエイリアスも定義しています。

[𝛼 n] : Vector 𝛼 (n : ℕ)
𝕍 : Vector

以下は、ベクトルリテラルを作成するための構文です。

e0 e1 e2 : ℝ
...
x = [e0, e1, e2]

上記のコードでは、型システムは変数xの型を[ℝ 3]または𝕍 ℝ 3($\mathbb{R}$型の要素を持つ$1 \times 3$行ベクトル)と推論します。数学では、1次元シーケンスは慣例により列ベクトルです。しかし、プログラミングでは、現代言語で普及している行優先順序の使用により、シーケンスは慣例により行ベクトルです。

innerおよびouterベクトル積関数を次のように宣言できます。両方の関数は、$\alpha$がNumクラスに制約されている、サイズ$n$の2つのベクトルを引数として取ります。innerの結果はNumクラスのスカラーであり、outerの結果は[Num n n]または𝕄 Num n n、つまりNumクラス要素の$n \times n$行列です。

inner : (𝛼 : Num) ⇒ [𝛼 n] → [𝛼 n] → 𝛼
outer : (𝛼 : Num) ⇒ [𝛼 n] → [𝛼 n] → [𝛼 n n]

上記の関数宣言では、型パラメータ$\alpha$は(𝛼 : Num) ⇒構文を使用してNumクラスの型に制約されています。しかし、ベクトル値コンストラクタ[𝛼 n]の宣言では型パラメータ$\alpha$が制約されていないため、[𝕌 10]のような非数値要素のベクトルを作成できます。しかし、ユーザーが数値ベクトルを期待するinnerまたはouterに非数値ベクトルを渡そうとすると、コンパイラは型エラーを発生させます。

Fortran、APL、J、Matlabのような配列処理言語は、スライスや要素へのアクセスに便利な構文をサポートしています。Python、Julia、Mojoなどのモダンな言語はこの配列アクセス構文を採用しています。私たちもそうします。1次元シーケンスアクセス構文を以下に示します。

x[i] ## nがxのサイズでi ≤ n-1の場合のi番目のベクトル要素
x[-i] ## i ≤ n-1の場合の(n-1-i)番目のベクトル要素
x[ia~ib] ## x[ia]からx[ib]までの要素のサブベクトル
x[i~] ## x[i]から最後の要素までのサブベクトル
x[~i] ## x[0]からx[i]までのサブベクトル

行列—行列は、固定サイズの2次元値グリッドです。

[𝛼 m n] : Matrix 𝛼 (m n : ℕ)
𝕄 : Matrix

行列リテラルを作成するための構文は、ベクトルリテラル構文を拡張します。実数値要素の場合、以下の例の変数yの型は[ℝ 2 3]または𝕄 ℝ 2 3($\mathbb{R}$型の要素を持つ$2 \times 3$行列)と推論されます。

y = [ [e00, e01, e02] ## ベクトル [e00 ~ e02]
    , [e10, e11, e12] ] ## 行列 [e00 ~ e12]

2次元シーケンスアクセス構文は次のとおりです。

y[i,~] ## yの行サイズがmでi ≤ m-1の場合のi行ベクトル
y[-i,~] ## i ≤ m-1の場合の(m-1-i)行ベクトル
y[ia~ib,~] ## y[ia,~]からy[ib,~]までのサブ行列
y[~,j] ## j列ベクトル
y[~,-j] ## (n-1-j)列ベクトル
y[~,ja~jb] ## y[~,ja]からy[~,jb]までのサブ行列
y[i,j] ## 行列要素
y[-i,-j] ## 行列要素

テンソル—テンソルは、固定サイズの多次元値シーケンスです。3次元キューブテンソルは次のように定義されます。

[𝛼 l m n] : Tensor3 𝛼 (l m n : ℕ)
𝕋3 : Tensor3

テンソルリテラルを作成するための構文は、行列リテラル構文を拡張します。以下の例では、変数zの型は[ℝ 3 3 3]または𝕋3 ℝ 3 3 3($\mathbb{R}$型の要素を持つ$3 \times 3 \times 3$テンソル)と推論されます。

z = [ [ [e00, e01, e02]
      , [e10, e11, e12]
      , [e20, e21, e22] ]
    , [ [f00, f01, f02] ## 1x3 ベクトル [f00 ~ f02]
      , [f10, f11, f12]
      , [f20, f21, f22] ] ## 3x3 行列 [f00 ~ f22]
    , [ [g00, g01, g02]
      , [g10, g11, g12]
      , [g20, g21, g22] ] ] ## 3x3x3 テンソル [e00 ~ g22]

3次元テンソルの要素は次のようにアクセスされます。

z[2, 1, 0] ## 要素 g10

テンソルアクセス構文は行列アクセス構文の自然な拡張であるため、さらに詳しく説明する必要はありません。しかし、シーケンスリテラルコンストラクタとシーケンス要素アクセサの2つの異なる意味で、コンマ区切りの[..., ...]構文を使用していることに注意することが重要です。コンストラクタの意味では、次元を区切り、各次元内の要素を区切るために[と]シンボルを使用します。アクセサの意味では、次元インデックスをグループ化し、次元インデックスを区切るために,を使用します。構文z[2, 1, 0]は、Cのz[2][1][0]構文よりもノイズが少なく、より読みやすいです。Fortranとは対照的に、今日すべての人気言語で採用されている行優先要素順序に従います。

シーケンス構文は高次元に拡張されます。例えば、6次元テンソルは次のように定義されます。

[𝛼 i j k l m n] : Tensor6 𝛼 (i j k l m n : ℕ)
𝕋6 : Tensor6

タプル—タプルは、異なる型の順序付けられたラベルなしフィールドを保持する名前のない積型です。例えば、デュプル型は(𝛼, 𝛽)、トリプル型は(𝛼, 𝛽, 𝛾)です。

音楽の音符は、タプルリテラルを使用して次のように表現できます。最初の要素は音符の名前(中央ハ音の場合は"C4")、2番目は周波数(261.624 Hz)、3番目はMIDI番号(60)です。

Note : (𝕊, ℝ, ℕ) ## 音楽の音符; 名前、周波数、MIDI
...
c4 = ("C4", 261.624, 60) ## 中央ハ音
...
freq = c4(1) ## 261.624 Hz
...
(name, freq, midi) = c4 ## name="C4", freq=261.624, midi=60

タプルは、少数のデータを小さなバンドルにまとめる便利な方法です。例えば、タプルは関数から複数の値を返すために使用できます。数学およびFPでは、関数は1つの値しか返せないため、複数の結果を返すには、それらの異なる値をタプルにバンドルする必要があります。しかし、数十個の値をタプルに押し込もうとすると危険です。そのような場合、レコードを使用する方が良い型です。

レコード—レコードは、さまざまな型の順序付けられたラベル付きフィールドを保持する名前付き積型です。上記で定義されたrectangularおよびpolar積型はレコードの例です。レコードのフィールドは、p.𝜑のように、.演算子を使用してアクセスされます。既存のレコードから新しいレコードを作成するには、レコード更新構文{... | ...}を使用します。

c = rectangular {x = 2.0, y = 3.0} ## 型ℂのcは2.0+𝒾3.0
...
c' = {c | y = -c.y} ## cの複素共役は2.0-𝒾3.0

列挙型—列挙型(不連続和)は、名前付き和型です。例えば、ブール値$\mathbb{B}$型は、𝔹 : false | trueのように、ヌル値コンストラクタfalseとtrueを持つ和型です。一方、複素数型$\mathbb{C}$は、ℂ : rectangular{x y : ℝ} | polar{r 𝜑 : ℝ}のように、レコード積型を取る値コンストラクタrectangularとpolarを持つ和型です。より正確には、$\mathbb{C}$は和積型です。列挙型は、和積型を形成するためにレコードと組み合わせて頻繁に使用されます。列挙型のデータ要素はパターンマッチングによってアクセスされます。

case b
  | false → ...
  | true → ...

ハッシュ—ハッシュはペアのコレクションです。各ペアは、一意のキーkに関連付けられた値vで構成されます:<k:𝛼 # v:𝛽>。ここで、キーの型は$𝛼$、値の型は$𝛽$です。シンボル#はキーとその値を区切ります。ハッシュの要素は、キーインデックス付け(h<k>でキーkに関連付けられた値を取得)またはパターンマッチング(x,xx = hでxがhの最初のキーと値のペアに、残りがxxに束縛される)によってアクセスされます。

モジュールを活用する

1つのファイルに1つのモジュール—モジュールは、概念的に関連する型と値のコンテナです。コードのすべてのまとまった単位はモジュールの候補です。多くのモダン言語では、プログラマーは1つのファイルに複数のモジュールを定義できます。これは、多くの絡み合ったサブ構造から構築された大規模で複雑なデータ構造を持つビジネスアプリケーションを実装する際に便利かもしれません。しかし、科学技術データ構造ははるかに単純です。そのため、新しい言語では、1つのファイルに1つのモジュールという単純なアプローチが使用されます。さらに単純化し、明確性を高めるために、含まれるモジュールの名前はコンテナファイルの名前と同じになるように強制されます。前述のモジュールとファイルの名前付け規則を思い出してください。

抽象データ型(ADTs)のサポート—抽象データ型(「ADT」というラベルも使用しますが、代数的データ型とは異なる概念です)は、内部表現が隠されており、公開されたアクセサ関数のコレクションを通じてのみ操作できるデータ構造です。抽象データ型はモジュール構造を使用して実装されます。

PPのモジュールベースの抽象化メカニズムは、OOクラスベースの抽象化メカニズムの前身でした。ITが1980年代に急速に成長するにつれて、ビジネスアプリケーションの複雑さは抽象データ型の抽象化能力を凌駕し始め、クラスは、その多層的なデータ隠蔽メカニズムにより、エンタープライズソフトウェア開発における標準的な抽象化メカニズムとなりました。しかし、科学技術アプリケーションははるかに控えめなデータ抽象化ニーズを持っているため、モジュールベースの抽象データ型は科学技術アプリケーションに適しています。

暗黙のエクスポートを使用する—ほとんどのモダンなプログラミング言語では、モジュールに含まれる宣言と定義はデフォルトで非表示になり、プログラマーはエクスポートしたい項目を明示的にマークする必要があります。もちろん、もう一つの選択肢は、自動的な暗黙のエクスポートです。

命令型PP言語では、非表示デフォルトの動作は、モジュールのユーザーが抽象データ型の内部データ表現を直接変更することを防ぐため、エクスポートデフォルトの動作よりも安全です。しかし、宣言型FP言語では、データ構造は不変です。不変性は、データ構造の表現を隠蔽することに執拗になる必要性を抑制します。そのため、新しい言語では、コードをモジュール全体に散らばるexportマーカーで散らかすのを避けるために、暗黙のエクスポート動作を採用します。特定の宣言または定義を隠す必要がある場合は、--シンボルで明示的にマークします。以下に示します。

#< Distance.f
This module implements distance measures. #>

-- 𝛿 = 0.0001 ## モジュール内部定数

## aとbが近いかどうかをチェックする
near? : ℝ → ℝ → 𝔹
  | a b → |b - a| < 𝛿
_≈_ : `near?`

上記のコードはDistance.fファイルに含まれており、関連するモジュールは自動的にDistanceという名前が付けられます。したがって、新しい言語にmodule ModuleNameのような構文は必要ありません。定数$\delta$はモジュール実装者が使用するために定義されていますが、--シンボルでマークされているため、モジュールユーザーからは隠されています。また、値は不変であるため、新しい言語にconstキーワードは必要ありません。

モジュールの自動エクスポート動作により、ユーザーは述語関数near?を利用できます。これは、測定値aとbの絶対距離が$\delta$未満であるかどうかをチェックし、したがって2つの測定値が互いに近いと見なされます。ミックスフィックス近似等価演算子_≈_は、near?のバッククォートバージョンにエイリアスされています。

Distanceモジュールは、メインモジュールから次のように使用されます。

#< Main.f #>

use Distance

main! : Unit → IO Unit
  | 𝟙 → if a ≈ b then "near" else "far" |> print!
         where a = -3.2; b = 6.8