From ffb5fdcd2580b00203456636be887adcc9759bda Mon Sep 17 00:00:00 2001 From: aarne Date: Thu, 8 Oct 2009 12:40:47 +0000 Subject: [PATCH] Sammie grammars added to examples --- examples/sammie/ExtSammie.gf | 0 examples/sammie/ParamSammie.gf | 47 +++ examples/sammie/ParamSammieEng.gf | 87 ++++++ examples/sammie/ParamSammieFin.gf | 90 ++++++ examples/sammie/ParamSammieFre.gf | 113 ++++++++ examples/sammie/ParamSammieGer.gf | 118 ++++++++ examples/sammie/ParamSammieSpa.gf | 110 +++++++ examples/sammie/ParamSammieSwe.gf | 93 ++++++ examples/sammie/Sammie.gf | 174 +++++++++++ examples/sammie/SammieEng.gf | 6 + examples/sammie/SammieEng1.gf | 235 +++++++++++++++ examples/sammie/SammieFin.gf | 7 + examples/sammie/SammieFre.gf | 7 + examples/sammie/SammieGer.gf | 7 + examples/sammie/SammieGer2.gf | 459 ++++++++++++++++++++++++++++++ examples/sammie/SammieI.gf | 287 +++++++++++++++++++ examples/sammie/SammieSpa.gf | 7 + examples/sammie/SammieSwe.gf | 7 + 18 files changed, 1854 insertions(+) create mode 100644 examples/sammie/ExtSammie.gf create mode 100644 examples/sammie/ParamSammie.gf create mode 100644 examples/sammie/ParamSammieEng.gf create mode 100644 examples/sammie/ParamSammieFin.gf create mode 100644 examples/sammie/ParamSammieFre.gf create mode 100644 examples/sammie/ParamSammieGer.gf create mode 100644 examples/sammie/ParamSammieSpa.gf create mode 100644 examples/sammie/ParamSammieSwe.gf create mode 100644 examples/sammie/Sammie.gf create mode 100644 examples/sammie/SammieEng.gf create mode 100644 examples/sammie/SammieEng1.gf create mode 100644 examples/sammie/SammieFin.gf create mode 100644 examples/sammie/SammieFre.gf create mode 100644 examples/sammie/SammieGer.gf create mode 100644 examples/sammie/SammieGer2.gf create mode 100644 examples/sammie/SammieI.gf create mode 100644 examples/sammie/SammieSpa.gf create mode 100644 examples/sammie/SammieSwe.gf diff --git a/examples/sammie/ExtSammie.gf b/examples/sammie/ExtSammie.gf new file mode 100644 index 000000000..e69de29bb diff --git a/examples/sammie/ParamSammie.gf b/examples/sammie/ParamSammie.gf new file mode 100644 index 000000000..d79a5002c --- /dev/null +++ b/examples/sammie/ParamSammie.gf @@ -0,0 +1,47 @@ +interface ParamSammie = open Syntax in { + +oper + song_N, track_N, album_N, record_N, cd_N, + playlist_N, artist_N, number_N, rock_N : N ; + new_A : A ; + + add_V3, remove_V3, show_V3 : V3 ; + tell_V2Q, show_V2Q : V2Q ; + create_V2, play_V2, return_V2, goto_V2, + record_V2, make_V2 : V2 ; + stop_V : V ; + + back_Adv : Adv ; + + what_IAdv : IAdv ; + + previous_A, next_A : A ; + please_PConj : PConj ; + + mainmenu_NP : NP ; + + goback_VP : VP ; + shutup_VP : VP ; + pause_VP : VP ; + resume_VP : VP ; + + whatever_Utt : Utt ; + + typeWithGenre : CN -> CN -> CN ; + + name : Str -> PN ; + + WhatName : NP -> QCl ; + + past : Tense * Ant ; + + imperative : VP -> Utt ; + + previous, next : CN -> NP ; + + what_say : Utt ; + all_art : Quant ; + + this : CN -> NP ; + +} diff --git a/examples/sammie/ParamSammieEng.gf b/examples/sammie/ParamSammieEng.gf new file mode 100644 index 000000000..10be19309 --- /dev/null +++ b/examples/sammie/ParamSammieEng.gf @@ -0,0 +1,87 @@ +instance ParamSammieEng of ParamSammie = open + SyntaxEng, + ExtraEng, + SymbolicEng, + ParadigmsEng, + IrregEng, + (C = ConstructX), + Prelude +in { + +oper + + song_N = mkN "song" ; + track_N = mkN "track" ; + album_N = mkN "album" ; + record_N = mkN "record" ; + cd_N = mkN "CD" ; + playlist_N = mkN "playlist" ; + artist_N = mkN "artist" ; + number_N = mkN "number" ; + rock_N = mkN "rock" ; + + new_A = regA "new" ; + + add_V3 = dirV3 (mkV "add") to_Prep ; + remove_V3 = dirV3 (mkV "remove") from_Prep ; + show_V3 = dirdirV3 (mkV "show") ; + + create_V2 = dirV2 (mkV "create") ; + show_V2Q = mkV2Q (dirV2 (mkV "show")) (mkPrep []) ; + tell_V2Q = mkV2Q (dirV2 tell_V) (mkPrep []) ; + play_V2 = dirV2 (mkV "play") ; + return_V2 = mkV2 (mkV "return") to_Prep ; + goto_V2 = mkV2 go_V to_Prep ; + record_V2 = dirV2 (mkV "record") ; + make_V2 = dirV2 make_V ; + + stop_V = regDuplV "stop" ; + + back_Adv = mkAdv "back" ; + + what_IAdv = C.mkIAdv "what" ; + + previous_A = mkA "previous" ; + next_A = mkA "next" ; + please_PConj = C.mkPConj "please" ; + + mainmenu_NP = + mkNP the_Art (mkCN (mkA "main") (mkN "menu")) ; + + goback_VP = mkVP (mkVP go_V) back_Adv ; + shutup_VP = mkVP (partV shut_V "up") ; + pause_VP = mkVP (mkV "pause") ; + resume_VP = mkVP (mkV "resume") ; + + whatever_Utt = C.mkUtt "whatever" ; + + typeWithGenre x genre = mkCN genre (mkNP x) ; + + name = regPN ; + + WhatName = mkQCl what_IAdv ; + + past = ; + + imperative vp = + mkUtt (mkImp vp) + | mkUtt (mkQS (mkQCl (mkCl (mkNP youSg_Pron) can_VV vp))) + | mkUtt (mkCl (mkNP i_Pron) want_VV vp) + | mkUtt vp + ; + + + previous cn = mkNP the_Art (mkCN previous_A cn) ; + next cn = mkNP the_Art (mkCN next_A cn) ; + + what_say = mkUtt whatSg_IP ; + + all_art = a_Art | the_Art ; + + artist_Prep = by8agent_Prep | with_Prep ; + + this cn = + mkNP this_Quant + | mkNP the_Art (mkCN (mkA "current") cn) + ; +} diff --git a/examples/sammie/ParamSammieFin.gf b/examples/sammie/ParamSammieFin.gf new file mode 100644 index 000000000..9e7613b22 --- /dev/null +++ b/examples/sammie/ParamSammieFin.gf @@ -0,0 +1,90 @@ +instance ParamSammieFin of ParamSammie = open + SyntaxFin, + ExtraFin, + SymbolicFin, + (R = ResFin), ---- + ParadigmsFin, + (C = ConstructX), + Prelude +in { + +oper + + song_N = mkN "laulu" ; + track_N = mkN "kappale" ; + album_N = mkN "albumi" ; + record_N = mkN "levy" ; + cd_N = mkN "cd-levy" ; + playlist_N = mkN "soittolista" ; + artist_N = mkN "artisti" ; + number_N = mkN "numero" ; + rock_N = mkN "rock" ; + + new_A = mkA (mkN "uusi" "uuden" "uusia") ; + + add_V3 = + dirV3 (mkV "lisätä") illative ; + remove_V3 = + dirV3 (mkV "poistaa") ablative ; + show_V3 = mkV3 (mkV "näyttää") (casePrep allative) accPrep ; + + create_V2 = dirV2 (mkV "luoda") ; + tell_V2Q = mkV2Q (mkV "sanoa") (casePrep allative) ; + play_V2 = dirV2 (mkV "soittaa") ; + show_V2Q = mkV2Q (mkV "näyttää") (casePrep allative) ; + return_V2 = mkV2 (mkV "palata") to_Prep ; + goto_V2 = mkV2 (mkV "mennä") to_Prep ; + record_V2 = dirV2 (mkV "levyttää") ; + make_V2 = dirV2 (mkV "tehdä" "tekee" "teen" "tekevät" "tehkää" "tehdään" + "teki" "tein" "tekisi" "tehnyt" "tehty" "tehdyn") ; + + stop_V = mkV "lopettaa" ; + + back_Adv = mkAdv "takaisin" ; + + what_IAdv = C.mkIAdv "mikä" ; + + previous_A = mkA "edellinen" ; + next_A = mkA "seuraava" ; + please_PConj = C.mkPConj ["ole hyvä"] ; + + mainmenu_NP = mkNP the_Art (mkN "päävalikko") ; + + goback_VP = mkVP (mkVP (mkV "mennä")) back_Adv ; + shutup_VP = mkVP (mkAdv "hiljaa") ; + pause_VP = mkVP (dirV2 (mkV "pitää")) (mkNP the_Art (mkN "tauko")) ; + resume_VP = mkVP (mkVP (mkV "palata")) (mkAdv "asiaan") ; + + whatever_Utt = C.mkUtt ["mitä tahansa"] ; + + typeWithGenre x genre = + mkCN x (mkRS (RelExistNP in_Prep which_RP (mkNP genre))) ; + + name = mkPN ; + + WhatName = mkQCl what_IAdv ; + + past = ; + + imperative vp = + mkUtt (mkImp vp) + | mkUtt (mkQS (mkQCl (mkCl (mkNP youSg_Pron) can_VV vp))) + | mkUtt (mkCl (mkNP i_Pron) want_VV vp) + | mkUtt vp + ; + + previous cn = mkNP the_Art (mkCN previous_A cn) ; + next cn = mkNP the_Art (mkCN next_A cn) ; + + what_say = mkUtt whatPart_IP ; + + all_art = the_Art ; + + artist_Prep = casePrep ablative ; + + this cn = + mkNP this_Quant + | mkNP the_Art (mkCN (mkA "tämänhetkinen") cn) + ; + +} diff --git a/examples/sammie/ParamSammieFre.gf b/examples/sammie/ParamSammieFre.gf new file mode 100644 index 000000000..d38beb618 --- /dev/null +++ b/examples/sammie/ParamSammieFre.gf @@ -0,0 +1,113 @@ +instance ParamSammieFre of ParamSammie = open + GrammarFre, + SyntaxFre, + ExtraFre, + SymbolFre, + IrregFre, + ParadigmsFre, + (M = MorphoFre), --- + ConstructX, + Prelude +in { + +oper + + song_N = regGenN "chanson" feminine ; + track_N = regN "morceau" ; + album_N = regN "album" ; + record_N = regGenN "disque" masculine ; + cd_N = regN "cd" ; + playlist_N = compN (regN "liste") ["de lecture"] ; + artist_N = regGenN "artiste" masculine ; + number_N = regN "numéro" ; + rock_N = regN "rock" ; + + new_A = + prefA (compADeg (mkA "nouveau" "nouvelle" "nouveaux" "nouvellement")) ; + + add_V3 = + dirdirV3 (regV "ajouter") ; + remove_V3 = + mkV3 (regV "supprimer") accusative genitive ; + show_V3 = mkV3 (regV "montrer") dative accusative ; + + create_V2 = dirV2 (regV "créer") ; + tell_V2 = dire_V2 ; + play_V2 = dirV2 (regV "jouer") ; + show_V2 = mkV2 (regV "montrer") to_Prep ; + return_V2 = mkV2 (regV "retourner") to_Prep ; + goto_V2 = mkV2 aller_V to_Prep ; + record_V2 = dirV2 (regV "enregistrer") ; + make_V2 = faire_V2 ; + + stop_V = regV "arrêter" ; + + back_Adv = mkAdv ["au retour"] ; ---- + + what_IAdv = mkIAdv "quel" ; ---- + + previous_Ord : Ord = + {s = \\ag => (regA "précédent").s ! M.Posit ! M.AF ag.g ag.n ; lock_Ord = <>} ; + next_Ord : Ord = + {s = \\ag => (regA "prochain").s ! M.Posit ! M.AF ag.g ag.n ; lock_Ord = <>} ; + please_PConj = mkPConj ["s'il vous plaît"] ; + + next_A = mkA "prochain" ; + previous_A = mkA "précédent" ; + show_V2Q = mkV2Q (mkV "montrer") dative ; + tell_V2Q = mkV2Q (mkV "raconter") dative ; + + mainmenu_NP = + mkNP the_Quant + (AdjCN (PositA (regA "principal")) (UseN (regN "menu"))) ; + + goback_VP = UseV (regV "retourner") ; + shutup_VP = UseV (reflV taire_V2) ; + pause_VP = + ComplV2 faire_V2 + (mkNP a_Quant (UseN (regN "pause"))) ; + resume_VP = UseV (regV "résumer") ; + + whatever_Utt = mkUtt ["n'importe quoi"] ; + + typeWithGenre x genre = +---- CompoundCN genre x ; + AdvCN x (PrepNP with_Prep + (mkNP genre)) ; + + name = regPN ; + + WhatName x = QuestIAdv how_IAdv (PredVP x (UseV (reflV (regV "appeler")))) ; + + past = ; + + imperative vp = variants { +---- UttImpPol PPos (ImpVP vp) ; +-- UttImpSg PPos (ImpVP vp) ; +-- UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP +-- (UsePron youSg_Pron) (ComplVV can_VV vp)))) ; + SyntaxFre.mkUtt (mkQS (QuestCl (PredVP + (UsePron youPol_Pron) (ComplVV can_VV vp)))) ; + SyntaxFre.mkUtt (mkQS (mkQCl (PredVP (UsePron i_Pron) + (ComplVV want_VV vp)))) ; + UttVP vp + } ; + + previous cn = + mkNP the_Quant + (AdjCN (PositA (regA "précédent")) cn) ; + + next = mkNP the_Quant next_Ord ; + + what_say = UttIAdv how_IAdv ; + + all_art = DefArt ; + + artist_Prep = variants {by8agent_Prep ; with_Prep} ; + + this cn = variants { + mkNP this_Quant cn ; + mkNP the_Quant (mkCN (regA "courant") cn) + } ; + +} diff --git a/examples/sammie/ParamSammieGer.gf b/examples/sammie/ParamSammieGer.gf new file mode 100644 index 000000000..8ac4805f6 --- /dev/null +++ b/examples/sammie/ParamSammieGer.gf @@ -0,0 +1,118 @@ +instance ParamSammieGer of ParamSammie = open + SyntaxGer, + ExtraGer, + SymbolicGer, + ParadigmsGer, + IrregGer, + (ConstructX = ConstructX), + Prelude +in { + +oper + + song_N = mkN "song" "songs" masculine ; + + track_N = variants { + mkN "lied" "lieder" neuter ; + mkN "stück" "stücke" neuter + } ; + + album_N = mkN "album" "album" "album" "albums" "alben" "alben" neuter ; + record_N = mkN "platte" ; + cd_N = mkN "cd" "cds" feminine ; + playlist_N = variants { + mkN "playlist" "playlisten" feminine ; + mkN "wiedergabeliste" + } ; + artist_N = mkN "künstler" ; + number_N = mkN "nummer" "nummern" feminine ; + rock_N = mkN "rock" ; + + new_A = mkA "neu" ; + + add_V3 = + mkV3 (prefixV "hinzu" (mkV "fügen")) accPrep zu_Prep ; + remove_V3 = + mkV3 (prefixV "aus" nehmen_V) accPrep (mkPrep "aus" dative) ; + show_V3 = mkV3 (mkV "zeigen") datPrep accPrep ; + + create_V2 = dirV2 (no_geV (mkV (variants {"erzeugen" ; "erstellen"}))) ; + tell_V2Q = mkV2Q (mkV "sagen") datPrep ; + play_V2 = dirV2 (mkV "spielen") ; + show_V2Q = mkV2Q (mkV "zeigen") datPrep ; + return_V2 = mkV2 (prefixV "zurück" gehen_V) zu_Prep ; + goto_V2 = mkV2 gehen_V to_Prep ; + record_V2 = dirV2 (no_geV (mkV "interpretieren")) ; + --prefixV "ein" (mkV "spielen")) ; + make_V2 = dirV2 (mkV "machen") ; + + stop_V = halten_V ; + + back_Adv = mkAdv "zurück" ; + + what_IAdv = ConstructX.mkIAdv "was" ; + + + + previous_A = mkA "vorig" | mkA "vorhergehend" ; + + next_A = mkA "nächst" | mkA "nachfolgend" | mkA "folgend" ; + + please_PConj = ConstructX.mkPConj "bitte" ; + + mainmenu_NP = + mkNP the_Art + (mkCN (mkN "hauptmenü" "hauptmenüs" neuter)) ; + + goback_VP = mkVP (mkVP gehen_V) back_Adv ; + shutup_VP = mkVP (schweigen_V) ; + pause_VP = mkVP (mkV "pausieren") ; + resume_VP = mkVP (mkV "wiederholen") ; ---- + + whatever_Utt = ConstructX.mkUtt ["irgendwas"] ; + + typeWithGenre x genre = + mkCN x (SyntaxGer.mkAdv with_Prep (mkNP genre)) ; + + name = regPN ; + + WhatName x = mkQCl how_IAdv (mkCl x heißen_V) ; + + past = ; + + imperative vp = + mkUtt (mkImp (bitteVP vp)) + | mkUtt (mkImp vp) + | mkUtt (mkQS (mkQCl (mkCl (mkNP youSg_Pron) can_VV vp))) + | mkUtt (mkQS (mkQCl (mkCl (mkNP youPol_Pron) can_VV vp))) + | mkUtt (mkS (mkCl (mkNP i_Pron) want_VV vp)) + | mkUtt (mkS TImpfSubj (mkCl (mkNP i_Pron) moegen_VV vp)) + | mkUtt vp + ; + + bitteVP : VP -> VP = \vp -> variants { + vp ; + mkVP (ConstructX.mkAdV "bitte") vp + } ; + + previous cn = + mkNP the_Art (mkCN previous_A cn) + | mkNP (mkCN previous_A cn) + ; + next cn = + mkNP the_Art (mkCN next_A cn) + | mkNP (mkCN next_A cn) + ; + + what_say = mkUtt whatSg_IP ; + + all_art = a_Art | the_Art ; + + artist_Prep = by8agent_Prep | with_Prep ; + + this cn = + mkNP this_Quant cn + | mkNP the_Art (mkCN (mkA "aktuell") cn) + ; + +} diff --git a/examples/sammie/ParamSammieSpa.gf b/examples/sammie/ParamSammieSpa.gf new file mode 100644 index 000000000..be829df83 --- /dev/null +++ b/examples/sammie/ParamSammieSpa.gf @@ -0,0 +1,110 @@ +instance ParamSammieSpa of ParamSammie = open + GrammarSpa, + ExtraSpa, + SymbolSpa, + IrregSpa, + (B = BeschSpa), + ParadigmsSpa, + (M = MorphoSpa), --- + ConstructX, + Prelude +in { + +oper + + song_N = femN (regN "canción") ; + track_N = regN "pista" ; + album_N = regN "album" ; + record_N = regN "disco" ; + cd_N = regN "cd" ; + playlist_N = compN (regN "lista") ["de favoritos"] ; --- canciones, pistas + artist_N = mascN (regN "artista") ; --- fem + number_N = regN "número" ; + rock_N = regN "rock" ; + + new_A = + prefA (regA "nuevo") ; + + add_V3 = + dirdirV3 (regV "agregar") ; + remove_V3 = + mkV3 (regV "suprimir") accusative genitive ; + show_V3 = mkV3 (regAltV "mostrar" "muestro") dative accusative ; + + create_V2 = dirV2 (regV "crear") ; + tell_V2 = dirV2 (decir_V) ; + play_V2 = dirV2 (regV "reproducir") ; --- tocar + show_V2 = mkV2 (regAltV "mostrar" "muestro") to_Prep ; + return_V2 = mkV2 volver_V to_Prep ; + goto_V2 = mkV2 ir_V to_Prep ; + record_V2 = dirV2 (regV "registrar") ; + make_V2 = dirV2 (hacer_V) ; + + stop_V = regV "parar" ; --- detener + + back_Adv = mkAdv ["pista previa"] ; ---- + +--- what_IAdv = mkIAdv "cual" ; ---- + + previous_Ord = + {s = \\ag => (regA "previo").s ! M.Posit ! M.AF ag.g ag.n ; lock_Ord = <>} ; + next_Ord = + {s = \\ag => (regA "siguente").s ! M.Posit ! M.AF ag.g ag.n ; lock_Ord = <>} ; + please_PConj = mkPConj ["por favor"] ; + + mainmenu_NP = + DetCN (DetSg (SgQuant DefArt) NoOrd) + (AdjCN (PositA (regA "principal")) (UseN (regN "menú"))) ; + + goback_VP = UseV (regV "volver") ; + shutup_VP = UseV (reflV (dirV2 (regV "callar"))) ; ---- silencio + pause_VP = + ComplV2 (dirV2 (hacer_V)) + (DetCN (DetSg (SgQuant IndefArt) NoOrd) (UseN (regN "pausa"))) ; ---pausar + resume_VP = UseV (regV "continuar") ; --- reproducir + + whatever_Utt = mkUtt ["no importa cual"] ; --- cualquiera + + typeWithGenre x genre = +---- CompoundCN genre x ; + AdvCN x (PrepNP genitive + (DetCN (DetSg MassDet NoOrd) genre)) ; + + name = regPN ; + + WhatName x = + QuestIAdv how_IAdv (PredVP x (UseV (reflV (regV "llamar")))) ; + + past = ; + + imperative vp = variants { +-- UttImpPol PPos (ImpVP vp) ; + UttImpSg PPos (ImpVP vp) +-- UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP +-- (UsePron youSg_Pron) (ComplVV can_VV vp)))) ; +-- UttQS (UseQCl TPres ASimul PPos (QuestCl (PredVP +-- (UsePron youPol_Pron) (ComplVV can_VV vp)))) ; +-- UttS (UseCl TPres ASimul PPos (PredVP (UsePron i_Pron) +-- (ComplVV want_VV vp))) ; +-- UttVP vp + } ; + + previous cn = + DetCN (DetSg (SgQuant DefArt) NoOrd) + (AdjCN (PositA (regA "previo")) cn) ; + + next = DetCN (DetSg (SgQuant DefArt) next_Ord) ; + + what_say = UttIAdv how_IAdv ; + + all_art = DefArt ; + + artist_Prep = variants {by8agent_Prep ; genitive} ; + + this cn = variants { + DetCN (DetSg (SgQuant this_Quant) NoOrd) cn ; + DetCN (DetSg (SgQuant DefArt) NoOrd) + (AdjCN (PositA (regA "actual")) cn) + } ; + +} diff --git a/examples/sammie/ParamSammieSwe.gf b/examples/sammie/ParamSammieSwe.gf new file mode 100644 index 000000000..b9259c7a9 --- /dev/null +++ b/examples/sammie/ParamSammieSwe.gf @@ -0,0 +1,93 @@ +instance ParamSammieSwe of ParamSammie = open + SyntaxSwe, + GrammarSwe, + ExtraSwe, + SymbolSwe, + ParadigmsSwe, + IrregSwe, + ConstructX, + Prelude +in { + +oper + + song_N = mk1N "sångerna" ; + track_N = mk1N "låtarna" ; + album_N = mk1N "albumen" ; + record_N = regN "platta" ; + cd_N = regN "cd-skiva" ; + playlist_N = regN "spellista" ; + artist_N = mk1N "artisterna" ; + number_N = mkN "nummer" "numret" "nummer" "numren" ; + rock_N = regN "rock" ; + + new_A = regA "ny" ; + + add_V3 = + mkV3 (partV lägga_V "till") noPrep (mkPrep "till") ; + remove_V3 = + mkV3 (partV taga_V "bort") noPrep (mkPrep "från") ; + show_V3 = dirdirV3 (regV "visa") ; + + create_V2 = dirV2 (regV "skapa") ; + tell_V2 = dirV2 säga_V ; + play_V2 = dirV2 (regV "spela") ; + show_V2 = dirV2 (regV "visa") ; + return_V2 = mkV2 (regV "återvänder") to_Prep ; + goto_V2 = mkV2 gå_V to_Prep ; + record_V2 = dirV2 (partV (regV "spela") "in") ; + make_V2 = dirV2 göra_V ; + + stop_V = regV "stanna" ; + + back_Adv = mkAdv "tillbaka" ; + + what_IAdv = mkIAdv "vad" ; + + previous_Ord = {s = "föregående" ; isDet = False ; lock_Ord = <>} ; + next_Ord = {s = "nästa" ; isDet = False ; lock_Ord = <>} ; + please_PConj = mkPConj "snälla" ; + + next_A = mkA "näst" ; --- not used + previous_A = mkA "föregående" ; --- not used + show_V2Q = mkV2Q (mkV "visa") noPrep ; + tell_V2Q = mkV2Q (mkV "berätta") noPrep ; + + mainmenu_NP = + mkNP the_Quant + (UseN (mk2N "huvudmeny" "huvudmenyer")) ; + + goback_VP = AdvVP (UseV gå_V) back_Adv ; + shutup_VP = UseV (tiga_V) ; + pause_VP = UseV (regV "pausa") ; + resume_VP = UseV (irregV "återupptaga" "återupptog" "återupptagit") ; + + whatever_Utt = mkUtt ["vad som helst"] ; + + typeWithGenre x genre = +---- CompoundCN genre x ; + AdvCN x (PrepNP with_Prep + (mkNP genre)) ; + + name = regPN ; + + WhatName x = mkQCl whatSg_IP x (dirV2 (mk2V "heta" "hette")) ; + past = ; + + imperative = SyntaxSwe.mkUtt ; + + previous cn = mkNP the_Art cn ; --previous_Ord cn ; + next cn = mkNP the_Art cn ; --next_Ord cn ; + + what_say = UttIP whatSg_IP ; + + all_art = variants {IndefArt ; DefArt} ; + + artist_Prep = variants {by8agent_Prep ; with_Prep} ; + + this cn = variants { + mkNP this_Quant cn ; + mkNP the_Quant + (AdjCN (PositA (regA "nuvarande")) cn) + } ; +} diff --git a/examples/sammie/Sammie.gf b/examples/sammie/Sammie.gf new file mode 100644 index 000000000..d45473c48 --- /dev/null +++ b/examples/sammie/Sammie.gf @@ -0,0 +1,174 @@ +abstract Sammie = { + +flags + startcat = Action ; + +cat + Action; + ToIdentify; + Object; + PlaylistSet; Playlist; + ArtistSet; Artist; + AlbumSet; Album; + SongSet; Song; + Number; + + PlaylistName; + Genre; + ArtistName; + AlbumName; + SongName; + +fun + + -- Action + + add_song_to_playlist : Playlist -> Object -> Action ; + + -- create a new playlist + create : Action ; + + dialog_pause : Action ; + + go_back_in_display_history : Action ; + + help : Action ; + + -- tell me + identify : ToIdentify -> Action ; + +-- what is this? +-- identify_songlist_of_album : Album -> Action ; + + -- gives just an object as a response to a question + make_completion : Object -> Action ; + + pause : Action ; + + play : Object -> Action ; + + please_repeat : Action ; + + -- I don't care + reject_any_constraint_determination : Action ; + + remove : Playlist -> Object -> Action ; + + resume : Action ; + + -- show me + show : ToIdentify -> Action ; + + show_main_menu : Action ; + + skip_backward : Action ; + + skip_forward : Action ; + + stop : Action ; + + -- ToIdentify + + artist_of_album : Album -> ToIdentify ; + artist_of_song : Song -> ToIdentify ; + currently_playing_object : ToIdentify ; + resource_by_type : Object -> ToIdentify ; + + -- Object + + one_song : Song -> Object ; + any_song : SongSet -> Object ; + all_songs : SongSet -> Object ; + + one_album : Album -> Object ; + any_album : AlbumSet -> Object ; + all_albums : AlbumSet -> Object ; + + one_playlist : Playlist -> Object ; + any_playlist : PlaylistSet -> Object ; + all_playlists : PlaylistSet -> Object ; + + -- PlaylistSet + + playlists_all : PlaylistSet ; + playlists_by_genre : Genre -> PlaylistSet ; + + -- Playlist + + playlist_this : Playlist ; + playlist_number : Number -> Playlist ; + playlist_name : PlaylistName -> Playlist ; + + -- ArtistSet + + artists_all : ArtistSet ; + + -- Artist + + artist_this : Artist ; + artist_name : ArtistName -> Artist ; + + -- AlbumSet + + albums_all : AlbumSet ; + albums_by_artist : Artist -> AlbumSet ; + albums_by_genre : Genre -> AlbumSet ; + albums_by_artist_genre : Artist -> Genre -> AlbumSet ; + + -- Album + + album_this : Album ; + album_number : Number -> Album ; + album_name : AlbumName -> Album ; + album_name_artist : AlbumName -> Artist -> Album ; + + -- SongSet + + songs_all : SongSet ; + songs_by_artist : Artist -> SongSet ; + songs_by_genre : Genre -> SongSet ; + songs_by_album : Album -> SongSet ; + songs_by_artist_genre : Artist -> Genre -> SongSet ; + + -- Song + + song_this : Song ; + song_name : SongName -> Song ; + song_name_artist : SongName -> Artist -> Song ; + + -- Ordinal + + num_1 : Number ; + num_2 : Number ; + num_3 : Number ; + + + -- Music database + + -- PlaylistName + + CoolHits : PlaylistName ; +-- Romantik : PlaylistName ; + + -- Artist + +-- Falco : ArtistName ; +-- TheBeatles : ArtistName ; + U2 : ArtistName ; + + -- Genre + +-- Pop : Genre ; + Rock : Genre ; + + -- AlbumName + + HowToDismantleAnAtomicBomb : AlbumName ; + + -- SongName + +-- AHardDaysNight : SongName ; +-- LetItBe : SongName ; + Vertigo : SongName ; + +} diff --git a/examples/sammie/SammieEng.gf b/examples/sammie/SammieEng.gf new file mode 100644 index 000000000..485c82eb5 --- /dev/null +++ b/examples/sammie/SammieEng.gf @@ -0,0 +1,6 @@ +--# -path=.:alltenses + +concrete SammieEng of Sammie = SammieI with + (Syntax = SyntaxEng), + (Symbolic = SymbolicEng), + (ParamSammie = ParamSammieEng) ; diff --git a/examples/sammie/SammieEng1.gf b/examples/sammie/SammieEng1.gf new file mode 100644 index 000000000..adc541e79 --- /dev/null +++ b/examples/sammie/SammieEng1.gf @@ -0,0 +1,235 @@ + +concrete SammieEng1 of Sammie = { + +flags startcat=Action; + +param SetForm = Any | All; + +oper Set = { s : SetForm => Str } ; + +oper mkSet : Str -> Set = \x -> { s = table { + Any => variants { "a"; "some"; "any" } ++ x ; + All => variants { "all"; ["all the"] } ++ (x + "s") + } } ; + +oper mkSetAdj : Str -> Str -> Set = \x -> \adj -> { s = table { + Any => variants { "a"; "some"; "any" } ++ adj ++ x ; + All => variants { "all"; ["all the"] } ++ adj ++ (x + "s") + } } ; + +oper optional : Str -> Str = \s -> variants { []; s } ; + +oper song = variants {"song"; "track"} ; +oper album = variants {"album";"record";"cd"} ; + +oper command : Str -> { s : Str } = + \s -> { s = variants {s; "please" ++ s; s ++ "please" } } ; + + +lincat + PlaylistSet, ArtistSet, AlbumSet, SongSet = Set ; + + +lin + -- Action + + add_song_to_playlist l o = + command ("add" ++ o.s ++ "to" ++ l.s) ; + + -- create a new playlist + create = + command ["create a new playlist"] ; + + dialog_pause = + command (variants { + ["pause the dialog"]; + ["be"] ++ variants { "quiet";"silent" }; + ["shut"] ++ variants {[]; ["the hell"]; ["the fuck"]} ++ "up"; + ["shut your mouth"]; + ["put a sock in it"]; + }); + + go_back_in_display_history = + command (variants { ["back"]; ["go back"] }) ; + + help = + command (variants { ["help"]; ["help me"]; ["give me help"] }) ; + + -- tell me + identify x = + command (optional ["tell me"] ++ x.s) ; + +-- identify_songlist_of_album x = command (x.s) ; + + make_completion x = command (x.s) ; + + pause = + command "pause" ; + + play x = + command ("play" ++ x.s) ; + + please_repeat = + command (variants { + ["repeat that"]; + ["what"]; + ["pardon"]; + ["pardon me"]; + ["what did you say"]; + ["what was that"] + }) ; + + -- I don't care + reject_any_constraint_determination = + command (variants { + ["whatever"]; + variants {["do i look like i"];["i don't"]} + ++ variants {["give a"] ++ variants {"shit";"fuck";["rat's ass"]}; + ["care"]} + ++ optional ["about that"]; + ["i couldn't care less"]; + ["see if i care"] + }) ; + + remove l o = + command ("remove" ++ o.s ++ "from" ++ l.s) ; + + resume = + command ("resume") ; + + -- show me + + show x = + command (["show me"] ++ x.s) ; + + show_main_menu = + command (variants { + ["show me the main menu"]; + ["go to the main menu"]; + ["back to the main menu"]; + }) ; + + skip_backward = + command (variants {"play"; ["go to"]} ++ ["the previous"] ++ song) ; + + skip_forward = + command (variants {"play"; ["go to"]} ++ ["the next"] ++ song) ; + + stop = command (variants { "stop" }) ; + + -- ToIdentify + + artist_of_album album = + { s = "who" ++ variants {"made";"sings";"plays";"recorded"} ++ album.s } ; + + artist_of_song song = + { s = "who" ++ variants {"made";"sings";"plays";"recorded"} ++ song.s } ; + + currently_playing_object = + { s = variants { + ["what is this"] ++ optional song ++ ["called"]; + ["what is the name of this"] ++ optional song; + } } ; + + resource_by_type x = { s = x.s } ; + + -- Object + + one_song x = { s = x.s } ; + any_song x = { s = x.s ! Any} ; + all_songs x = { s = x.s ! All } ; + + one_album x = { s = x.s } ; + any_album x = { s = x.s ! Any} ; + all_albums x = { s = x.s ! All } ; + + one_playlist x = { s = x.s } ; + any_playlist x = { s = x.s ! Any} ; + all_playlists x = { s = x.s ! All } ; + + + -- PlaylistSet + + playlists_all = mkSet "playlist" ; + playlists_by_genre genre = mkSetAdj "playlist" (genre.s) ; + + -- Playlist + + playlist_this = { s = ["this playlist"] } ; + playlist_number x = { s = "playlist" ++ x.s } ; + playlist_name x = { s = variants { ["the playlist"] ++ x.s; "the" ++ x.s ++ "playlist" }}; + + -- ArtistSet + + artists_all = mkSet "artist" ; + + -- Artist + + artist_this = { s = ["this artist"] } ; + artist_name x = { s = optional ["the artist"] ++ x.s } ; + + -- AlbumSet + + albums_all = mkSet album ; + albums_by_artist artist = { s = \\n => (mkSet album).s ! n ++ "by" ++ artist.s }; + albums_by_genre genre = mkSetAdj album (genre.s) ; + albums_by_artist_genre artist genre = { s = \\n => (mkSetAdj album (genre.s)).s ! n ++ "by" ++ artist.s }; + + -- Album + + album_this = { s = ["this"] ++ album } ; + album_number n = { s = album ++ ["number"] ++ n.s } ; + album_name name = { s = optional (["the"] ++ album) ++ name.s } ; + album_name_artist name artist = { s = optional (["the"] ++ album) ++ name.s ++ "by" ++ artist.s } ; + + -- SongSet + + songs_all = mkSet song ; + songs_by_artist artist = { s = \\n => (mkSet song).s ! n ++ "by" ++ artist.s }; + songs_by_genre genre = mkSetAdj song (genre.s) ; + songs_by_album album = { s = \\n => (mkSet song).s ! n ++ "from" ++ album.s } ; + songs_by_artist_genre artist genre = { s = \\n => (mkSetAdj song (genre.s)).s ! n ++ "by" ++ artist.s }; + + -- Song + + song_this = { s = "this" ++ song } ; + song_name x = { s = optional ("the" ++ song) ++ x.s } ; + song_name_artist name artist = { s = optional ("the" ++ song) ++ name.s ++ "by" ++ artist.s } ; + + -- Ordinal + +-- num_1 = { s = "one" } ; + num_2 = { s = "two" } ; +-- num_3 = { s = "three" } ; + + + + -- Music database + + -- PlaylistName + + CoolHits = { s = ["cool hits"] }; +-- Romantik = { s = ["romance"] }; + + -- Artist + +-- Falco = { s = ["Falco"] }; +-- TheBeatles = { s = ["The Beatles"] }; + U2 = { s = "u2" } ; + + -- Genre + +-- Pop = { s = ["pop"] }; + Rock = { s = ["rock"] }; + + -- AlbumName + + HowToDismantleAnAtomicBomb = { s = ["how to dismantle an atomic bomb"] }; + + -- SongName + +-- AHardDaysNight = { s = ["a hard day's night"] }; +-- LetItBe = { s = ["let it be"] }; + Vertigo = { s = "vertigo" } ; + +} \ No newline at end of file diff --git a/examples/sammie/SammieFin.gf b/examples/sammie/SammieFin.gf new file mode 100644 index 000000000..05bfa41ad --- /dev/null +++ b/examples/sammie/SammieFin.gf @@ -0,0 +1,7 @@ +--# -path=.:alltenses + +concrete SammieFin of Sammie = SammieI with + (Syntax = SyntaxFin), + (Symbolic = SymbolicFin), + (ParamSammie = ParamSammieFin) + ; diff --git a/examples/sammie/SammieFre.gf b/examples/sammie/SammieFre.gf new file mode 100644 index 000000000..863905db9 --- /dev/null +++ b/examples/sammie/SammieFre.gf @@ -0,0 +1,7 @@ +--# -path=.:alltenses + +concrete SammieFre of Sammie = SammieI with + (Syntax = SyntaxFre), + (Symbolic = SymbolicFre), + (ParamSammie = ParamSammieFre) + ; diff --git a/examples/sammie/SammieGer.gf b/examples/sammie/SammieGer.gf new file mode 100644 index 000000000..fe64fb25d --- /dev/null +++ b/examples/sammie/SammieGer.gf @@ -0,0 +1,7 @@ +--# -path=.:alltenses + +concrete SammieGer of Sammie = SammieI with + (Syntax = SyntaxGer), + (Symbolic = SymbolicGer), + (ParamSammie = ParamSammieGer) + ; diff --git a/examples/sammie/SammieGer2.gf b/examples/sammie/SammieGer2.gf new file mode 100644 index 000000000..51490f6a5 --- /dev/null +++ b/examples/sammie/SammieGer2.gf @@ -0,0 +1,459 @@ +--# -path=.:alltenses + +---- doesn't compile yet (AR 8/10/2009) + +concrete SammieGer2 of Sammie = open + + SyntaxGer, ---- should be used + + GrammarGer, + ExtraGer, + SymbolGer, + ParadigmsGer, + IrregGer, + (R = ResGer), ---- + ConstructX, + Prelude +in { + +flags startcat=Action; + +param SetForm = Any | All ; + +oper Set = { s : SetForm => NP } ; + +oper mkSet : CN -> Set = \x -> { s = table { + Any => variants { + DetCN someSg_Det x ; + DetCN (DetSg (SgQuant IndefArt) NoOrd) x + } ; + All => + PredetNP all_Predet (DetCN (DetPl (PlQuant all_art) NoNum NoOrd) x) + } + } ; + +oper mkSetAdj : CN -> A -> Set = \x, adj -> + mkSet (AdjCN (PositA adj) x) ; + +oper optional : Str -> Str = \s -> variants { []; s } ; + +oper song = UseN (variants {song_N ; track_N}) ; +oper album = UseN (variants {album_N ; record_N ; cd_N}) ; + +oper command : Utt -> Phr = \s -> variants { + PhrUtt NoPConj s NoVoc ; + PhrUtt NoPConj s please_Voc ; + PhrUtt please_PConj s NoVoc + } ; + + withGenre : CN -> CN -> Set = \x,y -> + mkSet (typeWithGenre x y) ; + + withGenreBy : CN -> NP -> CN -> Set = \x,z,y -> + mkSet (AdvCN (typeWithGenre x y) (PrepNP artist_Prep z)) ; + +---- + +lincat + Action = Phr ; + + Object, Playlist, Artist, Album, Song = NP ; + + PlaylistName, ArtistName, AlbumName, SongName = PN ; + + PlaylistSet, ArtistSet, AlbumSet, SongSet = Set ; + + ToIdentify = QS ; + + Genre = CN ; + + Number = Num ; + +lin + -- Action + + add_song_to_playlist l o = + command (imperative PPos (ImpVP (ComplV3 add_V3 o l))) ; + + create = + command + (imperative PPos (ImpVP (ComplV2 create_V2 + (DetCN (DetSg (SgQuant IndefArt) NoOrd) + (AdjCN (PositA new_A) (UseN playlist_N)))))) ; + + dialog_pause = + command (imperative PPos (ImpVP shutup_VP)) ; + + go_back_in_display_history = + command (variants { + UttAdv back_Adv ; + imperative PPos (ImpVP goback_VP) + } + ) ; + + help = + command (imperative PPos (ImpVP goback_VP)) ; + + -- tell me + identify x = + command (variants { + UttQS x ; + imperative PPos (ImpVP (AdvVP (ComplV2 tell_V2 (UsePron i_Pron)) + (AdvSC (EmbedQS x)))) + } + ) ; + +-- identify_songlist_of_album x = command (x.s) ; + + make_completion x = command (UttNP x) ; + + pause = + command (imperative PPos (ImpVP pause_VP)) ; + + play x = + command (imperative PPos (ImpVP (ComplV2 play_V2 x))) ; + + please_repeat = command what_say ; + + reject_any_constraint_determination = + command (whatever_Utt) ; + + remove l o = + command (imperative PPos (ImpVP (ComplV3 remove_V3 o l))) ; + + resume = + command (imperative PPos (ImpVP resume_VP)) ; + + -- show me + + show x = + command ( + imperative PPos (ImpVP (AdvVP (ComplV2 show_V2 (UsePron i_Pron)) + (AdvSC (EmbedQS x))))) ; + + show_main_menu = + command (variants { + imperative PPos (ImpVP (ComplV3 show_V3 (UsePron i_Pron) mainmenu_NP)) ; + imperative PPos (ImpVP (ComplV2 return_V2 mainmenu_NP)) + } + ) ; + + skip_backward = + command (variants { + imperative PPos (ImpVP (ComplV2 play_V2 (previous song))) ; + imperative PPos (ImpVP (ComplV2 goto_V2 (previous song))) + } + ) ; + + skip_forward = + command (variants { + imperative PPos (ImpVP (ComplV2 play_V2 (next song))) ; + imperative PPos (ImpVP (ComplV2 goto_V2 (next song))) + } + ) ; + + stop = command (imperative PPos (ImpVP (UseV stop_V))) ; + + -- ToIdentify + + artist_of_album album = + UseQCl past.p1 past.p2 PPos (QuestVP whoSg_IP + (variants {ComplV2 record_V2 album ; ComplV2 make_V2 album})) ; +--- { s = "who" ++ variants {"made";"sings";"plays";"recorded"} ++ album.s } ; + + artist_of_song song = + UseQCl past.p1 past.p2 PPos (QuestVP whoSg_IP (ComplV2 record_V2 song)) ; + + currently_playing_object = + UseQCl TPres ASimul PPos (WhatName + (this song)) ; + +{- --- + { s = variants { + ["what is this"] ++ optional song ++ ["called"]; + ["what is the name of this"] ++ optional song; + } } ; +-} + + resource_by_type x = ---T + UseQCl TPres ASimul PPos (WhatName x) ; + + -- Object + + one_song x = x ; + any_song x = x.s ! Any ; + all_songs x = x.s ! All ; + + one_album x = x ; + any_album x = x.s ! Any ; + all_albums x = x.s ! All ; + + one_playlist x = x ; + any_playlist x = x.s ! Any ; + all_playlists x = x.s ! All ; + + + -- PlaylistSet + + playlists_all = mkSet (UseN playlist_N) ; + playlists_by_genre = withGenre (UseN playlist_N) ; + + -- Playlist + + playlist_this = this (UseN playlist_N) ; +-- DetCN (DetSg (SgQuant this_Quant) NoOrd) (UseN playlist_N) ; + playlist_number x = + CNNumNP (UseN playlist_N) x ; + playlist_name x = + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN (UseN playlist_N) (UsePN x)) ; + + -- ArtistSet + + artists_all = mkSet (UseN artist_N) ; + + -- Artist + + artist_this = this (UseN artist_N) ; + -- DetCN (DetSg (SgQuant this_Quant) NoOrd) (UseN artist_N) ; + artist_name x =variants { + UsePN x ; + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN (UseN artist_N) (UsePN x)) + } ; + + -- AlbumSet + + albums_all = mkSet album ; + albums_by_artist artist = + mkSet (AdvCN album (PrepNP artist_Prep artist)) ; + albums_by_genre = withGenre album ; + + albums_by_artist_genre = withGenreBy album ; + + -- Album + + album_this = + this album ; + + album_number x = variants { + CNNumNP (ApposCN album (CNNumNP (UseN number_N) x)) NoNum ; + CNNumNP album x + } ; + album_name x = variants { + UsePN x ; + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN album (UsePN x)) + } ; + + album_name_artist x y = AdvNP (variants { + UsePN x ; + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN album (UsePN x)) + }) (PrepNP artist_Prep y) ; + + -- SongSet + + songs_all = mkSet song ; + songs_by_artist artist = + mkSet (AdvCN song (PrepNP artist_Prep artist)) ; + songs_by_genre = withGenre song ; + songs_by_album album = + mkSet (AdvCN song (PrepNP from_Prep album)) ; + + songs_by_artist_genre = withGenreBy song ; + + -- Song + + song_this = this song ; + -- DetCN (DetSg (SgQuant this_Quant) NoOrd) song ; + song_name x = variants { + UsePN x ; + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN song (UsePN x)) + } ; + song_name_artist x y = AdvNP (variants { + UsePN x ; + DetCN (DetSg (SgQuant DefArt) NoOrd) (ApposCN song (UsePN x)) + }) (PrepNP artist_Prep y) ; + + -- Ordinal + +-- num_1 = NumNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))) ; + num_2 = NumNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n2))))) ; +-- num_3 = { s = "three" } ; + + + + -- Music database + + -- PlaylistName + + CoolHits = name ["cool_hits"] ; +-- Romantik = { s = ["romance"] }; + + -- Artist + +-- Falco = { s = ["Falco"] }; +-- TheBeatles = { s = ["The Beatles"] }; + U2 = name "u2" ; + + -- Genre + +-- Pop = { s = ["pop"] }; + Rock = UseN rock_N ; + + -- AlbumName + + HowToDismantleAnAtomicBomb = name ["how_to_dismantle_an_atomic_bomb"]; + + -- SongName + +-- AHardDaysNight = { s = ["a hard day's night"] }; +-- LetItBe = { s = ["let it be"] }; + Vertigo = name ["vertigo"] ; + +-- } +-- instance ParamSammieGer of ParamSammie = open + +oper + + song_N = variants { + reg2N "lied" "lieder" neuter ; + reg2N "song" "songs" masculine + } ; + track_N = reg2N "stück" "stücke" neuter ; + album_N = mkN "album" "album" "album" "albums" "alben" "alben" neuter ; + record_N = regN "platte" ; + cd_N = reg2N "cd" "cds" feminine ; + playlist_N = variants { + reg2N "playlist" "playlisten" feminine ; + regN "wiedergabeliste" + } ; + artist_N = regN "künstler" ; + number_N = reg2N "nummer" "nummern" feminine ; + rock_N = regN "rock" ; + + new_A = regA "neu" ; + + add_V3 = + mkV3 (prefixV "hinzu" (regV "fügen")) accPrep zu_Prep ; + remove_V3 = + mkV3 (prefixV "aus" nehmen_V) accPrep (mkPrep "aus" dative) ; + show_V3 = mkV3 (regV "zeigen") datPrep accPrep ; + + create_V2 = dirV2 (no_geV (regV (variants {"erzeugen" ; "erstellen"}))) ; + tell_V2 = mkV2 (regV "sagen") datPrep ; + play_V2 = dirV2 (regV "spielen") ; + show_V2 = mkV2 (regV "zeigen") datPrep ; + return_V2 = mkV2 (prefixV "zurück" gehen_V) zu_Prep ; + goto_V2 = mkV2 gehen_V to_Prep ; + record_V2 = dirV2 (no_geV (regV "interpretieren")) ; + --prefixV "ein" (regV "spielen")) ; + make_V2 = dirV2 (regV "machen") ; + + stop_V = halten_V ; + + back_Adv = mkAdv "zurück" ; + + what_IAdv = mkIAdv "was" ; + + + + previous_Ord = + {s = variants { + (regA "vorig").s ! R.Posit ; + (regA "vorhergehend").s ! R.Posit + } ; + lock_Ord = <> + } ; + next_Ord = + {s = variants { + (regA "nächst").s ! R.Posit ; + (regA "nachfolgend").s ! R.Posit + } ; + lock_Ord = <> + } ; + + please_PConj = mkPConj "bitte" ; + + mainmenu_NP = + DetCN (DetSg (SgQuant DefArt) NoOrd) + (UseN (reg2N "hauptmenü" "hauptmenüs" neuter)) ; + + goback_VP = AdvVP (UseV gehen_V) back_Adv ; + shutup_VP = UseV (schweigen_V) ; + pause_VP = UseV (regV "pausieren") ; + resume_VP = UseV (regV "wiederholen") ; ---- + + whatever_Utt = mkUtt ["irgendwas"] ; + + typeWithGenre x genre = +---- CompoundCN genre x ; + AdvCN x (PrepNP with_Prep + (DetCN (DetSg MassDet NoOrd) genre)) ; + + name = regPN ; + + WhatName x = QuestIAdv how_IAdv (PredVP x (UseV heißen_V)) ; + + past = ; + + imperative = variants { UttImpPol ; UttImpSg } ; + + previous = DetCN (DetSg (SgQuant DefArt) previous_Ord) ; + next = DetCN (DetSg (SgQuant DefArt) next_Ord) ; + + what_say = UttIP whatSg_IP ; + + all_art = variants {IndefArt ; DefArt} ; + + artist_Prep = variants {by8agent_Prep ; with_Prep} ; + + this cn = variants { + DetCN (DetSg (SgQuant this_Quant) NoOrd) cn ; + DetCN (DetSg (SgQuant DefArt) NoOrd) + (AdjCN (PositA (regA "aktuell")) cn) + } ; + +-- interface ParamSammie = open Grammar in { + +oper + song_N, track_N, album_N, record_N, cd_N, + playlist_N, artist_N, number_N, rock_N : N ; + new_A : A ; + + add_V3, remove_V3, show_V3 : V3 ; + create_V2, tell_V2, play_V2, show_V2, return_V2, goto_V2, + record_V2, make_V2 : V2 ; + stop_V : V ; + + back_Adv : Adv ; + + what_IAdv : IAdv ; + + previous_Ord, next_Ord : Ord ; + please_PConj : PConj ; + + mainmenu_NP : NP ; + + goback_VP : VP ; + shutup_VP : VP ; + pause_VP : VP ; + resume_VP : VP ; + + whatever_Utt : Utt ; + + typeWithGenre : CN -> CN -> CN ; + + name : Str -> PN ; + + WhatName : NP -> QCl ; + + past : Tense * Ant ; + + imperative : Pol -> Imp -> Utt ; + + previous, next : CN -> NP ; + + what_say : Utt ; + all_art : Quant ; + + this : CN -> NP ; + +} diff --git a/examples/sammie/SammieI.gf b/examples/sammie/SammieI.gf new file mode 100644 index 000000000..664429b73 --- /dev/null +++ b/examples/sammie/SammieI.gf @@ -0,0 +1,287 @@ +--# -path=.:alltenses + +incomplete concrete SammieI of Sammie = open + Syntax, + Symbolic, + ParamSammie +in { + +flags startcat=Action; + +param SetForm = Any | All ; + +oper Set = { s : SetForm => NP } ; + +oper mkSet : CN -> Set = \x -> { s = table { + Any => variants { + mkNP someSg_Det x ; + mkNP a_Art x + } ; + All => + mkNP all_Predet (mkNP all_art plNum x) + } + } ; + +oper mkSetAdj : CN -> A -> Set = \x, adj -> + mkSet (mkCN adj x) ; + +oper optional : Str -> Str = \s -> [] | s ; + +oper song = mkCN (song_N | track_N) ; +oper album = mkCN (album_N | record_N | cd_N) ; + +oper command : Utt -> Phr = \s -> + mkPhr s + | mkPhr s please_Voc + | mkPhr please_PConj s ; + + withGenre : CN -> CN -> Set = \x,y -> + mkSet (typeWithGenre x y) ; + + withGenreBy : CN -> NP -> CN -> Set = \x,z,y -> + mkSet (mkCN (typeWithGenre x y) (mkAdv artist_Prep z)) ; + +---- + +lincat + Action = Phr ; + + Object, Playlist, Artist, Album, Song = NP ; + + PlaylistName, ArtistName, AlbumName, SongName = PN ; + + PlaylistSet, ArtistSet, AlbumSet, SongSet = Set ; + + ToIdentify = QS ; + + Genre = CN ; + + Number = Card ; + +lin + -- Action + + add_song_to_playlist l o = + command (imperative (mkVP add_V3 o l)) ; + + create = + command + (imperative (mkVP create_V2 + (mkNP a_Art (mkCN new_A playlist_N)))) ; + + dialog_pause = + command (imperative ( shutup_VP)) ; + + go_back_in_display_history = + command ( + mkUtt back_Adv | + imperative goback_VP + ) ; + + help = + command (imperative goback_VP) ; + + -- tell me + identify x = + command ( + mkUtt x | + imperative (mkVP tell_V2Q (mkNP i_Pron) x) + ) ; + +-- identify_songlist_of_album x = command (x.s) ; + + make_completion x = command (mkUtt x) ; + + pause = + command (imperative pause_VP) ; + + play x = + command (imperative (mkVP play_V2 x)) ; + + please_repeat = command what_say ; + + reject_any_constraint_determination = + command (whatever_Utt) ; + + remove l o = + command (imperative (mkVP remove_V3 o l)) ; + + resume = + command (imperative resume_VP) ; + + -- show me + + show x = + command ( + imperative (mkVP show_V2Q (mkNP i_Pron) x) + ) ; + + show_main_menu = + command ( + imperative (mkVP show_V3 (mkNP i_Pron) mainmenu_NP) + | imperative (mkVP return_V2 mainmenu_NP) + ) ; + + skip_backward = + command ( + imperative (mkVP play_V2 (previous song)) + | imperative (mkVP goto_V2 (previous song)) + ) ; + + skip_forward = + command (variants { + imperative (mkVP play_V2 (next song)) + | imperative (mkVP goto_V2 (next song)) + } + ) ; + + stop = command (imperative (mkVP stop_V)) ; + + -- ToIdentify + + artist_of_album album = + mkQS past.p1 past.p2 + (mkQCl whoSg_IP (mkVP (record_V2 | make_V2) album)) ; + + artist_of_song song = + mkQS past.p1 past.p2 (mkQCl whoSg_IP (mkVP record_V2 song)) ; + + currently_playing_object = + mkQS (WhatName (this song)) ; + + resource_by_type x = + mkQS (WhatName x) ; + + -- Object + + one_song x = x ; + any_song x = x.s ! Any ; + all_songs x = x.s ! All ; + + one_album x = x ; + any_album x = x.s ! Any ; + all_albums x = x.s ! All ; + + one_playlist x = x ; + any_playlist x = x.s ! Any ; + all_playlists x = x.s ! All ; + + + -- PlaylistSet + + playlists_all = mkSet (mkCN playlist_N) ; + playlists_by_genre = withGenre (mkCN playlist_N) ; + + -- Playlist + + playlist_this = this (mkCN playlist_N) ; + + playlist_number x = + symb (mkCN playlist_N) x ; + playlist_name x = + mkNP the_Art (mkCN (mkCN playlist_N) (mkNP x)) ; + + -- ArtistSet + + artists_all = mkSet (mkCN artist_N) ; + + -- Artist + + artist_this = this (mkCN artist_N) ; + + artist_name x = + mkNP x + | mkNP the_Art (mkCN (mkCN artist_N) (mkNP x)) + ; + + -- AlbumSet + + albums_all = mkSet album ; + albums_by_artist artist = + mkSet (mkCN album (mkAdv artist_Prep artist)) ; + albums_by_genre = withGenre album ; + + albums_by_artist_genre = withGenreBy album ; + + -- Album + + album_this = + this album ; + + album_number x = + mkNP the_Art (mkCN album (symb (mkCN number_N) x)) + | symb album x + ; + + album_name x = + mkNP x + | mkNP the_Art (mkCN album (mkNP x)) + ; + + album_name_artist x y = + mkNP + (mkNP x | mkNP the_Art (mkCN album (mkNP x))) + (mkAdv artist_Prep y) ; + + -- SongSet + + songs_all = + mkSet song ; + songs_by_artist artist = + mkSet (mkCN song (mkAdv artist_Prep artist)) ; + songs_by_genre = + withGenre song ; + songs_by_album album = + mkSet (mkCN song (mkAdv from_Prep album)) ; + songs_by_artist_genre = + withGenreBy song ; + + -- Song + + song_this = this song ; + song_name x = + mkNP x + | mkNP the_Art (mkCN song (mkNP x)) + ; + song_name_artist x y = + mkNP + (mkNP x | mkNP the_Art (mkCN song (mkNP x))) + (mkAdv artist_Prep y) ; + + -- Ordinal + + num_1 = mkCard n1_Numeral ; + num_2 = mkCard n2_Numeral ; + num_3 = mkCard n3_Numeral ; + + + + -- Music database + + -- PlaylistName + + CoolHits = name ["cool_hits"] ; +-- Romantik = { s = ["romance"] }; + + -- Artist + +-- Falco = { s = ["Falco"] }; +-- TheBeatles = { s = ["The Beatles"] }; + U2 = name "u2" ; + + -- Genre + +-- Pop = { s = ["pop"] }; + Rock = mkCN rock_N ; + + -- AlbumName + + HowToDismantleAnAtomicBomb = name ["how_to_dismantle_an_atomic_bomb"]; + + -- SongName + +-- AHardDaysNight = { s = ["a hard day's night"] }; +-- LetItBe = { s = ["let it be"] }; + Vertigo = name ["vertigo"] ; + +} diff --git a/examples/sammie/SammieSpa.gf b/examples/sammie/SammieSpa.gf new file mode 100644 index 000000000..d4afa136c --- /dev/null +++ b/examples/sammie/SammieSpa.gf @@ -0,0 +1,7 @@ +--# -path=.:alltenses:mathematical:prelude + +concrete SammieSpa of Sammie = SammieI with + (Grammar = GrammarSpa), + (Symbol = SymbolSpa), + (ParamSammie = ParamSammieSpa) + ; diff --git a/examples/sammie/SammieSwe.gf b/examples/sammie/SammieSwe.gf new file mode 100644 index 000000000..8d5fa2257 --- /dev/null +++ b/examples/sammie/SammieSwe.gf @@ -0,0 +1,7 @@ +--# -path=.:alltenses + +concrete SammieSwe of Sammie = SammieI with + (Syntax = SyntaxSwe), + (Symbolic = SymbolicSwe), + (ParamSammie = ParamSammieSwe) + ;