Witaj
- User
Witaj
Assistant
Witaj! Jak mogę Ci pomóc?
- User
Chciałbym stworzyć własny memowy język programowania "PL" z rozszerzeniem .pl. Jakbyś się za to zabrał?
Assistant
Świetny pomysł! Stworzenie "memowego" języka programowania to fantastyczny projekt, który łączy kreatywność, programowanie i poczucie humoru. Nazwa "PL" i rozszerzenie ".pl" są genialne – proste, polskie i od razu rozpoznawalne.
Jak bym się za to zabrał? Podzieliłbym to na kilka faz:
Faza 1: Koncepcja i Projektowanie (Memowa Dusza Języka)
To najważniejsza faza, bo tutaj nadajesz językowi jego unikalny charakter.
-
Filozofia i Wizja "PL":
- Cel: Czy to ma być język do szybkiego tworzenia memów? A może język, który sam w sobie jest memem, używając polskiego humoru i specyfiki? Skłaniałbym się ku temu drugiemu.
- Główne inspiracje memowe/polskie: Janusze, Grażyny, Pjoter, złoty polski chłopski rozum, "kurła", cebula, schabowy, pierogi, narzekanie, "dej", "dej mi plusa", "nie zesraj się", "było/nie było", "działa/nie działa", "a po co to komu?".
- Poziom skomplikowania: Na początek – bardzo niski. Język skryptowy, interpretowany.
- Paradygmat: Imperatywny, proceduralny. Może z odrobiną obiektowości, ale nazwanej memowo (np.
obiekt Janusz {}).
-
Składnia (Syntax) - Kluczowe Słowa (Keywords):
- Zmienne: Zamiast
var,let,const, można użyć:zmienna(np.zmienna moja_cebula to 5)słoik(na coś co ma stać na stałe, jak zapasy na zimę:słoik kasa_janusza to 1000)tekst(dla stringów:tekst imie_pjotera to "Pjoter")liczba(dla liczb:liczba wiek_grazyny to 40)prawda/fałsz(boolean:prawda czy_prawda to prawda)
- Warunki (If/Else):
jesli(if):jesli pieniadze_sa > 0 wtedyalbo_jak_nie(elif/else if):albo_jak_nie pieniadze_sa == 0 wtedyinaczej(else):inaczej wtedykoniec_sprawdzania(end if)
- Pętle (Loops):
dopoki(while):dopoki janusz_mysli prawdadla_kazdego(for each):dla_kazdego mem z memy_internetupowtarzaj(repeat N times):powtarzaj 5 razykoniec_petli(end loop)
- Funkcje/Procedury:
robota(function/procedure declaration):robota zrob_bigos(skladniki)wykonaj(call function):wykonaj zrob_bigos(cebula, kapusta)oddaj(return):oddaj schabowykoniec_roboty(end function)
- Wyjście/Wejście (I/O):
powiedzwypisz(print):powiedzwypisz "Kurła, działa!"zapytaj(input):zapytaj "Ile cebuli kupić?", ilosc_cebuli
- Komentarze:
# ChlopskiRozum: ...(jednoliniowy)/* ZloteMysli: ... */(wieloliniowy)
- Koniec bloku/programu:
amen(do zamknięcia bloków lub całego programu)koniec
- Zmienne: Zamiast
-
Semantyka (Co Kod Robi):
- Jak działają operatory (
+,-,*,/-dodaj,odejmij,pomnoz,podziel?). - Jak działa konkatenacja stringów (np.
tekst1 + tekst2czysklej(tekst1, tekst2)a możetekst1 kiełbasa tekst2)? - Jak obsługiwać błędy (np. wyjątki)? Może
kurla_bladalboawaria_na_placie_zabaw?
- Jak działają operatory (
-
System Typów:
- Na początek dynamiczny (jak w Pythonie/JavaScript). Nie deklarujesz typu, interpreter sam go zgaduje.
- Podstawowe typy:
liczba(integer/float),tekst(string),prawda/fałsz(boolean),nic(null/None). - Może
pierogi(listy/tablice),bigos(mapy/słowniki).
-
Funkcje Standardowe (Wbudowane "Memowe" Funkcje):
janusz_mysli(co_mysli): Może to funkcja, która "myśli" przez chwilę (delay) i wyświetlaco_mysli.grazyna_krzyczy(tekst): Wyświetla tekst wielkimi literami.pjoter_uciekaj(ile_szybko): Może to funkcja do szybkiego wyjścia z programu lub do przerwania pętli.narzekaj(na_co): Wyświetla losowe narzekanie nana_co.dej(co_dej, ile): Żąda czegoś (np. od użytkownika, lub od innej funkcji).bylo_nie_bylo(fakt): Sprawdza, czy coś miało miejsce.
-
Komunikaty o Błędach (Bardzo Memowe!):
- Błąd składni: "Kurła, tu brakuje cebuli!" "To nie jest składnia na miarę Janusza, popraw!" "Zapomniałeś o amen na koniec bloku!"
- Błąd wykonania: "Ups, program poszedł na wódkę i nie wrócił." "Wyjątek: Zbyt mały parking dla tej zmiennej!" "Błąd: Zderzenie na autostradzie typów!"
- Błąd logiczny: "Chłopski Rozum zawiódł w tym miejscu." "To nie jest rozsądne, nawet dla Grażyny!"
Faza 2: Implementacja (Od Koncepcji do Działającego Kodu)
Do implementacji polecam Pythona. Jest prosty, ma świetne biblioteki do parsowania i szybko można coś w nim zbudować.
-
Wybór Języka Implementacji:
- Python: Idealny ze względu na prostotę, dostępność bibliotek do budowy parserów (np.
PLY- Python Lex-Yacc,parsy,textxa nawet ręczne parsowanie).
- Python: Idealny ze względu na prostotę, dostępność bibliotek do budowy parserów (np.
-
Etapy Budowy Interpretera:
-
a) Lexer (Skaner/Tokenizator):
- Jego zadaniem jest wzięcie surowego kodu
.pli podzielenie go na "tokeny" – najmniejsze, znaczące jednostki języka (słowa kluczowe, identyfikatory, liczby, operatory, stringi itp.). - Przykład:
zmienna moj_portfel to 50 amen- Tokeny:
(ZMIENNA, "zmienna"),(IDENTYFIKATOR, "moj_portfel"),(TO, "to"),(LICZBA, "50"),(AMEN, "amen").
- Tokeny:
- Możesz to zrobić ręcznie (prostymi regexami) lub użyć
PLY(biblioteka do Pythona).
- Jego zadaniem jest wzięcie surowego kodu
-
b) Parser (Analizator Składniowy):
- Bierze strumień tokenów z lexera i sprawdza, czy ich kolejność jest zgodna z regułami gramatyki "PL".
- Buduje wewnętrzną reprezentację kodu, często w postaci Drzewa Składni Abstrakyjnej (AST - Abstract Syntax Tree). AST to hierarchiczna struktura, która reprezentuje kod programu w sposób, który łatwo jest później interpretować.
- Przykład: Dla
zmienna x to 10AST mógłby wyglądać tak:DeklaracjaZmiennej ├── Nazwa: "x" └── Wartość: Literał(10) - Również możesz użyć
PLYlub napisać prosty parser rekurencyjny (Recursive Descent Parser). Dla "memowego" języka, może ręczne podejście będzie bardziej "chłopskorozumne".
-
c) Interpreter/Evaluator:
- Przechodzi przez AST i wykonuje operacje, które reprezentuje każdy węzeł.
- Na przykład, gdy interpreter napotka węzeł
DeklaracjaZmiennej, doda zmienną do "środowiska" (czyli do słownika trzymającego nazwy zmiennych i ich wartości). Gdy napotka węzełPrint, wywoła funkcjępowiedzwypisz. - Będziesz potrzebował czegoś do przechowywania stanu programu – środowiska (variables, functions, scope). To może być po prostu słownik w Pythonie, np.
{'moj_portfel': 50}.
-
-
Tworzenie Pliku Wykonywalnego (Runner):
- Prosty skrypt Pythona, który przyjmuje ścieżkę do pliku
.pljako argument, czyta go, przekazuje do lexera, następnie do parsera, a na końcu do interpretera. - Możesz też stworzyć prosty REPL (Read-Eval-Print Loop), czyli interaktywną konsolę "PL", gdzie użytkownik wpisuje kod linijka po linijce i od razu widzi wynik (coś jak terminal Pythona). Nazwałbym to
piwnica_programistylubkolo_gospodyń_programistycznych.
- Prosty skrypt Pythona, który przyjmuje ścieżkę do pliku
Faza 3: Testowanie i Dokumentacja
-
Testy:
- Pisanie małych programów w "PL", które testują każdą funkcjonalność.
- "Hello World" w PL:
robota glowna_robota() powiedzwypisz "Witaj swiecie! Kurła, działa!" koniec_roboty wykonaj glowna_robota() amen - Testowanie warunków:
zmienna kasa_janusza to 100 jesli kasa_janusza > 50 wtedy powiedzwypisz "Piwo bedzie!" albo_jak_nie kasa_janusza == 50 wtedy powiedzwypisz "Na jedno starczy." inaczej wtedy powiedzwypisz "Trzeba isc na fuszkę." koniec_sprawdzania amen
-
Dokumentacja:
- "Chłopski Rozum: Podręcznik Języka PL"
- Opisz składnię, wszystkie słowa kluczowe, wbudowane funkcje, system typów.
- Dodaj przykłady kodu i wyjaśnij, co robią.
- Przedstaw "filozofię" języka i jak ma pomagać w "memowym" myśleniu.
- Sekcja "Kurła, Błędy!" z objaśnieniami i przykładami memowych komunikatów.
Faza 4: Rozwój i Społeczność (Opcjonalnie, na później)
-
Dodatkowe Funkcjonalności:
- Moduły (
skrzynka_narzedziowa,januszowe_algorytmy). - Wsparcie dla obiektowości (
janusz Obiekt {}). - Obsługa plików (
czytaj_ze_stodoly,zapisz_do_chlewu). - Grafika (może coś bardzo prostego, "malowane_farbkami_pod_blokiem").
- Moduły (
-
Narzędzia Deweloperskie:
- Podświetlanie składni dla edytorów kodu (VS Code extension?).
- Debuger (nazwany np.
gdzie_zgubilem_klucze_do_malucha).
-
Społeczność:
- Umieść projekt na GitHubie.
- Zachęć innych do współtworzenia memów, słów kluczowych i funkcji.
To będzie świetna zabawa! Pamiętaj, żeby zacząć od minimalnego działającego zestawu funkcji (np. tylko zmienne i
powiedzwypisz), a potem stopniowo dodawać kolejne. Powodzenia i niech Cię Chłopski Rozum prowadzi!-
- User
W czym najlepiej stworzyć interpreter?
Assistant
Świetne pytanie! Wybór narzędzi do stworzenia interpretera zależy od kilku czynników: Twojego doświadczenia, celów projektu (czy to ma być tylko zabawny eksperyment, czy coś bardziej rozbudowanego?), oraz preferencji.
Biorąc pod uwagę, że to "memowy" język, stawiałbym na łatwość implementacji, szybkość prototypowania i dostępność dobrych bibliotek do parsowania.
Oto najlepsze opcje i dlaczego:
1. Python (Najbardziej Polecam)
Dlaczego jest najlepszy dla tego projektu:
- Łatwość i szybkość rozwoju: Python jest niezwykle czytelny i pozwala na bardzo szybkie pisanie kodu. To idealne do eksperymentowania z memową składnią i funkcjami.
- Wbudowane typy danych: Słowniki (dictionaries) w Pythonie są idealne do przechowywania zmiennych, funkcji i zarządzania zakresem (scope) w interpreterze. Listy świetnie nadają się do reprezentacji AST (Abstract Syntax Tree) lub stosu.
- Bogactwo bibliotek do parsowania: To jest kluczowe! Python ma kilka doskonałych bibliotek, które znacznie ułatwiają proces tokenizacji (lexing) i parsowania (parsing):
- PLY (Python Lex-Yacc): Klasyka gatunku. Implementacja narzędzi Lex i Yacc w Pythonie. Bardzo potężne i elastyczne, choć wymaga nauki składni podobnej do BNF.
- Lark: Bardziej nowoczesna i często łatwiejsza w użyciu niż PLY. Obsługuje wiele algorytmów parsowania (LL, LR, LALR) i automatycznie buduje drzewo AST. Polecam, jeśli chcesz szybko zacząć.
- textx: Język do definiowania języków. Pozwala zdefiniować gramatykę, a textx wygeneruje parser i model AST. Świetne do Domain Specific Languages (DSL).
- Parsy: Lekka, kombinatoryczna biblioteka do parsowania, dobra do mniejszych gramatyk.
- Łatwość debugowania: Python ma dobre narzędzia do debugowania, co jest ważne podczas budowania czegoś tak złożonego jak interpreter.
- Czytelność AST: Drzewa AST zbudowane w Pythonie (np. jako zagnieżdżone listy lub obiekty) są intuicyjne i łatwe do traversowania w fazie interpretacji.
Podejście w Pythonie:
- Lexer: Zdefiniuj tokeny za pomocą
PLYlubLark, albo napisz prosty lexer ręcznie (np. używając wyrażeń regularnych). - Parser: Zdefiniuj gramatykę języka PL za pomocą
PLYlubLark. Parser przetworzy strumień tokenów na AST. - Interpreter: Napisz funkcję, która rekurencyjnie przechodzi przez węzły AST i wykonuje odpowiednie operacje (np.
ifdla warunków,fordla pętli, aktualizuje słownik zmiennych).
2. JavaScript / Node.js (Bardzo Dobra Alternatywa)
Dlaczego jest dobrą opcją:
- Podobne zalety do Pythona: JavaScript (w środowisku Node.js) również oferuje szybkie prototypowanie, łatwą obsługę stringów i obiektów (idealne do AST i środowiska).
- Znajomość: Jeśli jesteś programistą webowym, JavaScript może być dla Ciebie bardziej naturalnym wyborem.
- Dostępne biblioteki:
- Jison / Nearley: Narzędzia podobne do Lex/Yacc, ale dla JavaScriptu.
- Chevrotain: Szybka biblioteka do parsowania, która pozwala definiować gramatyki w kodzie JS.
- Ohm.js: Interesująca biblioteka do tworzenia gramatyk i operacji na AST.
- REPL: Łatwo stworzyć interaktywną konsolę (REPL) dla języka PL.
3. Go (Dobra opcja, jeśli szukasz czegoś "kompilowanego")
Dlaczego warto rozważyć:
- Prostota i wydajność: Go jest językiem kompilowanym, ale jego składnia jest stosunkowo prosta i intuicyjna. Oferuje dobrą wydajność.
- Łatwe pakowanie: Możesz łatwo skompilować swój interpreter do pojedynczego pliku wykonywalnego, co ułatwia dystrybucję "PL".
- Silne typowanie: Może pomóc w łapaniu błędów na etapie kompilacji, choć dla "memowego" języka na początku nie jest to priorytetem.
- Wbudowane pakiety: Pakiety
text/scannerigo/parser(dla parsowania kodu Go, ale można je adaptować) lub pisanie parsera rekurencyjnego jest stosunkowo proste w Go. Brak jest tak rozwiniętych parser-generatorów jak w Pythonie, ale pisanie ręczne jest bardzo wykonalne.
Języki, których unikałbym na początek dla tego projektu:
- C / C++: Niezwykle potężne i wydajne, ale:
- Duża złożoność: Ręczne zarządzanie pamięcią, wskaźniki, a także konieczność implementowania wszystkiego od zera (lub używania Lex/Yacc/Bison, które mają bardziej stromą krzywą uczenia) sprawiają, że rozwój jest znacznie wolniejszy.
- Niepotrzebna optymalizacja: Dla memowego języka wydajność nie jest priorytetem, a czas poświęcony na optymalizację lepiej zainwestować w tworzenie zabawnych funkcji.
- Java / C#: Chociaż są to dojrzałe języki z wieloma narzędziami:
- Bardziej "sztywne": Wymagają więcej boilerplate'u i są bardziej rygorystyczne w typowaniu, co może spowolnić eksperymentowanie.
- Złożoność środowiska: Uruchamianie JVM/CLR i cały ekosystem może być bardziej rozbudowany niż prosty skrypt Pythona/Node.js.
Podsumowanie:
Jeśli zależy Ci na szybkim rozwoju, łatwości pisania i dostępności najlepszych bibliotek do parsowania, zdecydowanie polecam Pythona. Jest to najczęstszy wybór do budowy własnych języków, zwłaszcza na początek i dla celów edukacyjnych/hobbystycznych.
Niezależnie od wyboru języka, kluczowe jest podejście iteracyjne:
- Zaimplementuj bardzo mały podzbiór języka (np. tylko zmienne i
powiedzwypisz). - Upewnij się, że działa.
- Dodawaj kolejne elementy (warunki, pętle, funkcje) krok po kroku.
Powodzenia w tworzeniu "PL"! To będzie super projekt!
- User
daj mi przykład dobrej bilioteki pod pythona do parsowania własnego języka i zamiany go na kod
Assistant
Absolutnie! Do parsowania własnego języka w Pythonie i zamiany go na kod (w tym przypadku, na akcje wykonawcze, czyli interpretację), biblioteka Lark jest fantastycznym wyborem. Jest łatwa w użyciu, elastyczna i świetnie radzi sobie z budowaniem Drzew Składni Abstrakyjnej (AST), które potem łatwo przetwarzać.
Dlaczego Lark?
- Łatwa gramatyka: Pozwala zdefiniować gramatykę języka w czytelnym formacie EBNF (Extended Backus–Naur Form).
- Automatyczne budowanie AST: Po sprasowaniu kodu źródłowego, Lark automatycznie tworzy drzewo AST, które jest świetną reprezentacją struktury kodu.
- Transformer: To jest klucz do "zamiany na kod". Lark posiada potężny mechanizm
Transformer, który pozwala przejść przez drzewo AST i wykonać na każdym węźle odpowiednie akcje – to właśnie tutaj zaimplementujesz logikę swojego interpretera.
Przykład: Prosty język "PL"
Zbudujmy bardzo prosty podzbiór Twojego języka "PL", który będzie potrafił:
- Deklarować zmienne (
zmienna X to Y). - Wypisywać tekst lub wartość zmiennej (
powiedzwypisz "tekst"lubpowiedzwypisz zmienna). - Wykonywać proste operacje arytmetyczne (
dodaj,odejmij).
1. Instalacja Lark
pip install lark
2. Definicja Gramatyki Języka "PL"
Utwórz plik
pl_grammar.lark(lub po prostu wklej do kodu Pythona):// pl_grammar.lark start: statement+ statement: declaration | print_statement | expression -> expression_statement // Aby wyrażenia mogły być osobnymi statementami declaration: "zmienna" IDENTIFIER "to" expression -> var_declaration print_statement: "powiedzwypisz" (STRING | IDENTIFIER | expression) -> print_stmt // Prosta arytmetyka expression: term ( ( "dodaj" | "odejmij" ) term )* term: factor ( ( "pomnoz" | "podziel" ) factor )* factor: NUMBER // Liczby | IDENTIFIER // Zmienne | "(" expression ")" // Wyrażenia w nawiasach // Podstawowe tokeny (zdefiniowane za pomocą regex) IDENTIFIER: /[a-zA-Z_][a-zA-Z0-9_]*/ NUMBER: /\d+(\.\d+)?/ STRING: /"([^"\\]|\\.)*"/ // Ignorowane elementy (np. spacje, komentarze) %ignore /\s+/ %ignore "#".* // Komentarze zaczynające się od #Wyjaśnienie Gramatyki:
start: Program składa się z jednego lub więcejstatement(instrukcji).statement: Może być deklaracją, instrukcją wypisywania lub wyrażeniem.declaration: Słowozmienna, potemIDENTIFIER(nazwa zmiennej),toiexpression(wartość).-> var_declarationto alias, który Lark użyje jako nazwę węzła w AST.print_statement: Słowopowiedzwypisz, a potemSTRING,IDENTIFIERlubexpression.expression,term,factor: Definiują hierarchię operacji arytmetycznych (kolejność wykonywania).IDENTIFIER,NUMBER,STRING: Definicje tokenów za pomocą wyrażeń regularnych.%ignore: Określa elementy, które parser powinien zignorować (np. białe znaki, komentarze).
3. Interpreter w Pythonie z użyciem Lark Transformer
Teraz napiszemy interpreter, który wykorzysta gramatykę i przetworzy AST.
from lark import Lark, Transformer, v_args # --- 1. Definicja Gramatyki --- # Zamiast wczytywać z pliku, umieścimy ją bezpośrednio w kodzie dla prostoty. pl_grammar = r""" start: statement+ statement: declaration | print_statement | expression -> expression_statement // Aby wyrażenia mogły być osobnymi statementami declaration: "zmienna" IDENTIFIER "to" expression -> var_declaration print_statement: "powiedzwypisz" (STRING | IDENTIFIER | expression) -> print_stmt // Prosta arytmetyka - pamiętaj o kolejności wykonywania działań! expression: term ( ( "dodaj" | "odejmij" ) term )* term: factor ( ( "pomnoz" | "podziel" ) factor )* factor: NUMBER | IDENTIFIER | "(" expression ")" // Podstawowe tokeny IDENTIFIER: /[a-zA-Z_][a-zA-Z0-9_]*/ NUMBER: /\d+(\.\d+)?/ STRING: /"([^"\\]|\\.)*"/ // Ignorowane elementy %import common.WS %import common.NEWLINE %ignore WS %ignore NEWLINE %ignore "#".* // Komentarze """ # --- 2. Interpreter/Transformer --- # Użyjemy dekoratora v_args(inline=True) aby argumenty metod były spłaszczone # (zamiast pojedynczej listy dzieci, dostajemy poszczególne argumenty) @v_args(inline=True) class PLInterpreter(Transformer): def __init__(self): # Środowisko do przechowywania zmiennych self.variables = {} def start(self, *statements): # Wykonaj każdą instrukcję po kolei for stmt in statements: if isinstance(stmt, tuple) and stmt[0] == 'print': # Sprawdź, czy to wynik print_stmt # print_stmt już wykonał swoje zadanie, nie potrzebujemy nic robić z jego wynikiem pass elif stmt is not None: # Możemy tu coś zrobić z wynikami wyrażeń, ale na razie je ignorujemy pass def var_declaration(self, name, value): # Deklaracja zmiennej: zapisz nazwę i wartość w środowisku self.variables[str(name)] = value # print(f"DEBUG: Zmienna {name} ustawiona na {value}") # Do debugowania def print_stmt(self, value): # Instrukcja wypisywania: if isinstance(value, str) and value.startswith('"') and value.endswith('"'): # Jeśli to literał string, usuń cudzysłowy print(value[1:-1]) elif str(value) in self.variables: # Jeśli to identyfikator, wypisz wartość zmiennej print(self.variables[str(value)]) elif isinstance(value, (int, float)): # Jeśli to liczba z expression print(value) else: # Jeśli to złożone wyrażenie, które już zostało obliczone print(value) return ('print', value) # Zwracamy tuple by zasygnalizować, że to print. Nie będzie użyte przez 'start' ale może być przydatne. # Operacje arytmetyczne def expression_statement(self, expr): # Gdy wyrażenie jest samodzielnym statementem, po prostu je obliczamy. # Możesz tu dodać np. wyświetlanie wyniku, jeśli chcesz. # print(f"DEBUG: Wynik wyrażenia: {expr}") return expr # Zwracamy wynik, ale start go nie używa def expression(self, first_term, *rest): result = first_term for op, next_term in zip(rest[::2], rest[1::2]): if op == 'dodaj': result += next_term elif op == 'odejmij': result -= next_term return result def term(self, first_factor, *rest): result = first_factor for op, next_factor in zip(rest[::2], rest[1::2]): if op == 'pomnoz': result *= next_factor elif op == 'podziel': if next_factor == 0: raise ValueError("Kurła, dzielenie przez zero to fuszerka!") result /= next_factor return result # Konwersja tokenów liści do typów Pythona def NUMBER(self, token): # Sprawdzamy, czy to liczba całkowita czy zmiennoprzecinkowa if '.' in token: return float(token) return int(token) def STRING(self, token): # Stringi w Lark są zwracane z cudzysłowami, usuwamy je return str(token) def IDENTIFIER(self, token): # Gdy identyfikator jest używany w wyrażeniu (np. 'x dodaj 5'), # próbujemy odczytać jego wartość ze środowiska. name = str(token) if name in self.variables: return self.variables[name] else: raise ValueError(f"Kurła, zmienna '{name}' nie istnieje! Co to za chłopski rozum?") # --- 3. Funkcja uruchamiająca interpreter --- def run_pl_code(code): # Utwórz parser zdefiniowany w gramatyce parser = Lark(pl_grammar, start='start', parser='lalr', propagate_positions=False) try: # Sparsuj kod na drzewo AST tree = parser.parse(code) # print("DEBUG: AST Tree:") # Możesz odkomentować, aby zobaczyć AST # print(tree.pretty()) # Utwórz instancję interpretera i przekształć drzewo (czyli wykonaj kod) interpreter = PLInterpreter() interpreter.transform(tree) except Exception as e: print(f"Awaria na placu zabaw! Błąd: {e}") # --- Przykładowy kod w języku PL --- pl_code_example = """ # To jest memowy język PL, kurła! zmienna moja_cebula to 10 zmienna stawka to 2.5 zmienna kasa_janusza to moja_cebula pomnoz stawka powiedzwypisz "Witaj swiecie! Kurla, dziala!" powiedzwypisz moja_cebula powiedzwypisz kasa_janusza zmienna wynik_dodawania to 5 dodaj 3 powiedzwypisz wynik_dodawania zmienna trudne_obliczenie to (10 dodaj 5) podziel 3 odejmij 1 powiedzwypisz trudne_obliczenie powiedzwypisz "Sprawdzamy co sie dzieje!" zmienna pusta_kasa to 0 # powiedzwypisz nieistniejaca_zmienna # To wywoła błąd, możesz odkomentować """ # Uruchomienie przykładu print("--- Uruchamiam kod PL ---") run_pl_code(pl_code_example) print("--- Koniec działania kodu PL ---") # Przykład z błędem dzielenia przez zero print("\n--- Uruchamiam kod PL z błędem dzielenia przez zero ---") error_code_example = """ zmienna zero_test to 0 zmienna blad to 10 podziel zero_test powiedzwypisz blad """ run_pl_code(error_code_example)
Jak to działa?
pl_grammar: To jest definicja języka. Mówi Larkowi, jakie tokeny są legalne (np.IDENTIFIER,NUMBER) i jak te tokeny łączą się, tworząc legalne instrukcje (np.declaration,print_statement).Lark(pl_grammar, ...): Tworzy instancję parsera, który będzie rozumiał Twoją gramatykę.parser.parse(code): Parser bierze Twój kod PL (jako string) i, jeśli jest zgodny z gramatyką, buduje z niegolark.Tree(AST). Każdy węzeł w tym drzewie odpowiada regule gramatyki.PLInterpreter(Transformer): To jest serce Twojego interpretera. Dziedziczy polark.Transformer.- Metody (
var_declaration,print_stmt,expressionitp.): Lark automatycznie wywołuje odpowiednią metodę w TwoimTransformerzedla każdego węzła w drzewie AST, gdy przetwarza go od dołu do góry (od liści do korzenia). @v_args(inline=True): Upraszcza podpisy metod, przekazując dzieci węzła jako bezpośrednie argumenty, a nie jako pojedynczą listę.self.variables: To słownik, który pełni rolę "środowiska" Twojego języka. Przechowuje wartości zadeklarowanych zmiennych.- Logika: W każdej metodzie definiujesz, co ma się stać, gdy interpreter napotka dany typ instrukcji/wyrażenia. Np. dla
var_declarationdodaje zmienną doself.variables, a dlaprint_stmtdrukuje wartość.
- Metody (
interpreter.transform(tree): To magiczna linijka, która uruchamia proces interpretacji. Lark przechodzi przez AST i wywołuje odpowiednie metodyTransformera, efektywnie "wykonując" Twój kod PL.
Co dalej?
To tylko bardzo podstawowy przykład. Możesz rozbudować "PL" o wiele więcej funkcji:
- Warunki (
jesli...wtedy...inaczej): Dodaj reguły gramatyczne i odpowiednie metody wPLInterpreterdo obsługiif/else. - Pętle (
dopoki...,dla_kazdego...): Podobnie, dodaj reguły i logikę pętli. - Funkcje (
robota...): Będziesz potrzebował bardziej zaawansowanego zarządzania zakresem (scopes) dla funkcji. Możesz użyć stosu słowników dlaself.variableslub stworzyć oddzielne obiektyScope. - Wbudowane funkcje memowe:
narzekaj(),dej(),janusz_mysli()– dodaj je jako regularne funkcje w interpreterze, które będą wywoływać odpowiedni kod Pythona. - Bardziej memowe komunikaty o błędach: Rozszerz obsługę błędów w
Transformerze, aby były bardziej humorystyczne.
Lark to świetne narzędzie do tego typu projektu, ponieważ pozwala skupić się na semantyce języka (co robić) zamiast na niskopoziomowych detalach parsowania. Powodzenia w tworzeniu Twojego memowego języka "PL"!
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.
Identical first prompt
claude-3-7-sonnet-20250219Compare side by side →
llama-4-maverick-03-26-experimentalCompare side by side →
- gpt-4.1-2025-04-14Compare side by side →
gemini-2.5-flash-preview-04-17Compare side by side →
deepseek-v3-0324Compare side by side →
deepseek-r1-0528Compare side by side →
claude-sonnet-4-20250514-thinking-32kCompare side by side →
llama-4-maverick-03-26-experimentalCompare side by side →
- chatgpt-4o-latest-20250326Compare side by side →
- o3-2025-04-16Compare side by side →
gemma-3-27b-itCompare side by side →