Case-Anweisungen und Pattern-Matching.

Ich bin Programmierung in SML für eine Aufgabe und ich habe ein paar Praxis-Probleme und ich fühle mich wie ich bin etwas fehlt - ich fühle mich wie ich bin mit zu vielen case Aussagen. Hier ist, was ich Tue und das problem Erklärungen für das, was ich habe Probleme mit.:

Schreiben Sie eine Funktion all_except_option, die einen string und eine string-Liste. Return "KEINE", wenn die Zeichenfolge nicht in der Liste sonst wieder EINIGE lst wo lst ist wie die Liste der Argumente außer die Zeichenfolge ist nicht in ihm.

fun all_except_option(str : string, lst : string list) =
  case lst of 
   [] => NONE
  | x::xs => case same_string(x, str) of
               true => SOME xs
             | false => case all_except_option(str, xs) of
                          NONE => NONE
                        | SOME y=> SOME (x::y)

Schreiben Sie eine Funktion get_substitutions1, die einen string-Liste (eine Liste von strings, die Substitutionen) und einen string s und gibt eine string-Liste. Das Ergebnis hat alle Zeichenfolgen, die in einer Liste in Substitutionen hat auch s, aber s selbst sollte nicht in das Ergebnis ein.

fun get_substitutions1(lst : string list list, s : string) = 
  case lst of
    [] => []
  | x::xs => case all_except_option(s, x) of
                 NONE => get_substitutions1(xs, s)
                | SOME y => y @ get_substitutions1(xs, s)

-
same_string ist eine mitgelieferte Funktion
fun same_string(s1 : string, s2 : string) = s1 = s2

Dies ist ein Teil der Aufgaben für week2 in der Coursera-Programmier-Sprachen-Kurs. Da es ein wegen Verletzung des post solutions online, bitte ich, diese Frage neu formulieren, ändern Sie den Funktionsnamen, damit Sie nicht exakt übereinstimmen mit der Zuordnung.

InformationsquelleAutor user998876 | 2011-10-17

9

Zunächst einmal möchte ich beginnen mit pattern-matching in der definition einer Funktion
anstatt einer "top-level" case " - Anweisung. Es ist im Grunde läuft alles auf den
dasselbe nach dem de-sugaring. Ich würde auch loszuwerden, die explizite Typ-Annotationen, sofern nicht unbedingt notwendig:
```
fun all_except_option (str, []) = NONE
  | all_except_option (str, x :: xs) =
    case same_string(x, str) of
      true  => SOME xs
    | false => case all_except_option(str, xs) of
                 NONE   => NONE
               | SOME y => SOME (x::y)

fun get_substitutions1 ([], s) = []
  | get_substitutions1 (x :: xs, s) =
    case all_except_option(s, x) of
      NONE   => get_substitutions1(xs, s)
    | SOME y => y @ get_substitutions1(xs, s)
```
Wenn die Geschwindigkeit ist nicht von Bedeutung, dann könnte man die Zusammenführung der beiden Fälle in die erste Funktion:
```
fun all_except_option (str, []) = NONE
  | all_except_option (str, x :: xs) =
    case (same_string(x, str), all_except_option(str, xs)) of
      (true, _)       => SOME xs
    | (false, NONE)   => NONE
    | (false, SOME y) => SOME (x::y)
```
Aber da Sie mit append (@), in der zweiten Funktion, und da ist es nicht
tail-rekursive, ich glaube nicht, dass es Ihr großes Anliegen. Beachten Sie, dass
append Potenzial "böse" und man sollte fast immer die Verkettung (und
dann drehen Sie Ihr Ergebnis, wenn es wieder) und tail-Rekursion, wenn möglich (es
immer ist).

Wenn Sie wirklich, wie das explizite type-Annotationen, dann könnte man es so machen:
```
val rec all_except_option : string * string list -> string list option  =
 fn (str, []) => NONE
  | (str, x :: xs) =>
    case (same_string(x, str), all_except_option(str, xs)) of
      (true, _)       => SOME xs
    | (false, NONE)   => NONE
    | (false, SOME y) => SOME (x::y)


val rec get_substitutions1 : string list list * string -> string list =
 fn ([], s) => []
  | (x :: xs, s) =>
    case all_except_option(s, x) of
      NONE   => get_substitutions1(xs, s)
    | SOME y => y @ get_substitutions1(xs, s)
```
Aber das ist nur mein bevorzugter Weg, wenn ich wirklich hinzufügen, geben Sie Anmerkungen ein.

Durch die Art und Weise, warum auf der Erde haben Sie die same_string Funktion? Sie können nur tun, der den direkten Vergleich anstelle. Mit einem auxilary-Funktion ist nur verrückt, es sei denn, Sie planen, exchange es mit einigen speziellen Logik irgendwann. Jedoch wird Ihre Funktion Namen nicht sugest.
- Wenn ich versuche, den oberen code-block, bekomme ich Kompilierungsfehler, die sagen, 'Fehler: operator ist keine Funktion" - Es scheint, wie der Fall all_except_options(s, x) - Abschnitt kann nicht getrennt werden von der get_substitutions1 (x :: xs, s) zu blockieren. Wie kann ich feststellen, sml, dass KEINER und EINIGE sind Fälle, für welche zurückgegeben all_except_options und nicht Fälle für get_substitutions?
- Man könnte sagen, dass "der Spaß Schlüsselwort bricht sich die zwei Funktionen". Es funktioniert in SML/NJ 110.72, so verwenden Sie entweder einen anderen interpreter oder Sie etwas falsch gemacht haben. Sie könnte die verschachtelte case-Ausdruck in Klammern. Jedoch ist die Fehlermeldung, die Sie erhalten, klingt nicht, als es nichts zu tun hat mit den Fällen?
- Ich weiß, dies ist ein Alter thread, aber ich versuche herausfinden, was in SOME y im all_except_option. Wenn Sie es ausschalten, wieder EINIGE (x::"wtf"::y) können Sie sehen, dass läuft auf alle Elemente, vor der passende string, aber nicht auf alle Elemente nach dem string, aufeinander abgestimmt ist. Wenn y hält der Rest von der Liste, warum sehe ich nicht die Liste kopiert werden? Ich habe eine harte Zeit "stepping" durch dieses problem mit einem pad von Papier und halten Spur von dem, was EINIGE y tatsächlich Punkte zu bei jedem Schritt.
InformationsquelleAutor Jesper.Reenberg
1

Zusätzlich zu dem, was Jesper.Reenberg erwähnt, ich wollte nur erwähnen, dass ein Spiel auf einem bool für true und false ersetzt werden kann, mit einer if-then-else. Jedoch, einige Leute denken, wenn-dann-sonst hässlicher als eine case-Anweisung
- Wahr ist, dass ich denke, ich bin einer von diesen Menschen 🙂
InformationsquelleAutor user102008

fun same_string( s1: string, s2: string ) = if String.compare( s1, s2 ) = EQUAL then true else false


fun contains( [],   s: string ) = false
|   contains( h::t, s: string ) = if same_string( s, h ) then true else contains( t, s )


fun all_except_option_successfully( s: string, [] )   = []
|   all_except_option_successfully( s: string, h::t ) = if same_string( s, h ) then t else ( h :: all_except_option_successfully( s, t ) )


fun all_except_option( s: string, [] )   = NONE
|   all_except_option( s: string, h::t ) = if same_string( s, h ) then SOME t else if contains( t, s ) then SOME ( h :: all_except_option_successfully( s, t ) ) else NONE

Es gibt immer etwas zu optimieren, ein "if .. then true else false" 🙂

InformationsquelleAutor Cyril

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.