变体无法在GF上编译

Question

我构建了一个程序来从一个命令式树生成不同的谓词。

抽象文件：

abstract Test = {
      flags startcat = Utterance;
      cat
          Utterance; Imperative; Verb; VerbPhrase;
      fun

      -- verb phrase
      Play_VP : VerbPhrase;


      -- Imp
      Play_Imp : VerbPhrase -> Imperative;


      -- Utt
      Sentence : Imperative -> Utterance;}

具体文件：

concrete TestEng of Test = open SyntaxEng, TestEngSrc, ParadigmsEng in {

lincat
    Utterance   = Utt;
    Imperative  = Imp;
    VerbPhrase  = VP;
    Verb        = V;
lin


-- verb phrase
Play_VP = mkVP ( variants{ mkV(play_Str) ; put_on_V });


--Imp
Play_Imp verbPhrase = mkImp(verbPhrase);

--Utt
Sentence imperative = mkUtt(imperative);}

最后是源文件：

resource TestEngSrc = open ParadigmsEng, SyntaxEng in {

oper
    -- verb string
    play_Str : Str  = variants{ "broadcast" ; "play"
                    ; "replay" ; "see" ; "view" ; "watch" ; "show"};

    -- verb
    play_V : V = variants {mkV(play_Str) ; put_on_V };


        -- verb part
        put_on_V : V = partV (mkV "put") "on";}

但只要我运行这个程序，它就会开始运行，并坚持到这种情况

​

我在GitHub上搜索了GF线程，以确定这个问题是个人问题还是一般问题，但我找到了这个页面：https://github.com/GrammaticalFramework/GF/issues/32，其中提到了在更新版本的GF中将提供一个解决方案。是否有关于此线程的更新，或者是否有比此线程中提供的解决方案更好的解决方案。感谢您的时间和努力。

Answer 1

没有，在变种的处理上还没有更新。但幸运的是，您的代码可以通过一个小的修复来提高效率。

VP又大又慢

语法中最大的瓶颈是你有一个类别VerbPhrase，其中有来自RGL的lincat VP。它对最终用户是不可见的，但一个VP包含近3000个字段。如果你想看看，在GF shell中试试这个：

> i -retain TestEngSrc.gf
> cc mkVP play_V
... lots of output

我不知道编译的确切细节，但是如果VP有8个变体，编译器就会卡住。

如何修正你的语法

如果您知道将只在命令式中使用动词，那么您可以完全跳过VP阶段，直接从动词创建命令式。V的RGL类别要好得多，它有6个字段，而不是大约3000个字段。因此，如果你改变语法，它会立即编译。我将名称更改为Test2，这样您就可以与旧的进行比较。

abstract Test2 = {
      flags startcat = Utterance;
      cat
          Utterance; Imperative; Verb;
      fun

      -- Verb
      Play_V : Verb ;

      -- Imp
      Play_Imp : Verb -> Imperative;

      -- Utt
      Sentence : Imperative -> Utterance;
}

具体的语法在这里。我打开了IrregEng和LexiconEng，因为其中一些动词已经定义好了。

concrete Test2Eng of Test2 = open SyntaxEng, ParadigmsEng, IrregEng, LexiconEng in {

lincat
    Utterance   = Utt;
    Imperative  = Imp;
    Verb        = V;
lin

  --Verb
  -- broadcast_V, see_V, show_V are in IrregEng.  play_V is in LexiconEng.
  Play_V = play_V|replay_V|broadcast_V|see_V|show_V|view_V|watch_V|put_on_V ;


  --Imp
  Play_Imp verb = mkImp verb ;

  --Utt
  Sentence imperative = mkUtt imperative ;

  oper
    replay_V : V = mkV "replay" ;
    view_V : V = mkV "view" ;
    watch_V : V = mkV "watch" ;
    put_on_V : V = partV put_V "on"; -- put_V is in IrregEng
}

在GF shell中进行测试，按照预期工作：

Test2> p "replay"
Sentence (Play_Imp Play_V)

Test2> p "watch"
Sentence (Play_Imp Play_V)

Test2> gt | l -treebank -all
Test2: Sentence (Play_Imp Play_V)
Test2Eng: play
Test2Eng: replay
Test2Eng: broadcast
Test2Eng: see
Test2Eng: show
Test2Eng: view
Test2Eng: watch
Test2Eng: put on

Answer 2

因为我需要使用动词短语，所以没有办法跳过它。因此，我试图找出这个问题背后的原因，并得出以下结果：

在这种情况下，虽然变体的数量不超过三个字符串，但它仍然会在每次程序运行时冻结。

有错误的代码

摘要：

   abstract Test = {
   flags startcat = VerbPhrase;
   cat
       VerbPhrase; Verb; 
   fun

   Play_VP : VerbPhrase;
}

具体情况：

   concrete TestEng of Test = open SyntaxEng,  ParadigmsEng, IrregEng in {
   
   lincat
       VerbPhrase  = VP;
       Verb        = V ;
   lin

       Play_VP = mkVP(play_V);


   oper

   play_V : V = variants {mkV(play_Str) ; put_on_V};

   play_Str : Str = variants {"play" ; "brodcast"};

   put_on_V : V = partV put_V "on";
}

但在另一种情况下，当动词在这种方法中被抽象定义时，程序运行得很好。

没有错误的代码

摘要：

   abstract Test = {
   flags startcat = VerbPhrase;
   cat
       VerbPhrase; Verb; 
   fun

   Play_V : Verb;

   Play_VP : Verb -> VerbPhrase;
}

具体情况：

concrete TestEng of Test = open SyntaxEng,  ParadigmsEng, IrregEng in {
   
   lincat
       VerbPhrase  = VP;
       Verb        = V ;
   lin

       Play_V = variants {mkV(play_Str) ; put_on_V};

       Play_VP play_v = mkVP(play_v);


   oper

   play_Str : Str = variants {"play" ; "brodcast"};

   put_on_V : V = partV put_V "on";
}

显然，问题实际上并不在VP结构中，而是在调用带有变体的操作时VP的行为方式。

希望你们能仔细研究一下这个问题，找到一个解决方案。