Názory k článku Rekurze a pattern matching v programovacím jazyku F#

Novější jazyky používají mutual:

mutual
  def even x :=
    if x = 0
    then true
    else odd (x-1)
  def odd x :=
    if x = 0
    then false
    else even (x-1)
end

to je takove citelnejsi, pekne

V jazycích, které vynucují totalitu funkcí, se to musí zapsat takto:

def fib : Nat -> Nat
  | 0 => 0
  | 1 => 1
  | n+2 => fib (n+1) + fib n

V F# môžme pattern match využiť pri spracovaní výnimiek, je to celkom fajn syntax.

open System

printf "Enter a number: "

let value = Console.ReadLine()

let n =
    match Int32.TryParse value with
    | true, num -> num
    | _ -> failwithf "'%s' is not an integer" value


let f = function
    | value when value > 0 -> printfn "positive value"
    | value when value = 0 -> printfn "zero"
    | value when value < 0 -> printfn "negative value"

f (int value)
f n

Operátor :? je pre dátové typy. F# nemá union types ako napr. Scala, tak som vytiahol ArrayList. (bŕŕ, Java hovadina sa dostala do F# !)

open System.Collections

type User =
    { FirstName: string
      LastName: string
      Occupation: string }

let vals = new ArrayList()
vals.Add(1.2)
vals.Add(22)
vals.Add(true)
vals.Add("falcon")

vals.Add(
    { FirstName = "John"
      LastName = "Doe"
      Occupation = "gardener" }
)

for wal in vals do
    match wal with
    | :? int -> printfn "an integer"
    | :? float -> printfn "a float"
    | :? bool -> printfn "a boolean"
    | :? User -> printfn "a User"
    | _ -> ()

Alebo sa tiež používajú tzv. active patterns, kde si zadefinujeme názvy, ktoré potom neskôr použijeme.

let (|RegEx|_|) p i =
    let m = Regex.Match(i, p)

    if m.Success then
        Some m.Groups
    else
        None


let CheckRegex (msg) =
    match msg with
    | RegEx @"\d+" g -> printfn "Digit: %A" g
    | RegEx @"\w+" g -> printfn "Word : %A" g
    | _ -> printfn "Not recognized"


CheckRegex "an old falcon"
CheckRegex "1984"
CheckRegex "3 hawks"

Niektoré jazyky používajú switch expressions alebo (given)/when syntax pre to isté. Veľmi dobre to má Groovy, ktorý zvláda regulárne výrazy, listy, mapy alebo range.

def testSwitch(val) {
    switch (val) {
        case 52 -> 'Number value match'
        case "Groovy 4" -> 'String value match'
        case ~/^Switch.*Groovy$/ -> 'Pattern match'
        case BigInteger -> 'Class isInstance'
        case 60..90 -> 'Range contains'
        case [21, 'test', 9.12] -> 'List contains'
        case 42.056 -> 'Object equals'
        case { it instanceof Integer && it < 50 } -> 'Closure boolean'
        case [groovy: 'Rocks!', version: '1.7.6'] -> "Map contains key '$val'"
        default -> 'Default'
    }
}

Ještě je dobrý “early return from a failed match” na ošetření chyb.

to Groovy je pekne. Vlastne ani nevim, proc se to vic neprosadilo (zatim jsem to pouzil jen na Jenkinsu :-)

Malé doplnění k tail rekurzi. V F# záleží na IL instrukcích. Například následujícímu programu dojde zásobník, i když z pohledu programátora to vypadá, že f i bar jsou volány v tail pozici:

let bar (f : int -> unit) (i : int) : unit =
    if i >= 0
    then f (i - 1)
    else printfn "Stop"

let rec foo (i : int) : unit =
    bar foo i

[<EntryPoint>]
let main args =
    foo 1000_000
    0

U bar to je i pravda, u f nikoliv, protože po volání f musí kompilátor ještě převést unit na void. Řešením je nepoužívat unit, ale udělat si vlastní type MyUnit = MyUnit

A to je takový problém (nebo by to bylo až tak moc otravné), aby se ty tail cally dělaly přes nějaký operátor, třeba tail foo(1000)?

Bylo by jasné, že to má být tail call, a kompilátor by ho mohl zkontrolovat a garantovat, že proběhne správně (nebo ohlásit chybu, že tady tail call být nemůže).

to ma Clojure s `(recur)` ale u vzajemne rekurze uz to chce trampoliny a tak (a imho se to v praxi moc neresi)

.NET má instrukci tail. na rozdíl od JVM, takže v F# jde použít continuation passing style, ale člověk musí být opatrný právě při použití unit.

Ano, to by šlo, ale nikdo to zatím do jazyka nepřidal. Viz https://github.com/fsharp/fslang-suggestions/issues/721