olski.skład.składnia

Abstrakcyjna składnia: co da się powiedzieć, bez tego, jak to brzmi.

Kategoria mówi, jaki byt drzewo w tym miejscu trzyma, a konstruktor mówi, co z czym wolno złożyć. Drzewo dobrze złożone jest jednoznaczne z definicji, więc jednoznaczność tego zapisu nie potrzebuje żadnego sprawdzenia: kształt drzewa jest tym, co niesie znaczenie.

Kategorie dzielą się na dwa moduły po tym, co która niesie. Tutaj są te, które orzekają: zdanie, jego pozycje i to, co do niego dochodzi. Te, które niosą rzecz, trzyma olski/skład/grupa.py.

Poziomem tych kategorii jest dziedzina, a nie polszczyzna. Czyj w olski/skład/grupa.py mówi, że jedna rzecz jest określeniem drugiej, a że wyjdzie z tego dopełniacz, rozstrzyga linearyzacja. Tak samo Okolicznik tutaj: drzewo mówi, że coś jest celem, a przypadek po przyimku przychodzi z olski/skład/przyimki.py. Ten poziom jest tym, co odróżnia ten zapis od rozbioru zdania pisanego z góry; wywód trzyma docs/design-notes.md.

Szyk jest tu skutkiem, a nie zapisem. Drzewo mówi, co w zdaniu jest tematem, a co nowe, przez Wyróżnienie, i dopiero z tego wychodzi kolejność, w której konstytuenty się wypisują. Czasownik przy tym nie rusza się nigdy, więc wyróżnienie przestawia to, co wokół niego stoi, a nie całe zdanie. Kolejności dokładają do tego konstrukcje, w których autor nie wybiera. Zaimek względny otwiera zdanie podrzędne zawsze, więc rzecz wskazana przez Opis staje w nim na czele, czymkolwiek w nim jest. Okoliczność wyrażona zdarzeniem staje na czele zdania, o ile pozwala na to jej spójnik, i mówi o tym leksykon, bo jest to fakt o słowie, a nie o zdaniu, w którym ono stoi. Treść staje na końcu zdania, bo zdanie podrzędne wprowadzone przez że stoi za całym zdaniem nadrzędnym i nie ma czym wyjść przed nie.

Czego drzewo nie niesie, jest tu decyzją, a nie brakiem. Nie ma w nim przypadka, bo przypadek bierze się z pozycji. Nie ma rodzaju, bo rodzaj rzeczownika jest leksykalny. Nie ma osoby ani czasu, bo obie te rzeczy niesie olski/skład/kontekst.py: czas jest własnością opowiadania, a nie pojedynczego zdarzenia. Dziura jest jedna i jest dziurą, a nie decyzją. Wewnątrz grupy imiennej szyku nie ma, bo Jaki w olski/skład/grupa.py stawia przymiotnik przed rzeczownikiem zawsze, choć przymiotnik po rzeczowniku nazywa, a przed nim określa. Miejsce tego w torze nazywa docs/roadmap.md.

CZASY = {'teraz': lambda podmiot: ('fin', dict(number=podmiot.number, person='ter')), 'kiedyś': lambda podmiot: ('praet', dict(number=podmiot.number, gender=podmiot.rodzaj))} module-attribute

PRZYPADKI_DOPEŁNIENIA = (BIERNIK, DOPEŁNIACZ) module-attribute

NAZWY_POZYCJI = {BIERNIK: 'dopełnienia w bierniku', DOPEŁNIACZ: 'dopełnienia w dopełniaczu', CELOWNIK: 'dopełnienia w celowniku', BEZOKOLICZNIK: 'bezokolicznika', ZDANIE_PODRZĘDNE: 'zdania podrzędnego'} module-attribute

OKOLICZNOŚCI = (Okolicznik, Przysłówek) module-attribute

PozaRamą

Bases: Exception

Drzewo żąda od słowa pozycji, której jego rama nie ma.

Wyjątek, a nie zdanie wypuszczone mimo to, z tego samego powodu co BrakFormy w olski/skład/morfologia.py: to jest błąd kompilacji, bo Linter pomaga dobry kod. nie jest zdaniem polskim i nikt takiego nie chciał napisać.

Ramę ma tu czasownik, przyimek i spójnik, a pytanie jest we wszystkich trzech wypadkach jedno: czy leksykon zna to, co autor postawił w drzewie. Spójnik pytany jest przy tym o dwie rzeczy, bo o dwóch mówi: o relacji, w której stoi, i o tym, czy jego zdanie staje na czele pary.

Source code in olski/skład/składnia.py

class PozaRamą(Exception):
    """Drzewo żąda od słowa pozycji, której jego rama nie ma.

    Wyjątek, a nie zdanie wypuszczone mimo to,
    z tego samego powodu co ``BrakFormy`` w ``olski/skład/morfologia.py``:
    to jest błąd kompilacji,
    bo `Linter pomaga dobry kod.` nie jest zdaniem polskim
    i nikt takiego nie chciał napisać.

    Ramę ma tu czasownik, przyimek i spójnik,
    a pytanie jest we wszystkich trzech wypadkach jedno:
    czy leksykon zna to, co autor postawił w drzewie.
    Spójnik pytany jest przy tym o dwie rzeczy, bo o dwóch mówi:
    o relacji, w której stoi, i o tym, czy jego zdanie staje na czele pary.
    """

Okolicznik dataclass

Bases: Wyróżnialne

Okoliczność w relacji: w piwnicy, wzrokiem, gdy bazyliszek otworzył oczy.

Relacja jest kategorią dziedziny i to ona stoi w drzewie, a słowo, którym polszczyzna ją wyraża, rozstrzyga o sobie tyle, ile go od relacji odróżnia: w mówi, gdzie i kiedy, a gdy mówi tylko kiedy.

Okoliczność bywa rzeczą albo zdarzeniem i jest to jedna kategoria, bo pytanie stawia się jedno. Różnią się one tym, czym słowo przed nimi jest po polsku: przed rzeczą stoi przyimek, który rządzi przypadkiem (olski/skład/przyimki.py), a przed zdarzeniem spójnik, który nie rządzi niczym (olski/skład/spójniki.py), bo zdanie podrzędne rozdaje przypadki własne. Przyimkiem żadnym jest pusty napis, bo część relacji polszczyzna wyraża samym przypadkiem, a rola bez przyimka jest tu tą samą kategorią co z nim. Narzędzie wychodzi tak zawsze, a czas ma obie drogi naraz: wieczorem i w nocy odpowiadają na jedno pytanie i różnią się tym, czy relacja wyszła na wierzch słowem.

Przyłączenie stoi w drzewie i to jest cała różnica między tym kierunkiem a parserem, któremu docs/subset.md zostawia je przy czytelniku: okolicznik postawiony przy czasowniku i określenie postawione przy rzeczy są dwoma różnymi drzewami, więc nie ma tu czego rozstrzygać po fakcie.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Okolicznik(Wyróżnialne):
    """Okoliczność w relacji: w piwnicy, wzrokiem, gdy bazyliszek otworzył oczy.

    Relacja jest kategorią dziedziny i to ona stoi w drzewie,
    a słowo, którym polszczyzna ją wyraża, rozstrzyga o sobie tyle,
    ile go od relacji odróżnia: ``w`` mówi, gdzie i kiedy,
    a ``gdy`` mówi tylko kiedy.

    Okoliczność bywa rzeczą albo zdarzeniem i jest to jedna kategoria,
    bo pytanie stawia się jedno.
    Różnią się one tym, czym słowo przed nimi jest po polsku:
    przed rzeczą stoi przyimek, który rządzi przypadkiem (``olski/skład/przyimki.py``),
    a przed zdarzeniem spójnik, który nie rządzi niczym (``olski/skład/spójniki.py``),
    bo zdanie podrzędne rozdaje przypadki własne.
    Przyimkiem żadnym jest pusty napis, bo część relacji polszczyzna wyraża
    samym przypadkiem, a rola bez przyimka jest tu tą samą kategorią co z nim.
    Narzędzie wychodzi tak zawsze, a czas ma obie drogi naraz:
    `wieczorem` i `w nocy` odpowiadają na jedno pytanie
    i różnią się tym, czy relacja wyszła na wierzch słowem.

    Przyłączenie stoi w drzewie i to jest cała różnica między tym kierunkiem
    a parserem, któremu ``docs/subset.md`` zostawia je przy czytelniku:
    okolicznik postawiony przy czasowniku i określenie postawione przy rzeczy
    są dwoma różnymi drzewami, więc nie ma tu czego rozstrzygać po fakcie.
    """

    słowo: str
    relacja: str
    co: Rola | Zdanie

    @property
    def zdarzeniem(self) -> bool:
        """Czy pod tą okolicznością stoi zdarzenie, a nie rzecz."""
        return isinstance(self.co, Zdanie)

    @property
    def wysuwalna(self) -> bool:
        """Czy wolno postawić tę okoliczność na czele zdania.

        Grupa imienna staje na czele zawsze, bo szyk polszczyzny jest swobodny
        i o wysunięciu rozstrzyga to, o czym zdanie jest.
        Zdarzenie staje tam, gdy pozwala na to jego spójnik,
        i to jest jedyne miejsce w tym pliku, w którym leksykon mówi o szyku.
        """
        return not self.zdarzeniem or staje_na_czele(self.słowo, self.relacja)

    def __post_init__(self) -> None:
        if self.zdarzeniem:
            znane = wprowadza(self.słowo, self.relacja)
        else:
            znane = przypadek(self.słowo, self.relacja) is not None
        if not znane:
            raise PozaRamą(f"{self.słowo or 'sam narzędnik'} nie stoi w relacji {self.relacja}")

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        """Słowo wraz z tym, co po nim stoi: zdanie podrzędne albo grupa imienna."""
        if self.zdarzeniem:
            return podrzędne(self.słowo, self.co, kontekst)
        grupa = wypisz(self.co, przypadek(self.słowo, self.relacja), kontekst)
        return sklej([Kawałek(self.słowo), grupa]) if self.słowo else grupa

słowo instance-attribute

relacja instance-attribute

co instance-attribute

zdarzeniem property

Czy pod tą okolicznością stoi zdarzenie, a nie rzecz.

wysuwalna property

Czy wolno postawić tę okoliczność na czele zdania.

Grupa imienna staje na czele zawsze, bo szyk polszczyzny jest swobodny i o wysunięciu rozstrzyga to, o czym zdanie jest. Zdarzenie staje tam, gdy pozwala na to jego spójnik, i to jest jedyne miejsce w tym pliku, w którym leksykon mówi o szyku.

__init__(słowo, relacja, co)

__post_init__()

Source code in olski/skład/składnia.py

def __post_init__(self) -> None:
    if self.zdarzeniem:
        znane = wprowadza(self.słowo, self.relacja)
    else:
        znane = przypadek(self.słowo, self.relacja) is not None
    if not znane:
        raise PozaRamą(f"{self.słowo or 'sam narzędnik'} nie stoi w relacji {self.relacja}")

linearyzuj(kontekst=TERAZ)

Słowo wraz z tym, co po nim stoi: zdanie podrzędne albo grupa imienna.

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    """Słowo wraz z tym, co po nim stoi: zdanie podrzędne albo grupa imienna."""
    if self.zdarzeniem:
        return podrzędne(self.słowo, self.co, kontekst)
    grupa = wypisz(self.co, przypadek(self.słowo, self.relacja), kontekst)
    return sklej([Kawałek(self.słowo), grupa]) if self.słowo else grupa

Komu dataclass

Bases: Wyróżnialne

Ten, komu zdarzenie się przydarza: parser pokazuje autorowi czytania.

Kategorią dziedziny jest tu uczestnik, a nie przypadek, i dlatego stoi tu kategoria osobna, a nie druga rola wrzucona obok pierwszej. Zdarzenie ma uczestników dwóch i nie są oni wymienni: ten, komu się coś daje, mówi się albo pokazuje, jest kimś innym niż to, co się daje, i drzewo ma powiedzieć, który jest który. Że wychodzi z tego celownik, rozstrzyga rama, tak samo jak rozstrzyga ona o przypadku dopełnienia (Robi niżej).

Nazwą jest pytanie, bo polszczyzna nie ma na tego uczestnika jednego słowa: dawać stawia tam odbiorcę, pomagać tego, komu się pomaga, a dziękować tego, komu się dziękuje, i wszyscy trzej odpowiadają, komu. Tyle jest w tej konwencji nazw, ile jest w niej pytań, i tak samo nazywają się relacje okolicznikowe w olski/skład/słownik.py.

Zdarzenia ta pozycja nie bierze i tym różni się od okoliczności: w celowniku stoi w polszczyźnie grupa imienna, a zdarzenie wypełnia pozycję ramy bezokolicznikiem albo treścią, czyli pozycją osobną (Treść wyżej).

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Komu(Wyróżnialne):
    """Ten, komu zdarzenie się przydarza: parser pokazuje autorowi czytania.

    Kategorią dziedziny jest tu uczestnik, a nie przypadek, i dlatego stoi tu
    kategoria osobna, a nie druga rola wrzucona obok pierwszej.
    Zdarzenie ma uczestników dwóch i nie są oni wymienni:
    ten, komu się coś daje, mówi się albo pokazuje, jest kimś innym niż to,
    co się daje, i drzewo ma powiedzieć, który jest który.
    Że wychodzi z tego celownik, rozstrzyga rama, tak samo jak rozstrzyga ona
    o przypadku dopełnienia (``Robi`` niżej).

    Nazwą jest pytanie, bo polszczyzna nie ma na tego uczestnika jednego słowa:
    ``dawać`` stawia tam odbiorcę, ``pomagać`` tego, komu się pomaga,
    a ``dziękować`` tego, komu się dziękuje, i wszyscy trzej odpowiadają, komu.
    Tyle jest w tej konwencji nazw, ile jest w niej pytań,
    i tak samo nazywają się relacje okolicznikowe w ``olski/skład/słownik.py``.

    Zdarzenia ta pozycja nie bierze i tym różni się od okoliczności:
    w celowniku stoi w polszczyźnie grupa imienna,
    a zdarzenie wypełnia pozycję ramy bezokolicznikiem albo treścią,
    czyli pozycją osobną (``Treść`` wyżej).
    """

    co: Rola

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        return wypisz(self.co, CELOWNIK, kontekst)

co instance-attribute

__init__(co)

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    return wypisz(self.co, CELOWNIK, kontekst)

Przysłówek dataclass

Bases: Wyróżnialne

Okoliczność wyrażona jednym słowem: wkrótce, nagle.

Stopnia drzewo nie niesie i dlatego linearyzacja żąda równego: przysłówek w stopniu wyższym mówi co innego niż w równym, a mówienie tego dopiero czeka na kategorię. Przysłówka, który stopnia nie ma, żądanie to nie dotyczy, i rozstrzyga to odmień w olski/skład/morfologia.py.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Przysłówek(Wyróżnialne):
    """Okoliczność wyrażona jednym słowem: wkrótce, nagle.

    Stopnia drzewo nie niesie i dlatego linearyzacja żąda równego:
    przysłówek w stopniu wyższym mówi co innego niż w równym,
    a mówienie tego dopiero czeka na kategorię.
    Przysłówka, który stopnia nie ma, żądanie to nie dotyczy,
    i rozstrzyga to ``odmień`` w ``olski/skład/morfologia.py``.
    """

    lemat: str

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        return Kawałek(odmień(self.lemat, "adv", degree="pos"))

lemat instance-attribute

__init__(lemat)

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    return Kawałek(odmień(self.lemat, "adv", degree="pos"))

Treść dataclass

To, co ktoś mówi, wie albo w co nie wierzy: zdarzenie jako uczestnik.

Kategorią dziedziny jest tu treść, a nie zdanie podrzędne, i zawinięcie jest potrzebne, bo drzewo samo tej różnicy nie niesie. V.chcieć(kot, V.spać(kot)) i V.wiedzieć(kot, Treść(V.spać(kot))) stawiają pod czasownikiem to samo zdarzenie i mówią dwie różne rzeczy, więc nie ma jak policzyć tego z tego, kto w zdarzeniu działa. Po co ta kategoria jest opowieści, mówi docs/kategorie-zapisu.md.

Zdaniem ta klasa nie jest, choć zdanie w sobie trzyma, i jest to rozstrzygnięcie, a nie wygoda dziedziczenia. Zdaniem jest to, co orzeka o kimś, a treść o nikim nie orzeka: stoi w roli uczestnika i o tym, kto ją niesie, mówi czasownik nad nią. Gdyby zdaniem była, Okolicznik wpuściłby ją tam, gdzie czeka na zdarzenie, i wypuścił gdy że, czyli dwa spójniki jeden po drugim.

Pól ta klasa nie ma poza objętym zdaniem i każde z brakujących ma swój powód. Kontroli nie ma czego zapisywać, bo zdanie podrzędne niesie podmiot własny, a przeczenia tym bardziej: dopełniacz negacji przez tę pozycję nie sięga, bo zdanie podrzędne rozdaje przypadki własne. Idzie to samo z siebie, bo Kontekst.podrzędne nie przekazuje w dół ani wykonawcy, ani przeczenia, i jest to ta sama metoda, która puszcza czas. Wyróżnienia ta klasa nie przyjmuje, bo pozycję ma jedną i wziętą z polszczyzny, a nie z tego, o czym zdanie jest; rozstrzyga o niej _miejsce niżej.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Treść:
    """To, co ktoś mówi, wie albo w co nie wierzy: zdarzenie jako uczestnik.

    Kategorią dziedziny jest tu treść, a nie zdanie podrzędne,
    i zawinięcie jest potrzebne, bo drzewo samo tej różnicy nie niesie.
    ``V.chcieć(kot, V.spać(kot))`` i ``V.wiedzieć(kot, Treść(V.spać(kot)))``
    stawiają pod czasownikiem to samo zdarzenie i mówią dwie różne rzeczy,
    więc nie ma jak policzyć tego z tego, kto w zdarzeniu działa.
    Po co ta kategoria jest opowieści, mówi ``docs/kategorie-zapisu.md``.

    Zdaniem ta klasa nie jest, choć zdanie w sobie trzyma,
    i jest to rozstrzygnięcie, a nie wygoda dziedziczenia.
    Zdaniem jest to, co orzeka o kimś, a treść o nikim nie orzeka:
    stoi w roli uczestnika i o tym, kto ją niesie, mówi czasownik nad nią.
    Gdyby zdaniem była, ``Okolicznik`` wpuściłby ją tam, gdzie czeka na zdarzenie,
    i wypuścił `gdy że`, czyli dwa spójniki jeden po drugim.

    Pól ta klasa nie ma poza objętym zdaniem i każde z brakujących ma swój powód.
    Kontroli nie ma czego zapisywać, bo zdanie podrzędne niesie podmiot własny,
    a przeczenia tym bardziej: dopełniacz negacji przez tę pozycję nie sięga,
    bo zdanie podrzędne rozdaje przypadki własne.
    Idzie to samo z siebie, bo ``Kontekst.podrzędne`` nie przekazuje w dół
    ani wykonawcy, ani przeczenia, i jest to ta sama metoda, która puszcza czas.
    Wyróżnienia ta klasa nie przyjmuje, bo pozycję ma jedną i wziętą z polszczyzny,
    a nie z tego, o czym zdanie jest; rozstrzyga o niej ``_miejsce`` niżej.
    """

    zdanie: Zdanie

    #: Spójnik, którym polszczyzna wprowadza treść orzekaną wprost. Stoi tu stałą,
    #: a nie w leksykonie jak słowo okoliczności, bo autor nie ma tu czego wybierać:
    #: ``żeby`` mówi, że tak ma być, czyli jest inną kategorią.
    SŁOWO = "że"

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        return podrzędne(self.SŁOWO, self.zdanie, kontekst)

zdanie instance-attribute

SŁOWO = 'że' class-attribute instance-attribute

__init__(zdanie)

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    return podrzędne(self.SŁOWO, self.zdanie, kontekst)

Zdanie

To, co orzeka o kimś: jedno zdarzenie albo kilka opowiedzianych naraz.

Klasa ta jest tu po to, żeby dało się o nią zapytać. Okolicznik pyta, bo od tego zależy, czy jego słowo jest przyimkiem, czy spójnikiem, a lista kategorii wypisana obok rozjechałaby się z pierwszą kategorią dopisaną i tam niedopisaną.

Wnosi jedno liczenie i żąda za nie trzech rzeczy, które daje każda kategoria: podmiotu, o którym zdanie orzeka, czasownika, którym orzeka, oraz konstytuentów, czyli tego, z czego się wypisuje.

Source code in olski/skład/składnia.py

class Zdanie:
    """To, co orzeka o kimś: jedno zdarzenie albo kilka opowiedzianych naraz.

    Klasa ta jest tu po to, żeby dało się o nią zapytać.
    Okolicznik pyta, bo od tego zależy, czy jego słowo jest przyimkiem,
    czy spójnikiem, a lista kategorii wypisana obok rozjechałaby się
    z pierwszą kategorią dopisaną i tam niedopisaną.

    Wnosi jedno liczenie i żąda za nie trzech rzeczy, które daje każda kategoria:
    podmiotu, o którym zdanie orzeka, czasownika, którym orzeka,
    oraz konstytuentów, czyli tego, z czego się wypisuje.
    """

    @property
    def podmioty(self) -> tuple[Rola, ...]:
        """Role, które w tym zdaniu stoją jako podmiot, wraz z tymi ze zdań pod nim.

        Zdanie proste ma jeden podmiot, a złożone ma go tyle, ile ma zdarzeń,
        i wszystkie one są tym, na co czytelnik trafia,
        szukając podmiotu, którego zdanie obok nie wypisało.
        Liczą się przez to zdania z każdego piętra drzewa (:func:`_zdania_głębiej`),
        a nie z dwóch pierwszych: `Mysz goniła ogon myszy, która spała.`
        ma dwa podmioty, a z dwóch pięter widać jeden.

        Kontekstu ta lista nie dostaje i nie ma po co,
        bo pyta o role wypisane w drzewie, a kontekst rozstrzyga o formach.
        """
        pod = (
            rola
            for konstytuent in self.konstytuenty
            for niższe in _zdania_głębiej(konstytuent)
            for rola in niższe.podmioty
        )
        return (self.podmiot, *pod)

    @property
    def sprawcy(self) -> tuple:
        """Rzeczy, o których to zdanie orzeka wprost, bez zdań stojących pod nim.

        Pyta o co innego niż ``podmioty`` i dlatego wydaje co innego.
        Tamto szuka podmiotów, na które trafia czytelnik, więc wydaje role;
        to szuka tych, których czasownik nad tym zdaniem ma wskazać,
        gdy stoi ono jako bezokolicznik, więc wydaje rzeczy spod ról,
        czyli dokładnie to, co niesie ``Kontekst.sprawca``.
        Zdanie proste ma jednego sprawcę, a ciąg zdarzeń ma po jednym na zdarzenie,
        bo bezokoliczników w nim wyjdzie tyle samo.
        """
        return (self.podmiot.rdzeń,)

    def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
        """Role, które w tym zdaniu stoją jako uczestnik zdarzenia, wraz z przypadkiem.

        Przypadek idzie razem z rolą, bo osobno żadne z dwojga nie mówi,
        którą formą uczestnik w zdaniu stanie,
        a to jest jedyne pytanie, dla którego ta lista istnieje.

        Uczestnikiem nie jest okoliczność, i to jest tu cała treść:
        rzecz spod przyimka staje w przypadku, którego żąda ten przyimek,
        a nie w tym, który by jej przypadł z roli w zdarzeniu.
        Przez to samo lista ta mówi coś, czego po samych formach nie widać,
        i korzysta z tego ``olski/skład/przegląd.py``.

        Nie schodzi ona pod konstytuenty, inaczej niż ``podmioty`` wyżej,
        bo uczestnicy dwóch zdań zestawieni w jedną listę
        dawaliby parę, która przy żadnym orzeczeniu razem nie stanęła;
        po zdania schodzi ``konteksty`` niżej.
        """
        return ((self.podmiot, "nom"),)

    def konteksty(self, kontekst: Kontekst = TERAZ):
        """To zdanie wraz z tymi, które stoją pod nim, każde w swoim kontekście.

        Jednostką jest tu orzeczenie, bo tyle wystarcza,
        żeby o dwóch rolach powiedzieć, że stanęły przy jednym.

        Kontekst idzie razem ze zdaniem, bo bez niego nie wiadomo,
        jakim napisem to zdanie wyszło: zdanie podrzędne mówi o wskazanej rzeczy
        zaimkiem, a zdanie po zdaniu o tym samym podmiocie podmiotu nie wypisuje.
        Liczy się go tą samą drogą, którą idzie linearyzacja,
        bo druga kopia mierzyłaby tekst, którego ten plik nie składa;
        tak samo robi ``Akapit.konteksty`` w ``olski/skład/opowieść.py`` piętro wyżej.
        """
        yield self, kontekst
        for konstytuent in self.konstytuenty:
            for niższe, niżej in _zdania_pod(konstytuent, kontekst):
                yield from niższe.konteksty(niżej)

    def _orzeczenie(self, kontekst: Kontekst) -> str:
        """Czasownik w formie, której żąda podmiot, wraz z przeczeniem.

        Stoi tu, bo przeczenie stawia ``nie`` przed czasownikiem tak samo
        w zdaniu o czynności i w orzeczeniu imiennym.
        Różni je to, co przeczenie robi poza czasownikiem:
        dopełnienie traci biernik na rzecz dopełniacza, a orzecznik nie ma czego stracić,
        bo narzędnika przeczenie w polszczyźnie nie rusza.
        """
        forma = forma_czasownika(self.czasownik, self.podmiot, kontekst)
        return f"nie {forma}" if self.przeczenie else forma

podmioty property

Role, które w tym zdaniu stoją jako podmiot, wraz z tymi ze zdań pod nim.

Zdanie proste ma jeden podmiot, a złożone ma go tyle, ile ma zdarzeń, i wszystkie one są tym, na co czytelnik trafia, szukając podmiotu, którego zdanie obok nie wypisało. Liczą się przez to zdania z każdego piętra drzewa (_zdania_głębiej), a nie z dwóch pierwszych: Mysz goniła ogon myszy, która spała. ma dwa podmioty, a z dwóch pięter widać jeden.

Kontekstu ta lista nie dostaje i nie ma po co, bo pyta o role wypisane w drzewie, a kontekst rozstrzyga o formach.

sprawcy property

Rzeczy, o których to zdanie orzeka wprost, bez zdań stojących pod nim.

Pyta o co innego niż podmioty i dlatego wydaje co innego. Tamto szuka podmiotów, na które trafia czytelnik, więc wydaje role; to szuka tych, których czasownik nad tym zdaniem ma wskazać, gdy stoi ono jako bezokolicznik, więc wydaje rzeczy spod ról, czyli dokładnie to, co niesie Kontekst.sprawca. Zdanie proste ma jednego sprawcę, a ciąg zdarzeń ma po jednym na zdarzenie, bo bezokoliczników w nim wyjdzie tyle samo.

uczestnicy(kontekst=TERAZ)

Role, które w tym zdaniu stoją jako uczestnik zdarzenia, wraz z przypadkiem.

Przypadek idzie razem z rolą, bo osobno żadne z dwojga nie mówi, którą formą uczestnik w zdaniu stanie, a to jest jedyne pytanie, dla którego ta lista istnieje.

Uczestnikiem nie jest okoliczność, i to jest tu cała treść: rzecz spod przyimka staje w przypadku, którego żąda ten przyimek, a nie w tym, który by jej przypadł z roli w zdarzeniu. Przez to samo lista ta mówi coś, czego po samych formach nie widać, i korzysta z tego olski/skład/przegląd.py.

Nie schodzi ona pod konstytuenty, inaczej niż podmioty wyżej, bo uczestnicy dwóch zdań zestawieni w jedną listę dawaliby parę, która przy żadnym orzeczeniu razem nie stanęła; po zdania schodzi konteksty niżej.

Source code in olski/skład/składnia.py

def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
    """Role, które w tym zdaniu stoją jako uczestnik zdarzenia, wraz z przypadkiem.

    Przypadek idzie razem z rolą, bo osobno żadne z dwojga nie mówi,
    którą formą uczestnik w zdaniu stanie,
    a to jest jedyne pytanie, dla którego ta lista istnieje.

    Uczestnikiem nie jest okoliczność, i to jest tu cała treść:
    rzecz spod przyimka staje w przypadku, którego żąda ten przyimek,
    a nie w tym, który by jej przypadł z roli w zdarzeniu.
    Przez to samo lista ta mówi coś, czego po samych formach nie widać,
    i korzysta z tego ``olski/skład/przegląd.py``.

    Nie schodzi ona pod konstytuenty, inaczej niż ``podmioty`` wyżej,
    bo uczestnicy dwóch zdań zestawieni w jedną listę
    dawaliby parę, która przy żadnym orzeczeniu razem nie stanęła;
    po zdania schodzi ``konteksty`` niżej.
    """
    return ((self.podmiot, "nom"),)

konteksty(kontekst=TERAZ)

To zdanie wraz z tymi, które stoją pod nim, każde w swoim kontekście.

Jednostką jest tu orzeczenie, bo tyle wystarcza, żeby o dwóch rolach powiedzieć, że stanęły przy jednym.

Kontekst idzie razem ze zdaniem, bo bez niego nie wiadomo, jakim napisem to zdanie wyszło: zdanie podrzędne mówi o wskazanej rzeczy zaimkiem, a zdanie po zdaniu o tym samym podmiocie podmiotu nie wypisuje. Liczy się go tą samą drogą, którą idzie linearyzacja, bo druga kopia mierzyłaby tekst, którego ten plik nie składa; tak samo robi Akapit.konteksty w olski/skład/opowieść.py piętro wyżej.

Source code in olski/skład/składnia.py

def konteksty(self, kontekst: Kontekst = TERAZ):
    """To zdanie wraz z tymi, które stoją pod nim, każde w swoim kontekście.

    Jednostką jest tu orzeczenie, bo tyle wystarcza,
    żeby o dwóch rolach powiedzieć, że stanęły przy jednym.

    Kontekst idzie razem ze zdaniem, bo bez niego nie wiadomo,
    jakim napisem to zdanie wyszło: zdanie podrzędne mówi o wskazanej rzeczy
    zaimkiem, a zdanie po zdaniu o tym samym podmiocie podmiotu nie wypisuje.
    Liczy się go tą samą drogą, którą idzie linearyzacja,
    bo druga kopia mierzyłaby tekst, którego ten plik nie składa;
    tak samo robi ``Akapit.konteksty`` w ``olski/skład/opowieść.py`` piętro wyżej.
    """
    yield self, kontekst
    for konstytuent in self.konstytuenty:
        for niższe, niżej in _zdania_pod(konstytuent, kontekst):
            yield from niższe.konteksty(niżej)

Jest dataclass

Bases: Zdanie

Orzeczenie imienne: zwykły tekst polski jest wejściem.

Orzecznik idzie w narzędniku, bo tyle bierze kopula. Szyk wychodzi z wyróżnień tak samo jak przy zdarzeniu, więc Wejściem jest zwykły tekst polski. jest tu orzecznikiem postawionym na czele wraz z podmiotem odesłanym na koniec, a nie wariantem linearyzacji.

Kopula jest polem, a nie stałą, bo autor wybiera między orzekaniem o tym, co jest, a orzekaniem o tym, co się kimś staje albo kimś zostaje, i jest to wybór dziedziny, a nie forma do policzenia. Wybór ogranicza leksykon, tak samo jak przy czynności: orzecznik w narzędniku bierze kopula i nikt poza nią, więc lemat, którego rama go nie ma, zgłasza się tutaj (olski.walencja.KOPULA).

Okoliczność dochodzi do orzekania tak samo jak do czynności, bo pytanie, na które ona odpowiada, jest w obu wypadkach to samo, i dlatego Kot jest zwierzęciem w piwnicy. wychodzi z tej kategorii.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Jest(Zdanie):
    """Orzeczenie imienne: zwykły tekst polski jest wejściem.

    Orzecznik idzie w narzędniku, bo tyle bierze kopula.
    Szyk wychodzi z wyróżnień tak samo jak przy zdarzeniu,
    więc `Wejściem jest zwykły tekst polski.` jest tu orzecznikiem postawionym
    na czele wraz z podmiotem odesłanym na koniec, a nie wariantem linearyzacji.

    Kopula jest polem, a nie stałą, bo autor wybiera między orzekaniem
    o tym, co jest, a orzekaniem o tym, co się kimś staje albo kimś zostaje,
    i jest to wybór dziedziny, a nie forma do policzenia.
    Wybór ogranicza leksykon, tak samo jak przy czynności:
    orzecznik w narzędniku bierze kopula i nikt poza nią,
    więc lemat, którego rama go nie ma, zgłasza się tutaj
    (:data:`olski.walencja.KOPULA`).

    Okoliczność dochodzi do orzekania tak samo jak do czynności,
    bo pytanie, na które ona odpowiada, jest w obu wypadkach to samo,
    i dlatego `Kot jest zwierzęciem w piwnicy.` wychodzi z tej kategorii.
    """

    #: Kopula, którą to zdanie orzeka, gdy autor żadnej nie wybrał.
    #: Bycie jest tu domyślnością, bo o zmianie nie mówi nic,
    #: a każda pozostała kopula mówi o niej coś ponadto.
    CZASOWNIK = "być"

    co: Rola | Wyróżnienie
    czym: Rola | Wyróżnienie
    czasownik: str = CZASOWNIK
    okoliczniki: tuple = ()
    przeczenie: bool = False

    def __post_init__(self) -> None:
        if ORZECZNIK not in rama(self.czasownik):
            raise PozaRamą(f"{self.czasownik} nie bierze orzecznika w narzędniku")

    @property
    def podmiot(self) -> Rola:
        return _goły(self.co)

    @property
    def konstytuenty(self) -> tuple:
        return (self.co, self.czym, *self.okoliczniki)

    def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
        return ((self.podmiot, "nom"), (_goły(self.czym), ORZECZNIK))

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        return szyk(
            [
                *_podmiot(self.co, kontekst),
                (None, Kawałek(self._orzeczenie(kontekst))),
                (
                    _miejsce(self.czym, kontekst),
                    wypisz(_goły(self.czym), ORZECZNIK, kontekst),
                ),
                *_okoliczności(self.okoliczniki, kontekst),
            ]
        )

CZASOWNIK = 'być' class-attribute instance-attribute

co instance-attribute

czym instance-attribute

czasownik = CZASOWNIK class-attribute instance-attribute

okoliczniki = () class-attribute instance-attribute

przeczenie = False class-attribute instance-attribute

podmiot property

konstytuenty property

__init__(co, czym, czasownik=CZASOWNIK, okoliczniki=(), przeczenie=False)

__post_init__()

Source code in olski/skład/składnia.py

def __post_init__(self) -> None:
    if ORZECZNIK not in rama(self.czasownik):
        raise PozaRamą(f"{self.czasownik} nie bierze orzecznika w narzędniku")

uczestnicy(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
    return ((self.podmiot, "nom"), (_goły(self.czym), ORZECZNIK))

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    return szyk(
        [
            *_podmiot(self.co, kontekst),
            (None, Kawałek(self._orzeczenie(kontekst))),
            (
                _miejsce(self.czym, kontekst),
                wypisz(_goły(self.czym), ORZECZNIK, kontekst),
            ),
            *_okoliczności(self.okoliczniki, kontekst),
        ]
    )

Robi dataclass

Bases: Zdanie

Zdanie o czynności: program zapisuje ustawienia.

Dopełnienie nie pyta, czy stoi pod nim rzecz, czy zdarzenie, i jest to ta sama jedna kategoria, którą Okolicznik ma o piętro obok. Czeladnik zaczął pracę. i Czeladnik zaczął pracować. mówią, co zaczął, a różnią się tym, czy zaczął rzecz, czy zdarzenie. Że wychodzi z tego raz biernik, a raz bezokolicznik bez podmiotu, rozstrzyga linearyzacja, tak samo jak rozstrzyga przypadek. Trzecią rzeczą, która tam stoi, jest Treść wyżej, czyli zdarzenie, o którym podmiot coś orzeka, zamiast je wykonywać.

Pytana o wszystkie trzy jest rama z leksykonu walencyjnego, bo wszystkie są jej pozycjami, a pytanie pada jedno: czy pozycja, którą ten konstytuent zajmuje, stoi w ramie tego czasownika. Rama jest zbiorem, więc pozycja dopisana do leksykonu nie dokłada tu gałęzi (rama w olski/walencja.py). Pytany jest ten sam plik, o który pyta parser po drugiej stronie, bo rama jest faktem o słowie, a nie o kierunku. Ostatnie z tych pytań waży najwięcej przy czasowniku, który bierze i biernik: zamykać biernik bierze, a Zamykał, że okno stało. nie jest zdaniem, i to leksykon jest jedyną rzeczą, która te dwa czasowniki rozdziela.

Dopełnienie pyta przy tym o dwa przypadki naraz i staje w tym, który rama ma, bo przypadek bierze się tu z pozycji jak wszędzie indziej: Czeladnik szukał córki krawca. i Czeladnik zasłonił twarz. wychodzą z drzewa tego samego kształtu, a autor nie pisze przypadka w żadnym (PRZYPADKI_DOPEŁNIENIA).

Uczestnik w celowniku stoi obok tego dopełnienia, a nie zamiast niego, i dlatego ma tu osobne pole: Parser pokazuje autorowi czytania. wypełnia dwie pozycje ramy naraz, a o tym, która rzecz stoi w której, mówi Komu wyżej.

Kopuli ta kategoria nie bierze wcale, i jest to ta sama odmowa co powyższe: rama kopuli ma orzecznik, a orzecznikiem orzeka Jest obok, więc Parser jest. nie wychodzi stąd tak samo, jak nie wyprowadza się z olskiego.

Sprawca bezokolicznika stoi w drzewie, a nie w leksykonie, i jest nim ta sama zmienna postawiona dwa razy, jak w Opis i w Postać. Drzewo, które postawiło tam kogoś innego, zgłasza się, bo bezokolicznik podmiotu nie ma i wyszedłby tekstem o kimś innym; czego polszczyzna mówi tam zamiast niego, trzyma docs/kategorie-zapisu.md.

Pytania padają w konstruktorze, a nie w linearyzacji, bo to konstruktor mówi, co z czym wolno złożyć, i bo drzewo, które tego nie przechodzi, jest błędne całe, a nie w tym jednym miejscu, gdzie się je wypisuje.

Przeczenie stoi tu polem, a nie osobnym konstruktorem, bo sięga dwóch rzeczy naraz: stawia nie przed czasownikiem i zabiera dopełnieniu biernik na rzecz dopełniacza, a te dwie rzeczy są jedną decyzją i rozjechać się nie mogą. Pierwszą z nich robi Zdanie dla obu kategorii, a druga jest tutaj, bo orzeczenie imienne dopełnienia nie ma.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Robi(Zdanie):
    """Zdanie o czynności: program zapisuje ustawienia.

    Dopełnienie nie pyta, czy stoi pod nim rzecz, czy zdarzenie,
    i jest to ta sama jedna kategoria, którą ``Okolicznik`` ma o piętro obok.
    `Czeladnik zaczął pracę.` i `Czeladnik zaczął pracować.`
    mówią, co zaczął, a różnią się tym, czy zaczął rzecz, czy zdarzenie.
    Że wychodzi z tego raz biernik, a raz bezokolicznik bez podmiotu,
    rozstrzyga linearyzacja, tak samo jak rozstrzyga przypadek.
    Trzecią rzeczą, która tam stoi, jest ``Treść`` wyżej,
    czyli zdarzenie, o którym podmiot coś orzeka, zamiast je wykonywać.

    Pytana o wszystkie trzy jest rama z leksykonu walencyjnego, bo wszystkie są jej
    pozycjami, a pytanie pada jedno: czy pozycja, którą ten konstytuent zajmuje,
    stoi w ramie tego czasownika.
    Rama jest zbiorem, więc pozycja dopisana do leksykonu nie dokłada tu gałęzi
    (``rama`` w ``olski/walencja.py``).
    Pytany jest ten sam plik, o który pyta parser po drugiej stronie,
    bo rama jest faktem o słowie, a nie o kierunku.
    Ostatnie z tych pytań waży najwięcej przy czasowniku, który bierze i biernik:
    ``zamykać`` biernik bierze, a `Zamykał, że okno stało.` nie jest zdaniem,
    i to leksykon jest jedyną rzeczą, która te dwa czasowniki rozdziela.

    Dopełnienie pyta przy tym o dwa przypadki naraz i staje w tym, który rama ma,
    bo przypadek bierze się tu z pozycji jak wszędzie indziej:
    `Czeladnik szukał córki krawca.` i `Czeladnik zasłonił twarz.`
    wychodzą z drzewa tego samego kształtu, a autor nie pisze przypadka w żadnym
    (:data:`PRZYPADKI_DOPEŁNIENIA`).

    Uczestnik w celowniku stoi obok tego dopełnienia, a nie zamiast niego,
    i dlatego ma tu osobne pole:
    `Parser pokazuje autorowi czytania.` wypełnia dwie pozycje ramy naraz,
    a o tym, która rzecz stoi w której, mówi ``Komu`` wyżej.

    Kopuli ta kategoria nie bierze wcale, i jest to ta sama odmowa co powyższe:
    rama kopuli ma orzecznik, a orzecznikiem orzeka ``Jest`` obok,
    więc `Parser jest.` nie wychodzi stąd tak samo, jak nie wyprowadza się z olskiego.

    Sprawca bezokolicznika stoi w drzewie, a nie w leksykonie,
    i jest nim ta sama zmienna postawiona dwa razy, jak w ``Opis`` i w ``Postać``.
    Drzewo, które postawiło tam kogoś innego, zgłasza się,
    bo bezokolicznik podmiotu nie ma i wyszedłby tekstem o kimś innym;
    czego polszczyzna mówi tam zamiast niego, trzyma ``docs/kategorie-zapisu.md``.

    Pytania padają w konstruktorze, a nie w linearyzacji,
    bo to konstruktor mówi, co z czym wolno złożyć,
    i bo drzewo, które tego nie przechodzi, jest błędne całe,
    a nie w tym jednym miejscu, gdzie się je wypisuje.

    Przeczenie stoi tu polem, a nie osobnym konstruktorem,
    bo sięga dwóch rzeczy naraz: stawia ``nie`` przed czasownikiem
    i zabiera dopełnieniu biernik na rzecz dopełniacza,
    a te dwie rzeczy są jedną decyzją i rozjechać się nie mogą.
    Pierwszą z nich robi ``Zdanie`` dla obu kategorii, a druga jest tutaj,
    bo orzeczenie imienne dopełnienia nie ma.
    """

    kto: Rola | Wyróżnienie
    czyn: str
    co: Rola | Wyróżnienie | Zdanie | Treść | None = None
    komu: Komu | Wyróżnienie | None = None
    okoliczniki: tuple = ()
    przeczenie: bool = False

    def __post_init__(self) -> None:
        if ORZECZNIK in rama(self.czyn):
            raise PozaRamą(f"{self.czyn} orzeka orzecznikiem, a nie czynnością")
        for żądane in self._żądania():
            _pozycja(self.czyn, żądane)
        dopełnienie = _goły(self.co)
        if isinstance(dopełnienie, Zdanie) and any(
            sprawca is not self.podmiot.rdzeń for sprawca in dopełnienie.sprawcy
        ):
            raise PozaRamą(f"bezokolicznik przy {self.czyn} orzeka o kimś innym")

    def _żądania(self):
        """Pozycje, których to drzewo żąda od ramy: po jednym żądaniu na wypełnioną pozycję.

        Pętla, a nie pytanie na pozycję, i to jest tu cała treść:
        pozycja dopisana do tej kategorii dokłada wiersz tutaj,
        a nie gałąź w konstruktorze i drugą w leksykonie.
        """
        if self.co is not None:
            yield _żądanie(_goły(self.co))
        if self.komu is not None:
            yield (CELOWNIK,)

    @property
    def czasownik(self) -> str:
        """Lemat, którym to zdanie orzeka.

        Czyn jest kategorią dziedziny, a czasownik słowem, które z niej wychodzi,
        więc jedno pole odpowiada tu na dwa pytania i oba są nazwane:
        drzewo pisze się czynem, a o formę pyta się czasownika.
        """
        return self.czyn

    @property
    def podmiot(self) -> Rola:
        return _goły(self.kto)

    @property
    def konstytuenty(self) -> tuple:
        wypełnione = tuple(pole for pole in (self.komu, self.co) if pole is not None)
        return (self.kto, *wypełnione, *self.okoliczniki)

    def _dopełnienie(self, kontekst: Kontekst) -> Kawałek:
        """Dopełnienie wypisane jako grupa imienna, bezokolicznik albo treść.

        Treść wypisuje się sama i nie dostaje stąd nic ponad to,
        co ``Kontekst.podrzędne`` daje każdemu zdaniu podrzędnemu,
        bo ma podmiot własny i własne przypadki.

        Zdarzenie dostaje kontekst zdania podrzędnego wraz z dwiema rzeczami,
        których to zdanie o sobie nie wie i wiedzieć nie może.
        Sprawcą jest podmiot tego zdania, więc bezokolicznik podmiotu nie wypisze
        i weźmie z niego formę, której sam nie ma.
        Przeczenie idzie tą samą drogą, bo dopełniacz negacji sięga przez bezokolicznik:
        `Nie chciał wynieść lustra.` przeczy raz, a przypadek zmienia o piętro niżej,
        i dlatego jedno przeczenie liczy się tu z dwóch pięter naraz.
        Treść tej drogi nie ma i to jest cała różnica między tymi dwiema pozycjami:
        `Nie wierzył, że wyniosła kufer.` przeczy jednemu czasownikowi,
        a drugi zostaje przy swoim bierniku.
        """
        dopełnienie = _goły(self.co)
        if isinstance(dopełnienie, Treść):
            return dopełnienie.linearyzuj(kontekst)
        if isinstance(dopełnienie, Zdanie):
            return dopełnienie.linearyzuj(
                replace(
                    kontekst.podrzędne(),
                    sprawca=self.podmiot.rdzeń,
                    pod_przeczeniem=self._przeczone(kontekst),
                )
            )
        return wypisz(dopełnienie, self._przypadek(kontekst), kontekst)

    def _przeczone(self, kontekst: Kontekst) -> bool:
        """Czy to zdanie stoi pod przeczeniem, własnym albo cudzym."""
        return self.przeczenie or kontekst.pod_przeczeniem

    def _przypadek(self, kontekst: Kontekst) -> str:
        """Przypadek, w którym staje dopełnienie: ten z ramy, a pod przeczeniem dopełniacz.

        Pytają o to dwa miejsca i muszą dostać tę samą odpowiedź:
        linearyzacja, żeby dopełnienie wypisać,
        i ``uczestnicy``, żeby powiedzieć, jaką formą ono stanęło.
        Druga kopia rozjechałaby się z pierwszą zmianą przeczenia
        i nie zgłosiłaby tego nigdzie, bo obie odpowiedzi są poprawnymi przypadkami.

        Dopełniacz negacji wchodzi w miejsce biernika i dopełniacza z leksykonu
        nie rusza, bo nie ma tam czego zmienić:
        `Czeladnik nie szukał córki krawca.` stoi w tym samym przypadku,
        co to samo zdanie bez przeczenia.
        """
        if self._przeczone(kontekst):
            return DOPEŁNIACZ
        return _pozycja(self.czyn, PRZYPADKI_DOPEŁNIENIA)

    def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
        """Podmiot, a wraz z nim ci uczestnicy, którzy są rzeczą, a nie zdarzeniem.

        Bezokolicznik podmiotem nie stanie, więc uczestnikiem nie jest:
        pytanie, dla którego ta lista istnieje, jest pytaniem o role wymienne.
        Celownik stanąć nim nie może z innego powodu i wchodzi tu mimo to,
        bo powód ten jest formą, a nie kategorią: rzeczownik ma celownik różny
        od mianownika i to rozstrzyga ``olski/skład/przegląd.py``, a nie ta lista.
        """
        role = [(self.podmiot, "nom")]
        dopełnienie = _goły(self.co)
        if isinstance(dopełnienie, Rola):
            role.append((dopełnienie, self._przypadek(kontekst)))
        if self.komu is not None:
            role.append((_goły(self.komu).co, CELOWNIK))
        return tuple(role)

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        pozycje = _podmiot(self.kto, kontekst)
        pozycje.append((None, Kawałek(self._orzeczenie(kontekst))))
        if self.komu is not None:
            pozycje.append((_miejsce(self.komu, kontekst), _goły(self.komu).linearyzuj(kontekst)))
        if self.co is not None:
            pozycje.append((_miejsce(self.co, kontekst), self._dopełnienie(kontekst)))
        pozycje.extend(_okoliczności(self.okoliczniki, kontekst))
        return szyk(pozycje)

kto instance-attribute

czyn instance-attribute

co = None class-attribute instance-attribute

komu = None class-attribute instance-attribute

okoliczniki = () class-attribute instance-attribute

przeczenie = False class-attribute instance-attribute

czasownik property

Lemat, którym to zdanie orzeka.

Czyn jest kategorią dziedziny, a czasownik słowem, które z niej wychodzi, więc jedno pole odpowiada tu na dwa pytania i oba są nazwane: drzewo pisze się czynem, a o formę pyta się czasownika.

podmiot property

konstytuenty property

__init__(kto, czyn, co=None, komu=None, okoliczniki=(), przeczenie=False)

__post_init__()

Source code in olski/skład/składnia.py

def __post_init__(self) -> None:
    if ORZECZNIK in rama(self.czyn):
        raise PozaRamą(f"{self.czyn} orzeka orzecznikiem, a nie czynnością")
    for żądane in self._żądania():
        _pozycja(self.czyn, żądane)
    dopełnienie = _goły(self.co)
    if isinstance(dopełnienie, Zdanie) and any(
        sprawca is not self.podmiot.rdzeń for sprawca in dopełnienie.sprawcy
    ):
        raise PozaRamą(f"bezokolicznik przy {self.czyn} orzeka o kimś innym")

uczestnicy(kontekst=TERAZ)

Podmiot, a wraz z nim ci uczestnicy, którzy są rzeczą, a nie zdarzeniem.

Bezokolicznik podmiotem nie stanie, więc uczestnikiem nie jest: pytanie, dla którego ta lista istnieje, jest pytaniem o role wymienne. Celownik stanąć nim nie może z innego powodu i wchodzi tu mimo to, bo powód ten jest formą, a nie kategorią: rzeczownik ma celownik różny od mianownika i to rozstrzyga olski/skład/przegląd.py, a nie ta lista.

Source code in olski/skład/składnia.py

def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
    """Podmiot, a wraz z nim ci uczestnicy, którzy są rzeczą, a nie zdarzeniem.

    Bezokolicznik podmiotem nie stanie, więc uczestnikiem nie jest:
    pytanie, dla którego ta lista istnieje, jest pytaniem o role wymienne.
    Celownik stanąć nim nie może z innego powodu i wchodzi tu mimo to,
    bo powód ten jest formą, a nie kategorią: rzeczownik ma celownik różny
    od mianownika i to rozstrzyga ``olski/skład/przegląd.py``, a nie ta lista.
    """
    role = [(self.podmiot, "nom")]
    dopełnienie = _goły(self.co)
    if isinstance(dopełnienie, Rola):
        role.append((dopełnienie, self._przypadek(kontekst)))
    if self.komu is not None:
        role.append((_goły(self.komu).co, CELOWNIK))
    return tuple(role)

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    pozycje = _podmiot(self.kto, kontekst)
    pozycje.append((None, Kawałek(self._orzeczenie(kontekst))))
    if self.komu is not None:
        pozycje.append((_miejsce(self.komu, kontekst), _goły(self.komu).linearyzuj(kontekst)))
    if self.co is not None:
        pozycje.append((_miejsce(self.co, kontekst), self._dopełnienie(kontekst)))
    pozycje.extend(_okoliczności(self.okoliczniki, kontekst))
    return szyk(pozycje)

Ciąg dataclass

Bases: Zdanie

Kilka zdarzeń opowiedzianych jednym zdaniem: podniósł deskę i zszedł.

Kategorią dziedziny jest tu następstwo, a nie spójnik. Autor mówi, że jedno stało się po drugim i że jest to jedna rzecz do opowiedzenia, a to, że wychodzi z tego i, rozstrzyga linearyzacja, tak samo jak rozstrzyga przypadek. Węższe to jest niż polskie i, które łączy także zdarzenia równoczesne, i węższe z rozmysłu: kolejność zdarzeń niesie tu kolejność zapisu, więc kategoria, która by o niej nie mówiła, kłamałaby o połowie swoich zdań.

Od koordynacji bytów różni się tym, czego żąda opuszczenie podmiotu. Byty stoją w jednej roli i żaden z nich nie ma czasownika, a zdarzenia mają go po jednym, więc drugie z nich mówi o tym samym, o kim mówiło pierwsze, i podmiotu nie powtarza. Rozstrzyga o tym pomijalny niżej, czyli ten sam warunek, z którego korzysta akapit, bo pytanie jest jedno: czy czytelnik odzyska podmiot, którego nie ma.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Ciąg(Zdanie):
    """Kilka zdarzeń opowiedzianych jednym zdaniem: podniósł deskę i zszedł.

    Kategorią dziedziny jest tu następstwo, a nie spójnik.
    Autor mówi, że jedno stało się po drugim i że jest to jedna rzecz do opowiedzenia,
    a to, że wychodzi z tego ``i``, rozstrzyga linearyzacja,
    tak samo jak rozstrzyga przypadek.
    Węższe to jest niż polskie ``i``, które łączy także zdarzenia równoczesne,
    i węższe z rozmysłu: kolejność zdarzeń niesie tu kolejność zapisu,
    więc kategoria, która by o niej nie mówiła, kłamałaby o połowie swoich zdań.

    Od koordynacji bytów różni się tym, czego żąda opuszczenie podmiotu.
    Byty stoją w jednej roli i żaden z nich nie ma czasownika,
    a zdarzenia mają go po jednym, więc drugie z nich mówi o tym samym,
    o kim mówiło pierwsze, i podmiotu nie powtarza.
    Rozstrzyga o tym ``pomijalny`` niżej, czyli ten sam warunek,
    z którego korzysta akapit, bo pytanie jest jedno:
    czy czytelnik odzyska podmiot, którego nie ma.
    """

    zdarzenia: tuple

    @property
    def podmiot(self) -> Rola:
        return self.zdarzenia[0].podmiot

    @property
    def czasownik(self) -> str:
        return self.zdarzenia[0].czasownik

    @property
    def konstytuenty(self) -> tuple:
        return tuple(część for zdarzenie in self.zdarzenia for część in zdarzenie.konstytuenty)

    @property
    def podmioty(self) -> tuple[Rola, ...]:
        """Podmioty wszystkich zdarzeń, a nie samego pierwszego.

        Domyślne liczenie schodzi pod konstytuenty, a te ciąg ma sklejone,
        więc znalazłoby zdania pod zdarzeniami i minęłoby same zdarzenia.
        """
        return tuple(rola for zdarzenie in self.zdarzenia for rola in zdarzenie.podmioty)

    @property
    def sprawcy(self) -> tuple:
        """Sprawca każdego zdarzenia, bo bezokolicznik wyjdzie z każdego osobno.

        Zdania pod zdarzeniami tu nie wchodzą, w odróżnieniu od ``podmioty``:
        `Chciał podnieść deskę i zejść po schodach.` żąda jednego sprawcy
        od dwóch bezokoliczników, a zdanie z ``bo`` pod którymś z nich
        ma podmiot własny i wychodzi z formą osobową.
        """
        return tuple(sprawca for zdarzenie in self.zdarzenia for sprawca in zdarzenie.sprawcy)

    def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
        """Żadnych, bo ciąg własnego orzeczenia nie ma, tylko po jednym na zdarzenie.

        Podmiot ciąg ma mimo to, i jest nim podmiot pierwszego zdarzenia,
        bo o to pyta ``pomijalny``, składając ciąg ze zdaniem obok.
        Tu odpowiedź jest inna, bo inne jest pytanie:
        uczestnicy stają przy orzeczeniu, a nie przy zdaniu,
        więc szuka się ich w ``konteksty`` niżej, po jednym zdarzeniu naraz.
        """
        return ()

    def _kolejno(self, kontekst: Kontekst):
        """Zdarzenia wraz z kontekstem każdego: drugie i dalsze podmiot opuszczają.

        Pierwsze bierze kontekst nietknięty, a nie policzony wobec pustki,
        bo o jego podmiocie rozstrzygnął akapit, składając cały ciąg ze zdaniem
        przed nim, i ta odpowiedź stoi już w tym kontekście.

        Odpowiedź pada tu raz, a czyta ją i linearyzacja, i ``konteksty``,
        bo o opuszczonym podmiocie musi wiedzieć nie tylko ten, kto ciąg wypisuje,
        ale i ten, kto pyta, co z niego wyszło.
        """
        poprzednie = None
        for zdarzenie in self.zdarzenia:
            yield zdarzenie, (
                kontekst if poprzednie is None else po_poprzednim(zdarzenie, poprzednie, kontekst)
            )
            poprzednie = zdarzenie

    def konteksty(self, kontekst: Kontekst = TERAZ):
        """Zdania wszystkich zdarzeń, a nie samego ciągu, każde w kontekście z ``_kolejno``."""
        for zdarzenie, jego in self._kolejno(kontekst):
            yield from zdarzenie.konteksty(jego)

    def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
        return lista([zdarzenie.linearyzuj(jego) for zdarzenie, jego in self._kolejno(kontekst)])

zdarzenia instance-attribute

podmiot property

czasownik property

konstytuenty property

podmioty property

Podmioty wszystkich zdarzeń, a nie samego pierwszego.

Domyślne liczenie schodzi pod konstytuenty, a te ciąg ma sklejone, więc znalazłoby zdania pod zdarzeniami i minęłoby same zdarzenia.

sprawcy property

Sprawca każdego zdarzenia, bo bezokolicznik wyjdzie z każdego osobno.

Zdania pod zdarzeniami tu nie wchodzą, w odróżnieniu od podmioty: Chciał podnieść deskę i zejść po schodach. żąda jednego sprawcy od dwóch bezokoliczników, a zdanie z bo pod którymś z nich ma podmiot własny i wychodzi z formą osobową.

__init__(zdarzenia)

uczestnicy(kontekst=TERAZ)

Żadnych, bo ciąg własnego orzeczenia nie ma, tylko po jednym na zdarzenie.

Podmiot ciąg ma mimo to, i jest nim podmiot pierwszego zdarzenia, bo o to pyta pomijalny, składając ciąg ze zdaniem obok. Tu odpowiedź jest inna, bo inne jest pytanie: uczestnicy stają przy orzeczeniu, a nie przy zdaniu, więc szuka się ich w konteksty niżej, po jednym zdarzeniu naraz.

Source code in olski/skład/składnia.py

def uczestnicy(self, kontekst: Kontekst = TERAZ) -> tuple[tuple[Rola, str], ...]:
    """Żadnych, bo ciąg własnego orzeczenia nie ma, tylko po jednym na zdarzenie.

    Podmiot ciąg ma mimo to, i jest nim podmiot pierwszego zdarzenia,
    bo o to pyta ``pomijalny``, składając ciąg ze zdaniem obok.
    Tu odpowiedź jest inna, bo inne jest pytanie:
    uczestnicy stają przy orzeczeniu, a nie przy zdaniu,
    więc szuka się ich w ``konteksty`` niżej, po jednym zdarzeniu naraz.
    """
    return ()

konteksty(kontekst=TERAZ)

Zdania wszystkich zdarzeń, a nie samego ciągu, każde w kontekście z _kolejno.

Source code in olski/skład/składnia.py

def konteksty(self, kontekst: Kontekst = TERAZ):
    """Zdania wszystkich zdarzeń, a nie samego ciągu, każde w kontekście z ``_kolejno``."""
    for zdarzenie, jego in self._kolejno(kontekst):
        yield from zdarzenie.konteksty(jego)

linearyzuj(kontekst=TERAZ)

Source code in olski/skład/składnia.py

def linearyzuj(self, kontekst: Kontekst = TERAZ) -> Kawałek:
    return lista([zdarzenie.linearyzuj(jego) for zdarzenie, jego in self._kolejno(kontekst)])

Opis dataclass

Bases: Rola

Rzecz wskazana zdarzeniem, w którym stoi: postaci, których nikt nie liczył.

Kategorią dziedziny jest tu wskazywanie, a nie zdanie podrzędne. Jaki wskazuje rzecz cechą, ta klasa wskazuje ją zdarzeniem, i pytanie jest w obu wypadkach jedno: o którą rzecz mowa. Że wychodzi z tego przydawka zdaniowa wraz z zaimkiem i przecinkami, rozstrzyga linearyzacja, tak samo jak rozstrzyga przypadek.

Które miejsce w zdarzeniu zostaje zaimkiem, mówi tożsamość obiektu, a nie osobny znacznik postawiony w tym miejscu. Autor pisze rzecz raz i stawia tę samą zmienną w zdaniu, które ją opisuje, czyli robi to samo, co robi z Postać w olski/skład/opowieść.py: tam ta sama zmienna dwa razy jest jedną rzeczą w dwóch zdaniach, a tutaj jest jedną rzeczą w zdaniu nadrzędnym i podrzędnym naraz.

Zdanie, które tej rzeczy nie stawia w miejscu, skąd zaimek wyjdzie na czoło, zgłasza się od razu, bo opis, który nie opisuje, jest błędem drzewa. Czym jest to miejsce, mówi _wskazany.

Source code in olski/skład/składnia.py

@dataclass(frozen=True)
class Opis(Rola):
    """Rzecz wskazana zdarzeniem, w którym stoi: postaci, których nikt nie liczył.

    Kategorią dziedziny jest tu wskazywanie, a nie zdanie podrzędne.
    ``Jaki`` wskazuje rzecz cechą, ta klasa wskazuje ją zdarzeniem,
    i pytanie jest w obu wypadkach jedno: o którą rzecz mowa.
    Że wychodzi z tego przydawka zdaniowa wraz z zaimkiem i przecinkami,
    rozstrzyga linearyzacja, tak samo jak rozstrzyga przypadek.

    Które miejsce w zdarzeniu zostaje zaimkiem, mówi tożsamość obiektu,
    a nie osobny znacznik postawiony w tym miejscu.
    Autor pisze rzecz raz i stawia tę samą zmienną w zdaniu, które ją opisuje,
    czyli robi to samo, co robi z ``Postać`` w ``olski/skład/opowieść.py``:
    tam ta sama zmienna dwa razy jest jedną rzeczą w dwóch zdaniach,
    a tutaj jest jedną rzeczą w zdaniu nadrzędnym i podrzędnym naraz.

    Zdanie, które tej rzeczy nie stawia w miejscu, skąd zaimek wyjdzie na czoło,
    zgłasza się od razu, bo opis, który nie opisuje, jest błędem drzewa.
    Czym jest to miejsce, mówi ``_wskazany``.
    """

    rzecz: Rola
    zdanie: object

    def __post_init__(self) -> None:
        kontekst = Kontekst(wskazywany=self.rzecz)
        if not any(_wskazany(część, kontekst) for część in self.zdanie.konstytuenty):
            raise PozaRamą("zdanie opisujące nie stawia opisywanej rzeczy")

    @property
    def number(self) -> str:
        return self.rzecz.number

    @property
    def rodzaj(self) -> str:
        return self.rzecz.rodzaj

    @property
    def tożsamość(self):
        return self.rzecz.tożsamość

    def wewnątrz(self, kontekst: Kontekst) -> Kontekst:
        """Kontekst zdania opisującego: podrzędne wraz z rzeczą, którą ma wskazać.

        Wydzielone z linearyzacji, bo pyta o to samo ``_zdania_pod``,
        a bez tej rzeczy opis wychodziłby stamtąd zdaniem, w którym zaimka nie ma,
        czyli napisem, którego autor nie dostał.
        """
        return replace(kontekst.podrzędne(), wskazywany=self.rzecz)

    def linearyzuj(self, case: str, kontekst: Kontekst = TERAZ) -> Kawałek:
        """Rzecz, przecinek, zdanie o niej, a przecinek zamykający jako żądanie.

        Przypadek dostaje sama rzecz, bo to ona stoi w zdaniu nadrzędnym,
        a zdanie podrzędne rozdaje przypadki własne.
        Czas dostaje ono od ``podrzędne`` w ``olski/skład/powierzchnia.py``,
        a od tej metody to, którą rzecz ma powiedzieć zaimkiem.
        Pomijanie podmiotu w nim nie działa, i to nie jest brak:
        podmiot opuszczony w zdaniu podrzędnym czytałby się jako ten,
        którego zaimek właśnie zastąpił.

        Przecinek otwierający staje tutaj, bo stoi w środku tego kawałka,
        a zamykający zostaje żądaniem, bo stoi na jego krańcu
        i rozstrzyga o nim to, co obok stanie.
        """
        zdanie = replace(self.zdanie.linearyzuj(self.wewnątrz(kontekst)), przed=True)
        return replace(sklej([wypisz(self.rzecz, case, kontekst), zdanie]), po=True)

rzecz instance-attribute

zdanie instance-attribute

number property

rodzaj property

tożsamość property

__init__(rzecz, zdanie)

__post_init__()

Source code in olski/skład/składnia.py

def __post_init__(self) -> None:
    kontekst = Kontekst(wskazywany=self.rzecz)
    if not any(_wskazany(część, kontekst) for część in self.zdanie.konstytuenty):
        raise PozaRamą("zdanie opisujące nie stawia opisywanej rzeczy")

wewnątrz(kontekst)

Kontekst zdania opisującego: podrzędne wraz z rzeczą, którą ma wskazać.

Wydzielone z linearyzacji, bo pyta o to samo _zdania_pod, a bez tej rzeczy opis wychodziłby stamtąd zdaniem, w którym zaimka nie ma, czyli napisem, którego autor nie dostał.

Source code in olski/skład/składnia.py

def wewnątrz(self, kontekst: Kontekst) -> Kontekst:
    """Kontekst zdania opisującego: podrzędne wraz z rzeczą, którą ma wskazać.

    Wydzielone z linearyzacji, bo pyta o to samo ``_zdania_pod``,
    a bez tej rzeczy opis wychodziłby stamtąd zdaniem, w którym zaimka nie ma,
    czyli napisem, którego autor nie dostał.
    """
    return replace(kontekst.podrzędne(), wskazywany=self.rzecz)

linearyzuj(case, kontekst=TERAZ)

Rzecz, przecinek, zdanie o niej, a przecinek zamykający jako żądanie.

Przypadek dostaje sama rzecz, bo to ona stoi w zdaniu nadrzędnym, a zdanie podrzędne rozdaje przypadki własne. Czas dostaje ono od podrzędne w olski/skład/powierzchnia.py, a od tej metody to, którą rzecz ma powiedzieć zaimkiem. Pomijanie podmiotu w nim nie działa, i to nie jest brak: podmiot opuszczony w zdaniu podrzędnym czytałby się jako ten, którego zaimek właśnie zastąpił.

Przecinek otwierający staje tutaj, bo stoi w środku tego kawałka, a zamykający zostaje żądaniem, bo stoi na jego krańcu i rozstrzyga o nim to, co obok stanie.

Source code in olski/skład/składnia.py

def linearyzuj(self, case: str, kontekst: Kontekst = TERAZ) -> Kawałek:
    """Rzecz, przecinek, zdanie o niej, a przecinek zamykający jako żądanie.

    Przypadek dostaje sama rzecz, bo to ona stoi w zdaniu nadrzędnym,
    a zdanie podrzędne rozdaje przypadki własne.
    Czas dostaje ono od ``podrzędne`` w ``olski/skład/powierzchnia.py``,
    a od tej metody to, którą rzecz ma powiedzieć zaimkiem.
    Pomijanie podmiotu w nim nie działa, i to nie jest brak:
    podmiot opuszczony w zdaniu podrzędnym czytałby się jako ten,
    którego zaimek właśnie zastąpił.

    Przecinek otwierający staje tutaj, bo stoi w środku tego kawałka,
    a zamykający zostaje żądaniem, bo stoi na jego krańcu
    i rozstrzyga o nim to, co obok stanie.
    """
    zdanie = replace(self.zdanie.linearyzuj(self.wewnątrz(kontekst)), przed=True)
    return replace(sklej([wypisz(self.rzecz, case, kontekst), zdanie]), po=True)

forma_czasownika(czasownik, podmiot, kontekst)

Forma czasownika, którą ten podmiot z niego wyciąga.

Tędy idzie każde zdanie, bo zgodność z podmiotem jest jedna i nie zależy od tego, czy orzeka się czynność, czy bycie czymś. Tędy idzie też pytanie odwrotne, które stawia pomijalny: forma jest wszystkim, co po opuszczonym podmiocie zostaje, więc jest też miarą tego, czy da się go opuścić.

Zdanie, którego wykonawca przychodzi z góry, nie pyta o zgodność wcale. Bezokolicznik nie niesie ani osoby, ani rodzaju, ani czasu, bo wszystkie trzy niesie czasownik nad nim, i dlatego czasu nie ma tu czym uzgadniać ani po co.

Source code in olski/skład/składnia.py

def forma_czasownika(czasownik: str, podmiot: Rola, kontekst: Kontekst) -> str:
    """Forma czasownika, którą ten podmiot z niego wyciąga.

    Tędy idzie każde zdanie, bo zgodność z podmiotem jest jedna
    i nie zależy od tego, czy orzeka się czynność, czy bycie czymś.
    Tędy idzie też pytanie odwrotne, które stawia ``pomijalny``:
    forma jest wszystkim, co po opuszczonym podmiocie zostaje,
    więc jest też miarą tego, czy da się go opuścić.

    Zdanie, którego wykonawca przychodzi z góry, nie pyta o zgodność wcale.
    Bezokolicznik nie niesie ani osoby, ani rodzaju, ani czasu,
    bo wszystkie trzy niesie czasownik nad nim,
    i dlatego czasu nie ma tu czym uzgadniać ani po co.
    """
    if kontekst.sprawca is not None:
        return odmień(czasownik, "inf")
    pos, cechy = CZASY[kontekst.czas](podmiot)
    return odmień(czasownik, pos, **cechy)

szyk(pozycje)

Kolejność wypisania: czoło, środek w porządku domyślnym, koniec.

Środek jest tu porządkiem, którego nikt nie wybierał, więc zdanie bez żadnego wyróżnienia wychodzi w szyku podmiot, czasownik, reszta.

Wyróżnione miejsce bierze jeden konstytuent, bo na czele stoi jedna rzecz, więc drugi zgłasza się tak samo jak drugie dopełnienie w zdarzenie: dwa tematy naraz są drzewem błędnym, a nie zdaniem o dziwnym szyku. Zgłoszenie mówi o staniu, a nie o wyróżnieniu, bo część konstytuentów dostaje to miejsce od _miejsce i autor nie napisał przy nich znacznika.

Source code in olski/skład/składnia.py

def szyk(pozycje: list[tuple[str | None, Kawałek]]) -> Kawałek:
    """Kolejność wypisania: czoło, środek w porządku domyślnym, koniec.

    Środek jest tu porządkiem, którego nikt nie wybierał,
    więc zdanie bez żadnego wyróżnienia wychodzi w szyku podmiot, czasownik, reszta.

    Wyróżnione miejsce bierze jeden konstytuent, bo na czele stoi jedna rzecz,
    więc drugi zgłasza się tak samo jak drugie dopełnienie w ``zdarzenie``:
    dwa tematy naraz są drzewem błędnym, a nie zdaniem o dziwnym szyku.
    Zgłoszenie mówi o staniu, a nie o wyróżnieniu, bo część konstytuentów
    dostaje to miejsce od ``_miejsce`` i autor nie napisał przy nich znacznika.
    """
    wyróżnione: dict[str, Kawałek] = {}
    środek: list[Kawałek] = []
    for miejsce, kawałek in pozycje:
        if miejsce is None:
            środek.append(kawałek)
            continue
        if miejsce in wyróżnione:
            raise PozaRamą(f"dwa konstytuenty stają jako {miejsce}")
        wyróżnione[miejsce] = kawałek
    kolejność = (wyróżnione.get("czoło"), *środek, wyróżnione.get("koniec"))
    return sklej([część for część in kolejność if część is not None])

zdarzenie(kto, czyn, *reszta)

Zdarzenie złożone z tego, co dostało, po kategoriach, a nie po pozycjach.

Pierwszy argument jest tym, kto działa, i stoi zawsze. Reszta rozdziela się kategorią (_pole): okoliczności może być wiele, a uczestnik jest w każdej pozycji jeden, więc liczenie pozycji zostaje po tej stronie, a nie po stronie autora. Czasownik nieprzechodni składa się więc tak samo jak przechodni, a o pozycje pyta rama z leksykonu, którą sprawdza Robi.

Source code in olski/skład/składnia.py

def zdarzenie(kto, czyn: str, *reszta) -> Robi:
    """Zdarzenie złożone z tego, co dostało, po kategoriach, a nie po pozycjach.

    Pierwszy argument jest tym, kto działa, i stoi zawsze.
    Reszta rozdziela się kategorią (:func:`_pole`): okoliczności może być wiele,
    a uczestnik jest w każdej pozycji jeden,
    więc liczenie pozycji zostaje po tej stronie, a nie po stronie autora.
    Czasownik nieprzechodni składa się więc tak samo jak przechodni,
    a o pozycje pyta rama z leksykonu, którą sprawdza ``Robi``.
    """
    pola: dict[str, list] = {"co": [], "komu": [], "okoliczniki": []}
    for część in reszta:
        pola[_pole(_goły(część))].append(część)
    for nazwa in ("co", "komu"):
        if len(pola[nazwa]) > 1:
            raise PozaRamą(f"{czyn} dostaje {len(pola[nazwa])} uczestników w jednej pozycji")
    return Robi(
        kto=byt(kto),
        czyn=czyn,
        co=byt(pola["co"][0]) if pola["co"] else None,
        komu=pola["komu"][0] if pola["komu"] else None,
        okoliczniki=tuple(pola["okoliczniki"]),
    )

nie(zdanie)

To samo zdanie zaprzeczone.

Konstruktorem to nie jest, tylko zmianą jednej cechy zdania, bo zaprzeczone zdanie ma te same role co twierdzące i drugi konstruktor kazałby wypisać je jeszcze raz.

Sięga jednego orzeczenia, bo tyle znaczy nie w polszczyźnie, więc ciąg zdarzeń przeczy się zdarzenie po zdarzeniu, a nie w całości: Nie podniosła deski i nie zeszła po schodach.

Source code in olski/skład/składnia.py

def nie(zdanie: Jest | Robi) -> Jest | Robi:
    """To samo zdanie zaprzeczone.

    Konstruktorem to nie jest, tylko zmianą jednej cechy zdania,
    bo zaprzeczone zdanie ma te same role co twierdzące
    i drugi konstruktor kazałby wypisać je jeszcze raz.

    Sięga jednego orzeczenia, bo tyle znaczy ``nie`` w polszczyźnie,
    więc ciąg zdarzeń przeczy się zdarzenie po zdarzeniu,
    a nie w całości: `Nie podniosła deski i nie zeszła po schodach.`
    """
    return replace(zdanie, przeczenie=True)

pomijalny(zdanie, poprzednie, kontekst)

Podmiot, którego nie trzeba wypisywać, bo czytelnik odzyska go z czasownika.

Warunków jest cztery i każdy chroni przed inną stratą. Podmiot bez tożsamości nie jest tym samym podmiotem, tylko takim samym, a podmiot inny niż w zdaniu obok odsyła czytelnika do kogoś, o kim nie mowa. Podmiot opisany zdaniem przepada wraz z opisem, czyli wraz z tym, co autor o nim akurat powiedział, więc opuszczeniem to nie jest.

Czwarty warunek jest tym, którego reguła sama z siebie nie ma, a bez którego opuszczenie mówi co innego, niż mówił autor. Po opuszczonym podmiocie zostaje forma czasownika, więc podmiot wraca stamtąd tylko wtedy, gdy nikt inny tej samej formy z tego czasownika nie wyciąga. Skrzynia stojąca w piwnicy odbiera córce krawca rodzaj żeński, a bazyliszek odbiera czeladnikowi rodzaj męski, i wtedy podmiot staje wypisany, choć zdanie obok mówiło o tym samym. Liczone jest to tym samym czasownikiem, który podmiotu nie wypisze, bo różnice, których on nie robi, nie są różnicami dla czytelnika: czas przeszły rozdziela rodzaje, a teraźniejszy nie rozdziela żadnego.

Source code in olski/skład/składnia.py

def pomijalny(zdanie: Zdanie, poprzednie: Zdanie | None, kontekst: Kontekst):
    """Podmiot, którego nie trzeba wypisywać, bo czytelnik odzyska go z czasownika.

    Warunków jest cztery i każdy chroni przed inną stratą.
    Podmiot bez tożsamości nie jest tym samym podmiotem, tylko takim samym,
    a podmiot inny niż w zdaniu obok odsyła czytelnika do kogoś, o kim nie mowa.
    Podmiot opisany zdaniem przepada wraz z opisem, czyli wraz z tym,
    co autor o nim akurat powiedział, więc opuszczeniem to nie jest.

    Czwarty warunek jest tym, którego reguła sama z siebie nie ma,
    a bez którego opuszczenie mówi co innego, niż mówił autor.
    Po opuszczonym podmiocie zostaje forma czasownika, więc podmiot wraca stamtąd
    tylko wtedy, gdy nikt inny tej samej formy z tego czasownika nie wyciąga.
    Skrzynia stojąca w piwnicy odbiera córce krawca rodzaj żeński,
    a bazyliszek odbiera czeladnikowi rodzaj męski,
    i wtedy podmiot staje wypisany, choć zdanie obok mówiło o tym samym.
    Liczone jest to tym samym czasownikiem, który podmiotu nie wypisze,
    bo różnice, których on nie robi, nie są różnicami dla czytelnika:
    czas przeszły rozdziela rodzaje, a teraźniejszy nie rozdziela żadnego.
    """
    podmiot = zdanie.podmiot
    tożsamość = podmiot.tożsamość
    if tożsamość is None or poprzednie is None:
        return None
    if poprzednie.podmiot.tożsamość is not tożsamość or isinstance(podmiot, Opis):
        return None
    forma = forma_czasownika(zdanie.czasownik, podmiot, kontekst)
    mylące = (
        rola
        for rola in (*poprzednie.podmioty, *zdanie.podmioty)
        if rola.tożsamość is not tożsamość
    )
    if any(forma_czasownika(zdanie.czasownik, rola, kontekst) == forma for rola in mylące):
        return None
    return tożsamość

po_poprzednim(zdanie, poprzednie, kontekst)

Kontekst zdania stojącego za poprzednim, czyli z podmiotem opuszczonym albo nie.

Pytają o to trzy miejsca i muszą dostać tę samą odpowiedź: akapit i ciąg zdarzeń, bo z tego składają tekst, oraz odsiew olski/skład/makieta.py, bo pyta o zdanie, które akapit dopiero złoży. Trzy kopie tego jednego wiersza rozjechałyby się na pierwszym warunku dopisanym do pomijalny wyżej, a odsiew mierzyłby wtedy inny tekst, niż akapit potem wypisze.

Source code in olski/skład/składnia.py

def po_poprzednim(zdanie: Zdanie, poprzednie: Zdanie | None, kontekst: Kontekst) -> Kontekst:
    """Kontekst zdania stojącego za poprzednim, czyli z podmiotem opuszczonym albo nie.

    Pytają o to trzy miejsca i muszą dostać tę samą odpowiedź:
    akapit i ciąg zdarzeń, bo z tego składają tekst,
    oraz odsiew ``olski/skład/makieta.py``, bo pyta o zdanie, które akapit dopiero złoży.
    Trzy kopie tego jednego wiersza rozjechałyby się na pierwszym warunku
    dopisanym do ``pomijalny`` wyżej, a odsiew mierzyłby wtedy inny tekst,
    niż akapit potem wypisze.
    """
    return replace(kontekst, pomijany=pomijalny(zdanie, poprzednie, kontekst))

kompiluj(drzewo, kontekst=TERAZ)

Drzewo jako zdanie: wielka litera na początku i kropka na końcu.

Wielkość litery należy do składu, a nie do lematu, bo ta sama rzecz stoi raz na początku zdania, a raz w jego środku.

Przecinek, którego żądają krańce zdania, nie staje nigdzie, bo z jednej strony stoi kropka, a z drugiej nie stoi nic. Odjąć go stąd nie ma czego: żądanie krańca jest polem Kawałek, a nie znakiem doklejonym do napisu.

Source code in olski/skład/składnia.py

def kompiluj(drzewo, kontekst: Kontekst = TERAZ) -> str:
    """Drzewo jako zdanie: wielka litera na początku i kropka na końcu.

    Wielkość litery należy do składu, a nie do lematu,
    bo ta sama rzecz stoi raz na początku zdania, a raz w jego środku.

    Przecinek, którego żądają krańce zdania, nie staje nigdzie,
    bo z jednej strony stoi kropka, a z drugiej nie stoi nic.
    Odjąć go stąd nie ma czego: żądanie krańca jest polem ``Kawałek``,
    a nie znakiem doklejonym do napisu.
    """
    tekst = drzewo.linearyzuj(kontekst).napis
    return f"{tekst[0].upper()}{tekst[1:]}."