Hy 1.0.0, the Lisp dialect for Python, has been released

[Kodiologist]

I'm pleased to announce the release of Hy 1.0.0, after nearly 12 years of on-and-off development and lots of real-world use. Hy is a Lisp dialect embedded in Python. See Hylang.org for an introduction and documentation, the NEWS file for a version history, and the HYPE POST for something a little less serious.

Henceforth, breaking changes to documented parts of the language (other than dropping support for versions of Python that are themselves no longer supported by the CPython developers) will increase the major version number, and my intention is for that not to happen often, if at all. My focus will be on fixing new bugs as they arise, adding compatibility with new versions of Python, and adding support for whatever new features are added to Python in a fashion that won't break code that works on previous versions of Hy 1.x.y.

[pyx]

Congrats. This is the moment I've been waiting for over a decade, literally.

It gives me peace of mind because I am working on an ORM and an async web framework, both in Hy, they are not the typical "yet another ..." ones, I am not reinventing the wheel, both libraries are leveraging existing awesome libraries, containing mostly macros, focusing on cleaner interface and less boilerplate code.

For example, instead of these models in SQLAlchemy's ORM Quick Start Guide

class Base(DeclarativeBase):
    pass

class User(Base):
    __tablename__ = "user_account"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(30))
    fullname: Mapped[Optional[str]]

    addresses: Mapped[List["Address"]] = relationship(
        back_populates="user", cascade="all, delete-orphan"
    )

class Address(Base):
    __tablename__ = "address"

    id: Mapped[int] = mapped_column(primary_key=True)
    email_address: Mapped[str]
    user_id: Mapped[int] = mapped_column(ForeignKey("user_account.id"))

    user: Mapped["User"] = relationship(back_populates="addresses")

One can use the defmodel macro:

(defmodel User
  (id int :primary-key)
  (name str :max-length 30)
  (fullname str :nullable)
  (1->* Address :as "addresses"))

(defmodel Address
  (id int :primary-key)
  (email str)
  (*->1 User :reference "addresses"))

There will be no extra cost in runtime as defmodel is merely a macro that expand the code into the SQLAlchemy one above. To me, this is the true power of lisp, and a stabilized set of internals and APIs of Hy is a must for this kind of thing, so thank you all for the release of 1.0.

[kskarthik]

the hy syntax is minimal !

[pyx]

the hy syntax is minimal !

It is my favorite, too. So far, I've got (excerpts from the package's examples):

One to one

(defmodel Parent
  (id int :primary-key)
  (child "Child" :relationship "parent"))

(defmodel Child
  (id int :primary-key)
  ; equivalent to:
  ; (:one-to-one Parent :reference "child")
  (1->1 Parent))

Many to many

(defmodel Parent
  (id int :primary-key)
  (:many-to-many Child :as children))

(defmodel Child
  (id int :primary-key)
  ; equivalent to: :many-to-many
  (*->* Parent :reference children))

(deflinktable Parent Child)

Timestamp fields

(defmodel Todo
  (id int :primary-key)
  (content str)
  (created-at :timestamp-create)
  (updated-at :timestamp-update))

"One to many" and "many to one" already shown.

Once they are declared, they are just plain old SQLAlchemy 2.0 ORM objects, so you can use defmodel as a DSL for database schema and only write in Hy there, then use python for the rest.

I am working on querying DSL now, fluent interface doesn't get along with s-expressions, the best (without macro) I can get is:

(setv stmt (. (select Address)
                  (join Address.user)
                  (where (= User.name "sandy"))
                  (where (= Address.email "sandy@sqlalchemy.org")))

There must be a better way...

Once I have that done, I will push it to GitHub, and it will be on PyPI.

I will stop here since this thread is the release announcement.

[viljamivirolainen]

Please at least make it such that you have the syntactic order and semantic order match, as in: https://research.google/pubs/sql-has-problems-we-can-fix-them-pipe-syntax-in-sql/

[viljamivirolainen]

From paper:

https://research.google/pubs/sql-has-problems-we-can-fix-them-pipe-syntax-in-sql/

[pyx]

Please at least make it such that you have the syntactic order and semantic order match, as in: https://research.google/pubs/sql-has-problems-we-can-fix-them-pipe-syntax-in-sql/

I had a brief read of the paper before, and forgot about it, thanks for the reminder. Because SQLAlchemy's ORM querying interface is generally flexible enough, I should be able to come up with something like |> (it is also my favorite operator in OCaml). Another way that I can think of is to mimic list comprehension, I don't know yet. Just like the defmodel macro, I didn't get it right in the beginning until I wrote a few small apps with it and keep refactoring, then the final design emerged after a few iterations, time will tell.

[kamilion]

Is this feasible to operate on top of Micropython instead of CPython?

[Kodiologist]

MicroPython… includes a small subset of the Python standard library

Doesn't sound like it, but you could always use hy2py on CPython and then run the output, presuming you limit your constructions to what MicroPython supports.

[Kodiologist]

I can see a big spike in unique daily visitors to my web server (which hosts Hylang.org) on release day, which is cool.