> LispE provides an alternative to parentheses with the composition operator: "."

That is a... Choice.

Breaking the pair operator in favour of something new.

After programming in Common Lisp for a few years (a long time ago) and then later on having a brief period where I was fond of Python, I did also become fascinated with the concept of lisps where indentation replaces parenthesis such as Wisp:

https://www.draketo.de/software/wisp

Mind you - I usually end up concluding that Lisp syntax is actually pretty good as it is...

There's a new one, pretty good, resembling Python/Julia syntax, check it out! https://moonli-lang.github.io/

    defun multiply-thrice(x):
      print(x * x * x)
    end

    multiply-thrice(23)

I've always been tempted with wisp. Ever since I saw SRFI-110. Love the concept.

I just never quite manage to grasp the new syntax.

They’ve got a page on that. They did away with linked lists and chose to represent them as vectors. With some of the usual stuff you see going on under the hood in this style of list on imperative languages, like pre-allocating a little room for growth.

I can’t opine on whether that’s a good choice. But I will observe two things: first, singly linked lists aren’t as great on modern computing architectures as they were 50 years ago. Locality of reference matters a lot more now. And second, both Hy and Clojure abandoned the traditional focus on dotted pairs, and in both cases I found it was fine. (Disclaimer, I didn’t spend a whole lot of time with Hy.)

Yeah, that's pretty unclean on two aspects: breaks pairs, and breaks the orthogonality of s-expressions

A simple macro would've sufficed, say:

  (compose
    sum
    (numbers 1 2 3))

I don't think it's too bad orthogonality wise, though it is a bit weird to introduce infix notation. It would almost make more sense to write

((. sum numbers) (1 2 3))

Your approach is better on a mathematical sense, yes. That’s how Haskell does it.

schemers used a good old `compose` instead of a dedicated syntax

and beside multiple-args, there's the usual threading macros

    (-> [1 2 3] f g)

It's not too bad. I like it! Haskell uses "$" to do the same thing.

Technically $ means something slightly different, it is more somilar to putting parentheses around the right half of the expression. For function composition it uses the same '.' .

Well, you could use $ in Lisp, too. Thats a standard valid symbol, that doesn't have a builtin meaning.

I honestly would've prefered someone try and turn xml into a lisp, at least that has a cool hack value

Whoa I never expected to see a lisp repository from Naver

I knew a company, StorySense, and their main product WhatsTheNumber used Lisp (maybe Scheme?) for the main logic in the back end. One of the founders previously worked at MIT Media Lab. Interestingly enough their competitor, Whoscall, was acquired by Naver. I wonder if they also used Lisp and if LispE is related to that product at all.

https://www.cw.com.tw/article/5067306

(Article in Chinese)