To skoro vypadá tak, že by se daly zdrojáky mezi OCaml a F# převádět (přímo nebo přes AST) automagií. Jde to? Protože předpokládám, že F# je přece jen rozšířenější platforma (.NET).

První verze F# kompilátoru (z konce roku 2001) byly napsány v OCamlu. A F# dřívě podporoval syntax OCamlu. Díky této podpoře šlo v OCamlu napsaný F# kompilátor přeložit pomocí F#.

Rustu taky, jestli se dobře pamatuju.

Ano Rust potvrzuji.

Je zajímavé, že pro prototypy překladačů se často používají OCaml nebo Scheme.

Ta syntaxe se nějak přepínala? Protože i teď má F# dvě varianty syntaxe že?

ted nevim jak to myslis. Rozliseni "verbose" a "lightweight" nebo neco jineho?

Ale obecne nejde (dneska) rict, ze Ocaml je dopredne kompatibini F#. To platilo kdysi, dneska se ty jazyky rozesly (ne moc, ale rozesly).

Přepínala se přidáním

#light "off"

na začátek souboru. V posledních verzích je třeba spouštět překladač s přepínačem --mlcompatibility, aby nevyhazoval chyby a varování na OCamlí syntaxi.

Nicméně oba jazyky jsou značně rozdílné. Např. OCaml kontroluje kompatibilitu modulů strukturálně (když má modul funkce správných názvů a typů, tak je to ok), zatímco F# nebo celý .NET kontroluje kompatibilitu tříd nominálně (nestačí, že má metody správných názvů a typů, ale musí být podtypem nějaké třídy nebo rozhraní).

5. 10. 2023, 11:22 editováno autorem komentáře

takze rozdil "jen" v OOP? to mi stejne pripadne jako prilepek

Nejenom. Rozdíl je v systému modulů, kde OCaml umožňuje moduly parametrizovat jinými moduly (v ML světě se tomu říká aplikativní nebo generativní funktory).

OCaml má silnejší typový systém (např. GADT, polymorfní varianty) a silnější typovou inferenci. Na druhé straně F# má podtypový polymorfismus a OCaml jen řádkový (row) polymorfismus.

OCaml 5 a novější má podporu pro efekty a jejich handlery, což AFAIK není možné udělat v .NET bez podpory runtimu. A lidi od MS zrovna nedávno oznámili, že podpora nebude: https://github.com/dotnet/runtimelab/issues/2398

OOP, prílepok funkcionálneho? :)

proste v dobe, kdy OOP bylo povazovano za stribrnou kulku v IT (ugh), tak z funkcionalniho CAMLu udelali OCaml, ze to tam dolepili. Neresili jsme to uz nekdy u prvniho clanku? Kde se zminovalo, ze se nejaka podpora OOP zacala objevovat i v assemblerech a tak. Nebo to bylo jinde?

Pro fajnšmekry (Lean):

def List.sum [Add α] [Inhabited α] (l : List α) := l.foldl (· + ·) default

A nie je to trochu cheating použiť foldl? V OCaml/F# je to kompletný algoritmus sumy.

Zaujímavé je, že to vytvorí funkciu pre typ aj pre inštanciu. (BTW, funguje aj haskellovský $ pre pipu). C# má tzv. extension methods, ale tam to je oveľa ťažkopádnejšie.

def List.sum' [Add α] [Inhabited α] (l : List α) := l.foldl (λ x y => x + y) default

def main: IO Unit := do

  let vals: List Nat := [1, 2, 3, 4, 5]
  IO.println vals.sum'

  let vals: List Nat := [1, 2, 3, 4, 5]
  IO.println (List.sum' $ vals)

  let vals: List Int := [-2, -1, 0, 1, 2, 3, 4, 5]
  IO.println vals.sum'

  let vals: List Float := [1.1, 2.2, 3.3, 4.4, 5.5]
  IO.println vals.sum'

Nevím, jestli cheating, ale zajistí to vyhnutí se rekurzi.

Pochybné je spíše to použití Inhabited, správně by tam měla být typová třída pro Monoid, ale o to tady nešlo.