OCaml-Funktion parameter-Mustervergleich für Zeichenketten

Ich habe versucht, verwenden um eine Zeichenfolge übergeben, um eine umgekehrte Zeichenfolge. Warum kann ich nicht tun:

let rec reverse x = 
  match x with
  | "" -> ""
  | e ^ s -> (reverse s) ^ e;;

Dem compiler sagt, es ist ein syntax Fehler. Kann ich nicht ^ zu destructure Parameter?

Zusätzlich für die unten folgende Erklärung: Wo in der Zeichenfolge sollte der compiler auch split den string? "abc" "a" "bc" oder "ab" "c"

InformationsquelleAutor lkahtz | 2012-03-25

ocaml

18

Der Grund dafür ist, dass die Saiten sind nicht dargestellt als Datentyp in der gleichen Weise wie Listen. Deshalb, während cons (::) ist ein Konstruktor, ^ ist nicht. Stattdessen werden die Zeichenfolgen dargestellt, die ein niedrigeres Niveau geben, ohne eine rekursive definition (als Listen). Es ist ein Weg, um match-strings wie eine Liste von Zeichen, die mit Hilfe einer Funktion von SML (was man schreiben kann, OCaml), genannt 'explodieren' und 'implode', die-jeweils-einen string in einen char-Liste und Umgekehrt. Hier ist ein Beispiel für die Implementierung von Ihnen.
- Danke. Aber ist eh 'überlastung' der Operanden wie C++ zu tun? Das wird auf jeden Fall besser die Abstraktion.
- Nein. Es gibt keinen Weg, um eine überlastung der Betreiber. Strings werden definiert als eine untere Stufe geben, und Sie können nicht künstlich auferlegen, Sie in einen Datentyp, wenn Sie grundsätzlich nicht ein induktiv definierter Typ ist.
InformationsquelleAutor Kristopher Micinski
2

Wenn Sie schreiben Sie eine pattern-matching-Ausdruck verwenden, können Sie beliebige Funktionen in Ihrem Muster. Sie können nur Konstruktoren, die Aussehen wie ungewichtete Funktionen. Zum Beispiel der Funktion "+" definiert ist, auf ganze zahlen. Der Ausdruck 1+2 wird ausgewertet und ergibt 3; die Funktion "+" evaluiert, so dass Sie nicht auf x+y. Hier ist ein Versuch, zu definieren, eine Funktion auf natürlichen zahlen, der prüft, ob die Zahl null ist:
```
 let f x =  match x with
  | 0 -> false
  | a+1 -> true
 ;;
```
Kann das nicht funktionieren! Aus dem gleichen Grund, dein Beispiel mit strings arbeiten kann. Die Funktion "^" bewertet, strings, es ist kein Konstruktor.

Dem matching auf x+1 würde nur funktionieren, wenn die zahlen wurden ungewichtete symbolische Ausdrücke aus der ungewichtete Betreiber + und eine symbolische Konstante 1. Dies ist nicht der Fall in OCAML. Ganzzahlen implementiert werden direkt durch den Computer zahlen.

Wenn Sie einen variant-Typ passt Sie auf Konstruktoren, die ungewichtete Ausdrücken. Zum Beispiel:
```
 # let f x = match x with
    | Some x -> x+1
    | None -> 0
 ;;
 val f : int option -> int = <fun>
```
Dies funktioniert, da die 'a option Typ ist ein symbolischer Ausdruck, wie Some x. Hier Some ist nicht eine Funktion, die ausgewertet wird, und gibt einen anderen Wert, sondern eher ein "constructor", die man sich vorstellen kann wie eine Funktion, die nie ausgewertet. Der Ausdruck Some 3 wird nicht bewertet, jede weitere; es bleibt, wie es ist. Es ist nur auf solche Funktionen, können Sie pattern-match.

Listen sind auch symbolische, ungewichtete Ausdrücke aufgebaut aus Konstruktoren; der Konstruktor ist ::. Das Ergebnis x :: y :: [] ist eine ungewichtete Ausdruck, diese vertreten durch die Liste [x;y] nur für kosmetische Bequemlichkeit. Aus diesem Grund, können Sie pattern-match auf den Listen.
- Danke für deine Antwort. Es wäre toll, wenn könnten Sie erwähnen, ob und wie die Mustererkennung in Zeichenketten ist möglich in OCaml.
InformationsquelleAutor winitzki

Als Kristopher Micinski erklärt, kann man nicht zerlegen strings mit pattern-matching, wie Sie mit Listen.

Aber Sie können konvertieren Sie Sie in Listen, mit explode. Hier ist Ihre reverse Funktion mit pattern-matching mit explode und sein Gegenstück implode:

let rec reverse str =
  match explode str with
    [] -> ""
    | h::t -> reverse (implode t) ^ string_of_char h

Verwenden Sie es wie diese:

let () =
  let text = "Stack Overflow ♥ OCaml" in
  Printf.printf "Regular: %s\n" text;
  Printf.printf "Reversed: %s\n" (reverse text)

Was zeigt, dass es funktioniert für single-byte-Zeichen, aber nicht für multi-byte-ones.

Und hier sind explode und implode zusammen mit einem Helfer-Methode:

let string_of_char c = String.make 1 c

(* Converts a string to a list of chars *)
let explode str =
  let rec explode_inner cur_index chars = 
    if cur_index < String.length str then
      let new_char = str.[cur_index] in
      explode_inner (cur_index + 1) (chars @ [new_char])
    else chars in
  explode_inner 0 []

(* Converts a list of chars to a string *)
let rec implode chars =
  match chars with
    [] -> ""
    | h::t ->  string_of_char h ^ (implode t)

InformationsquelleAutor Matthias Braun

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.