Corak Pengaturcaraan Meta Runtime dalam Python ini Menarik

Latar belakang

Saya sedang mengusahakan rangka kerja UI yang dibina di atas Pyodide, yang dipanggil Zenaura. Baru-baru ini, saya perhatikan bahawa antara muka pembina — cara utama pengguna mencipta elemen UI — agak terlalu rumit dan tidak menarik. Walaupun ia mengabstrakkan antara muka asas yang lebih rumit untuk berinteraksi dengan struktur data "Nod" DOM ​​maya Zenaura, ia masih tidak memuaskan. Saya ingin memudahkan perkara dan memberikan pengguna pengalaman yang lebih bersih, lebih intuitif, sambil meletakkan asas untuk berpotensi membangunkan pengkompil untuk sintaks yang benar-benar baharu. Sesuatu seperti ini:

div(attr1=val1, child1, child2, child3)

Pernyataan Masalah

Antara muka pembina semasa terlalu tahap rendah dan tidak mesra pengguna. Pengguna seharusnya tidak perlu berinteraksi dengan sesuatu seperti ini:

builder = Builder(name__)
if children:
    builder.with_children(*children)
if attributes:
    builder.with_attributes(**attributes)
if text:
    builder.with_text(text)
# print("data", builder.node.children, builder.node.attributes)
return builder.build()

Sebaliknya, mereka sepatutnya boleh menggunakan sintaks yang lebih bersih dan mudah dibaca seperti:

div(id="some-id", h1("text"), p("text"))

Melihat pada dokumen MDN, terdapat 91 teg HTML, dengan kemungkinan penambahan atau penamatan. Saya pada mulanya mempertimbangkan untuk menjana kod secara dinamik untuk memudahkan proses ini, tetapi semasa ia berfungsi, ia bukan penyelesaian yang paling praktikal. Matlamat utama adalah untuk menunjukkan docstrings setiap kali pengguna memanggil fungsi, tetapi pendekatan yang dijana secara dinamik memperkenalkan beberapa cabaran, seperti kekurangan autolengkap.

Pendekatan Dinamik

Berikut ialah kod yang dijana secara dinamik yang saya uji:

tag_config = {
    # root elements
    "html": "nestable",
    "main": "nestable",
    "body": "nestable",
}

tags_factory = {
    "nestable": lambda name__: f"""
{name__} = partial(nestable, "{name__}")
{name__}.__doc__ = nestable.__doc__
""",
    "textable": lambda name__: f"""
{name__} = partial(textable, "{name__}")
""",
    "self_closing": lambda name__: f"""
{name__} = partial(self_closing, "{name__}")
""",
    "nestable_no_attrs": lambda name__: f"""
{name__} = partial(nestable_no_attrs, "{name__}")
"""
}

for k, v in tag_config.items():
    exec(tags_factory[v](k), globals())

Ini berfungsi dengan baik dari segi kefungsian tetapi kurang pada kebolehgunaan. Kelemahan utama ialah kekurangan autolengkap, kerana kod itu disuntik semasa runtime. Walau bagaimanapun, teg HTML itu sendiri agak mudah, jadi ini tidak begitu membimbangkan buat masa ini.

Faedah dan Had

Salah satu kelebihan ketara pendekatan ini ialah fleksibiliti. Menyokong atau menafikan elemen html dalam Zenaura adalah semudah menambah atau mengalih keluar pasangan nilai kunci daripada kamus tag_config. Ini adalah cara yang mudah untuk menyesuaikan diri dengan perubahan dalam teg HTML dari semasa ke semasa.

Selain itu, satu-satunya had adalah dengan autolengkap dan menunjukkan rentetan dokumen kepada pengguna, saya rasa ini adalah pertukaran yang baik untuk dibuat memandangkan elemen html cukup asas.

Walau bagaimanapun, pertukaran datang dalam bentuk kebolehgunaan: tanpa pelengkapan automatik, pengguna mungkin menghadapi cabaran apabila berinteraksi dengan antara muka. Walau bagaimanapun, saya percaya ini adalah titik permulaan yang baik untuk bereksperimen dengan cara baharu untuk mengendalikan elemen tag dalam Zenaura.

Atas ialah kandungan terperinci Corak Pengaturcaraan Meta Runtime dalam Python ini Menarik. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!