Lisp's Influence on Ruby

One way I find traditional Lisp style more painful for functional code than Ruby's is that Lisp pushes me to read and write code from right to left. In the example the author gave:

    orders
      .select { |o| o.placed_at > 1.week.ago }
      .group_by(&:customer_id)
      .transform_values { |group| group.sum(&:total) }

the equivalent Lisp code would either be written in imperative style as multiple statements that each write to a temporary variable or (let) binding, or would look like this:

    (reduce #'+
      (map (lambda (o) (getf o 'total))
        ; this group_by replacement function
        ; might be written as hash-table code
        (my-group-by 'customer-id
          (remove-if-not
            (lambda (o)
              (>
                (getf o 'placed-at)
                (- (now) (* 60 60 24 7))))
            orders))))

where I now have to read from bottom to top to understand the order of operations on the `orders` record set, even though the "logical" way that I would think about how to execute the high-level operations is the opposite.

Other imperative languages that offer functional styles either make you do things imperatively to get that "logical" ordering of functional operations like I feel Lisp pushes you to do, or they do something like Ruby where things are chained left to right in a "single" statement. (Unified function call syntax in D, extension methods in C#, pipelines of structured objects in PowerShell.)

Now that I'm out of the corporate tyranny and have my own company, I use lisp for everything. There's certain satisfaction in writing config files and persisting data directly in s-expressions. Any json requirements are triggered by exports to foreign systems.

For folks that want all of this plus macros (and a lot of other great things), check out Elixir.

> He’s described Ruby’s design as starting from a simple Lisp, stripping out macros and s-expressions

Put the macros back! It would be so cool!

That is actually Lisp influence on Smalltalk, and Perl, that eventually influenced Ruby.

I love Ruby, use it for most of my projects that don't require performance.

Nothing I would love more than a Ruby with a Common-Lisp like compiler and runtime. Unboxed types, native compilation, partial compilation, live image (Ruby has this but "faster Rubies" like Crystal don't), etc...

What have the Lisps ever done for us?

https://www.youtube.com/watch?v=Qc7HmhrgTuQ