Início / coding / Perguntas / 79550050
Accepted
Ananya Batra
Asked: 2025-04-02 16:10:18 +0800 CST

Como modelar o "ano até a data" e suas variações no GF (RGL)?

  • 772

Sou novo na Biblioteca de Gramática de Recursos do GF, mas gostaria de modelar expressões temporais como "ano até a data" e suas variantes ("ano até a data", "ano até agora", "anual", etc.).

Qual parte do discurso seria "ano até a data" e como posso representar "ano até a data" no RGL do GF? "Ano até a data" deve ser um AP, Adv ou uma categoria diferente?

Esta foi minha primeira tentativa:

oper YearToDate : AP = mkAP (mkA "year-to-date") ;

Mas o problema é que isso codifica a frase "year-to-date" como uma string. Isso significa que seus componentes não são modificáveis ​​("month to date") e não tenho certeza de como contabilizar todas as variantes.

gf

1 respostas

  1. Best Answer

    Qual parte do discurso seria "ano até a data" e como posso representar "ano até a data" no RGL do GF? "Ano até a data" deve ser um AP, Adv ou uma categoria diferente?

    No final das contas, a categoria RGL mais conveniente depende de como você quer usá-la. Se você olhar a sinopse RGL para modificar um CN ("substantivo comum"), verá que tanto AP quanto Adv podem modificar um CN, mas em inglês, eles usarão uma ordem de palavras diferente. Adv é um pós-modificador (casa [na colina]:Adv) enquanto AP é um pré-modificador ([grande]:casa AP). Com base nessas informações, AP é uma escolha melhor.

    Mas o problema é que isso codifica a frase "year-to-date" como uma string. Isso significa que seus componentes não são modificáveis ​​("month to date") e não tenho certeza de como contabilizar todas as variantes.

    Para mim, elas parecem entradas lexicais diferentes, e faz sentido que sejam funções diferentes. A palavra "variante" em GF significa variação livre, ou seja, as palavras "ano até a data", "ano até agora" e "anual" são realmente 100% intercambiáveis, e enquanto todas as 3 seriam analisadas, apenas uma delas seria linearizada. Normalmente, você não quer lidar com a variação dessa forma; em vez disso, você tem as palavras como entradas lexicais diferentes na gramática GF, mas um aplicativo externo controla quais tratar como intercambiáveis ​​em qual contexto.

    Dito isso, se você quiser ter funções que criem novas variantes de uma palavra base em tempo de execução, isso é definitivamente possível — embora seus exemplos particulares sejam um pouco feios de construir em tempo de execução, você precisa acessar os internos em vez de usar a API RGL. Mas é possível com certeza.

    Vou apenas colar um exemplo de gramática aqui. Fique à vontade para pedir esclarecimentos ou indicar se não é o que você procura.

    Sintaxe abstrata

    abstract TemporalModifiers = {
  flags startcat = Item ;

  cat
    Item ;
    Kind ;
    Quality ;
    TemporalKind ;

  fun
    -- Quantify a Kind into an Item:
    IndefSg, IndefPl : Kind -> Item ;

    -- Modify a Kind with a Quality
    Mod : Quality -> Kind -> Kind ;

    -- Make a temporal expression into a Quality
    ToDate, UpToNow, Ly : TemporalKind -> Quality ;

    Year, Month : TemporalKind ;

    Sale : Kind ;
}

    Sintaxe concreta

    concrete TemporalModifiersEng of TemporalModifiers = 
   open Prelude, SyntaxEng, ParadigmsEng in {

  lincat
    Item = NP ;
    Kind = CN ;
    Quality = AP ;
    TemporalKind = {s : CN ; ly : AP} ;

  lin
    IndefSg kind = mkNP aSg_Det kind ;
    IndefPl kind = mkNP aPl_Det kind ;

    Mod quality kind = mkCN quality kind ;

    Ly tk = tk.ly ; -- TemporalKind already contains a field for its -ly adjective, here we just choose it.

    -- With the other two, we need to touch the internals—potentially risky!
    -- This is the lincat of AP in the RGL: {s : Agr => Str ; isPre : Bool} ;
    UpToNow tk = lin AP {
      s = \\_ => (mkUtt (mkNP aSg_Det tk.s)).s ++ "up to now" ;
      isPre = False
      } ;
    ToDate tk = lin AP {
      s = \\_ => (mkUtt tk.s).s ++ BIND ++ "-to-date" ;
      isPre = True
      } ;

    Year = {
      s = mkCN (mkN "year") ;
      ly = mkAP (mkA "yearly")
      } ;

    Month = {
      s = mkCN (mkN "month") ;
      ly = mkAP (mkA "monthly")
    } ;

    Sale = mkCN (mkN "sale") ;

}

    Saída da gramática

    Teste no shell GF assim:

    $ gf TemporalModifiersEng.gf
…
TemporalModifiers> gt -depth=3 | l -bind -tabtreebank
IndefPl (Mod (Ly Month) Sale)           monthly sales
IndefPl (Mod (Ly Year) Sale)            yearly sales
IndefPl (Mod (ToDate Month) Sale)       month-to-date sales
IndefPl (Mod (ToDate Year) Sale)        year-to-date sales
IndefPl (Mod (UpToNow Month) Sale)      sales a month up to now
IndefPl (Mod (UpToNow Year) Sale)       sales a year up to now
IndefPl Sale                            sales
IndefSg (Mod (Ly Month) Sale)           a monthly sale
IndefSg (Mod (Ly Year) Sale)            a yearly sale
IndefSg (Mod (ToDate Month) Sale)       a month-to-date sale
IndefSg (Mod (ToDate Year) Sale)        a year-to-date sale
IndefSg (Mod (UpToNow Month) Sale)      a sale a month up to now
IndefSg (Mod (UpToNow Year) Sale)       a sale a year up to now
IndefSg Sale                            a sale
    • 0

relate perguntas