GF 中带有限定词的专有名词 艺术家数量有限艺术家作为修饰符与主题作为艺术家的任意字符串

如何解决GF 中带有限定词的专有名词 艺术家数量有限艺术家作为修饰符与主题作为艺术家的任意字符串

我正在尝试在 GF 中生成以下句子： Jack wants to listen to a Taylor song 但正如我在 RGL 中看到的，PN -> NP 是获得正确名称的唯一解决方案。如何让GF输出带有限定词和宾语的专有名词。

我还想知道为什么在 RGL 中 PN 被称为专有名称而不是专有名词？

解决方法

那句话中“Taylor”的句法功能是对“歌曲”的修饰。所以分组不是“一个泰勒”，而是“一首歌”，泰勒作为修饰符：

• 一首歌
• 好听的歌
• 泰勒的歌曲

此答案不一定适用于英语以外的其他语言。但是，您可以直接从 RGL 中使用许多其他结构，例如“NP 的歌曲”。

艺术家数量有限

如果您有一组固定的艺术家，最简单的方法可能是将他们作弊并将其变成英语的形容词。举个例子：

abstract Song = {
  flags startcat = Sentence ;
  cat
    Sentence ;
    Person ;
    Artist ;

  fun
    wantToListen : Person -> Artist -> Sentence ;
    Jack : Person ;
    Taylor,Ariana : Artist ;
}

对于英文版本，我们将 Artist 的 lincat 变成 AP。这适用于英语，因为形容词不变形，所以它只是一个字符串。

concrete SongEng of Song = open SyntaxEng,ParadigmsEng,LexiconEng in {

  lincat
    Sentence = Utt ;
    Person = NP ;
    Artist = AP ; -- cheat in English

  lin
    -- : Person -> Artist -> Sentence ;
    wantToListen person artist =
      let artistsSong : CN = mkCN artist song_N ;
          listenToSong : VP = mkVP listen_V2 (mkNP a_Det artistsSong) ;
       in mkUtt (mkS (mkCl person want_VV listenToSong)) ;

    -- : Person
    Jack = mkNP (mkPN "Jack") ;

    -- : Artist
    Taylor = mkAP (mkA "Taylor") ;
    Ariana = mkAP (mkA "Ariana") ;
}

按预期工作：

$ gf SongEng.gf
…
Song> gt | l -treebank
Song: wantToListen Jack Ariana
SongEng: Jack wants to listen to an Ariana song

Song: wantToListen Jack Taylor
SongEng: Jack wants to listen to a Taylor song

请注意，如果您的乐队有自己的文章，您会Jack 想听一首披头士乐队的歌曲。

艺术家作为修饰符与主题

您始终可以为 Artist 制作更复杂的 lincat，这是一个示例。我们将在抽象语法中添加 TheBeatles 作为 Artist。我还添加了另一个功能，其中艺术家不仅仅是修饰符，而是主体。

abstract Song2 = Song ** {
  flags startcat = Sentence ;
  fun
    TheBeatles : Artist ;
    isGood : Artist -> Sentence ;
}

这是混凝土。我没有重复使用原始的 SongEng，因为我需要更改 Artist 的 lincat。

concrete Song2Eng of Song2 = open SyntaxEng,LexiconEng in {

  lincat
    Sentence = Utt ;
    Person = NP ;
    Artist = LinArtist ; -- {independent : NP ; modifier : AP}

  lin
    -- : Person -> Artist -> Sentence ;
    wantToListen person artist =
      let artistsSong : CN = mkCN artist.modifier song_N ;
          listenToSong : VP = mkVP listen_V2 (mkNP a_Det artistsSong) ;
       in mkUtt (mkS (mkCl person want_VV listenToSong)) ;

    -- : Artist -> Sentence
    isGood artist = mkUtt (mkS (mkCl artist.independent good_A)) ;

    -- : Person
    Jack = mkNP (mkPN "Jack") ;

    -- : Artist
    Taylor = mkArtist "Taylor" ;
    Ariana = mkArtist "Ariana" ;
    TheBeatles = mkArtist "The Beatles" "Beatles" ;

  oper
    LinArtist : Type = {independent : NP ; modifier : AP} ;
    mkArtist = overload {
      mkArtist : Str -> Str -> LinArtist = \thebeatles,beatles -> {
        independent = mkNP (mkPN thebeatles) ;
        modifier = mkAP (mkA beatles)
        } ;
      mkArtist : Str -> LinArtist = \taylor -> {
        independent = mkNP (mkN taylor) ;
        modifier = mkAP (mkA taylor)
        }
      } ;
}

这是它的输出。

Song2> gt | l
Ariana is good
Taylor is good
The Beatles is good
Jack wants to listen to an Ariana song
Jack wants to listen to a Taylor song
Jack wants to listen to a Beatles song

如果您想将“The Beatles”变成复数形式，那么我们可以这样做。添加 mkArtist 的另一个重载实例，在那里你给它一个已经构造的 NP。然后您可以指定“The Beatles”实际上是复数形式。

  oper
    mkArtist = overload {
      mkArtist : Str -> Str -> LinArtist = … ; -- same as before
      mkArtist : Str -> LinArtist = … ; -- same as before
      mkArtist : NP -> AP -> LinArtist = \thebeatles,beatles -> {
        independent = thebeatles ;
        modifier = beatles
        }
  lin
    TheBeatles =
      mkArtist
        (mkNP aPl_Det (mkN "The Beatles" "The Beatles"))
        (mkAP (mkA "Beatles")) ;
      } ;

这会为您提供以下输出：

Song2> l isGood TheBeatles 
The Beatles are good

作为艺术家的任意字符串

最后，如果你想使用任意字符串作为艺术家，你可以使用字符串文字。对于 independent 字段，效果很好：Symbolic 模块中有一些函数可以将字符串文字转换为 NP。

但是，对于modifier字段，你需要走出API---here are instructions如何以稍微不那么不安全的方式去做，但仍然不能保证稳定，如果RGL 内部结构不断变化。

除了免责声明，这是最后的扩展。

abstract Song3 = Song2 ** {
  flags startcat = Sentence ;
  fun
    StringArtist : String -> Artist ;
}

还有混凝土。这次我们确实扩展了 Song2Eng，因为不需要更改 lincat。

concrete Song3Eng of Song3 = Song2Eng ** open SyntaxEng,LexiconEng,SymbolicEng in {
  lin
    -- : String -> Artist ;
    StringArtist string = {
      independent = symb string ; -- symb : String -> NP,from SymbolicEng
      modifier = <mkAP good_A : AP> ** {s = \\_ => string.s} -- hack
      } ;
}

让我们看看它是如何工作的：

Song3> p "Jack wants to listen to a skhdgdjgfhjkdfhjsdf song"
wantToListen Jack (StringArtist "skhdgdjgfhjkdfhjsdf")

Song3> p "9ortge94yhjerh90fpersk is good"
isGood (StringArtist "9ortge94yhjerh90fpersk")

只是一个警告：用空格线性化字符串效果很好，所以这是可以的：

Song3> l isGood (StringArtist "Spice Girls")
Spice Girls is good

但是你不能解析带有空格的字符串。

Song3> p "Backstreet Boys is good"
The parser failed at token 2: "Boys"