I'm new to GF its Resource Grammar Library but I would like to model temporal expressions like "year to date" and its variants ("year-to-date", "year up to now", "yearly", etc).

What part of speech would "year to date" be and how can I represent "year to date" in GF’s RGL? Should "year to date" be an AP, Adv, or a different category?

This was my first attempt:

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

But the problem is this hardcodes the phrase "year-to-date" as a string. This means that its components are not modifiable ("month to date") and I'm unsure of how to account for all the variants.

I'm new to GF its Resource Grammar Library but I would like to model temporal expressions like "year to date" and its variants ("year-to-date", "year up to now", "yearly", etc).

What part of speech would "year to date" be and how can I represent "year to date" in GF’s RGL? Should "year to date" be an AP, Adv, or a different category?

This was my first attempt:

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

But the problem is this hardcodes the phrase "year-to-date" as a string. This means that its components are not modifiable ("month to date") and I'm unsure of how to account for all the variants.

• gf

• 1 Is this related to the Haskell programming language? – Noughtmare Commented Apr 2 at 8:23

1 Answer 1

What part of speech would "year to date" be and how can I represent "year to date" in GF’s RGL? Should "year to date" be an AP, Adv, or a different category?

Ultimately, the most convenient RGL category depends on how you want to use it. If you look at the RGL synopsis for modifying a CN ("common noun"), you see that both AP and Adv can modify a CN, but in English, they will use a different word order. Adv is a postmodifier (house [on the hill]:Adv) whereas AP is a premodifier ([big]:AP house). Based on this information, AP is a better choice.

But the problem is this hardcodes the phrase "year-to-date" as a string. This means that its components are not modifiable ("month to date") and I'm unsure of how to account for all the variants.

These look like different lexical entries to me, and it makes sense for them to be different functions. The word "variant" in GF means free variation, i.e. the words "year-to-date", "year up to now" and "yearly" are truly 100% interchangeable, and while all 3 would be parsed, only one of them will be linearized. Usually you don't want to handle variation that way; rather you have the words as different lexical entries in the GF grammar, but an external application controls which ones to treat as interchangeable in which context.

That said, if you'd like to have functions that create new variants from a base word at runtime, that's definitely possible—although your particular examples are a bit ugly to construct at runtime, you need to access the internals instead of using the RGL API. But it is possible for sure.

I am going to just paste an example grammar here, feel free to ask for clarifications or point out if it isn't what you're after.

Abstract syntax

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 ;
}

Concrete syntax

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") ;

}

Output of the grammar

Test in the GF shell like this:

$ 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