Correctly constructing SLASH-list in extracted adjunct phrase

So when preparing the presentation today I noticed my adjunct extraction rule was not actually working the way I thought it was (my favorite situation to be in the day before presentation). In particular, I had the slash list append to the MOD instead of the the mother’s actual slash list, just by mistake. I did not actually have a proper LDD sentence to test this, so it went unnoticed all this time.

And now I am not sure how to properly fix it.

What I want to do is append the the extracted adjunct to the daughter’s existing SLASH list. I seem to be able to prepend it like so:

extracted-adj-phrase := extracted-adj-phrase-simple &
  [ SYNSEM.NON-LOCAL.SLASH append-list &
		   [ LIST < [ CAT [ HEAD +rp & [ MOD < [ ] > ] ] ] . #slash > ],
    HEAD-DTR.SYNSEM.NON-LOCAL.SLASH.LIST #slash ].

extracted-adj-phrase-simple := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc ],
	     NON-LOCAL.SLASH append-list & [ LIST <
		    [ CAT [ HEAD [ MOD.FIRST [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           VAL #val,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] ],
    HEAD-DTR.SYNSEM canonical-synsem &
	   [ LOCAL local &
		   [ CAT [ HEAD #head,
                   VAL #val,
			       POSTHEAD #ph,
                   MC #mc ],
                   CONT.HOOK #hook,
                   CTXT #ctxt ],
	     MODIFIED notmod ],
    C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ] ].

but not vice versa, I think because of how the . operator works (I get an error that way).

I could perhaps use the APPEND feature but I am not sure how as the extracted adjunct is not an append list. Here’s something weird that I have right now:

extracted-adj-phrase := basic-extracted-adj-phrase &
  [ SYNSEM [ LOCAL.CAT [ VAL.SPEC < >, POSTHEAD #ph,
                         MC #mc, WH #wh ],
	         NON-LOCAL [ QUE #que, YNQ #ynq, SLASH append-list &
		   [ APPEND < #slash, append-list & [ LIST < [ CAT [ HEAD [ MOD.FIRST [ LOCAL intersective-mod &
                                                   [ CAT [ HEAD #head,
                                                           VAL #val,
                                                           POSTHEAD #ph,
                                                           MC #mc ],
                                                     CONT.HOOK #hook,
                                                     CTXT #ctxt ] ] ],
                              VAL [ SPEC < >,
                                    SUBJ olist,
                                    COMPS olist,
                                    SPR olist ] ] ] > ] > ] ] ],
    HEAD-DTR.SYNSEM canonical-synsem & [ LOCAL local & [ CAT [ WH #wh,
		                            HEAD #head & verb,
		                            VAL #val & [ SPEC < > ], POSTHEAD #ph,
                   MC #mc ], CONT.HOOK #hook,
                   CTXT #ctxt  ],
             NON-LOCAL [ QUE #que, SLASH #slash, YNQ #ynq ], MODIFIED notmod ],
              C-CONT [ HOOK #hook,
         RELS.LIST < >,
	     HCONS.LIST < >,
	     ICONS.LIST < > ]].

It seems to work but I am not sure it’s a good way of doing it.

If you aren’t using append-lists, then pre-pending is all that’s available. If you are using append lists… I’m not sure how to debug. Perhaps @guyemerson has ideas?

I am using append-lists. To clarify, this version that I give above (with turning the extracted modifier into an append-list) seems to work, it just looks weird. So perhaps not so much a question of what to debug as generally how to properly do it?

Yes, creating a new append-list is the way to do it.

I would only add that all the explicit append-list constraints are superfluous, e.g. you can just write SLASH.APPEND < ... > rather than SLASH append-list & [ APPEND < ... > ]. And similarly, when creating a new append-list, you actually only need to create a new list-container, i.e. [ LIST < [ ... ] > ]. So more succinctly, it would be:

SLASH.APPEND < #slash, [ LIST < [ ... ] > ] >

If this is something that you end up doing a lot, it might make sense to define a specific operation for it, so that it would have syntax like:

SLASH.PUSH < #slash, [ ... ] >

1 Like