Why Operators Are Useful

#1

Post by s16h » Sat, Mar 16, 2019, 11:58 AM UTC

Why Operators Are Useful
neopythonic.blogspot.com

Re: Why Operators Are Useful

#2

Post by phoe-krk » Sat, Mar 16, 2019, 2:03 PM UTC

This is much less confusing than (2), and leads to the observation that the parentheses are redundant, so now we can write "x + y + z"

This is a non-problem if you're using Lisp. (+ x y z) accepts an arbitary number of arguments and the operator precedence problem does not exist since there is no operator precedence.

Re: Why Operators Are Useful

#3

Post by platz » Sat, Mar 16, 2019, 2:19 PM UTC

phoe-krk wrote: post #2

This is much less confusing than (2), and leads to the observation that the parentheses are redundant, so now we can write "x + y + z" This is a non-problem if you're using Lisp. (+ x y z) accepts an arbitary number of arguments and the operator precedence problem does not exist since there is no operator precedence.

So you trade simplicity in one problem (precedence) and gain complexity in another (variadic arguments and (lang-dependent) multiple variadic function implementations)

Re: Why Operators Are Useful

#4

Post by QuadrupleA » Sat, Mar 16, 2019, 2:21 PM UTC

phoe-krk wrote: post #2

This is much less confusing than (2), and leads to the observation that the parentheses are redundant, so now we can write "x + y + z" This is a non-problem if you're using Lisp. (+ x y z) accepts an arbitary number of arguments and the operator precedence problem does not exist since there is no operator precedence.

Lisp is pretty ugly :)

    (eql (* x (+ y z)) (+ (* x y) (* x z)))

I wonder if its famed sense of enlightenment is partly just overcoming the mental hurdle of it's syntax.

Edit: typo fix, had x/z mixed up

Re: Why Operators Are Useful

#5

Post by ghettoimp » Sat, Mar 16, 2019, 2:21 PM UTC

phoe-krk wrote: post #2

This is much less confusing than (2), and leads to the observation that the parentheses are redundant, so now we can write "x + y + z" This is a non-problem if you're using Lisp. (+ x y z) accepts an arbitary number of arguments and the operator precedence problem does not exist since there is no operator precedence.

Yup. In addition to ignoring the usual Lisp convention for associative operators, I think the article muddies the waters here by using words like "add" and "mul" in all of the non-infix examples, making them unnecessarily verbose. After using prefix notation for years, it seems very natural for pattern recognition and formula manipulation. Never having to think about precedence and associativity is really nice.

Re: Why Operators Are Useful

#6

Post by explainplease » Sat, Mar 16, 2019, 2:25 PM UTC

QuadrupleA wrote: post #4

phoe-krk wrote: post #2

This is much less confusing than (2), and leads to the observation that the parentheses are redundant, so now we can write "x + y + z" This is a non-problem if you're using Lisp. (+ x y z) accepts an arbitary number of arguments and the operator precedence problem does not exist since there is no operator precedence.

Lisp is pretty ugly :) (eql (* x (+ y z)) (+ (* x y) (* x z))) I wonder if its famed sense of enlightenment is partly just overcoming the mental hurdle of it's syntax. Edit: typo fix, had x/z mixed up

You don't have to do it like that. You could do:

    (= (* x (+ y z))
       (+ (* x z) (* y z)))

Or:

    (= (* x (+ y z))
       (+ (* x z)
          (* y z)))

Or:

    (= (* x
          (+ y z))
       (+ (* x z)
          (* y z)))

Or:

    (= (+ (* x z)
          (* y z))
       (* x (+ y z)))

Or:

    (= (+ (* x z)
          (* y z))
       (* (+ y z) x))

Or:

    (= (+ (* x z)
          (* y z))
       (* (+ y z)
          x))

I think the last one makes the relationships quite clear.

Writing legible equations is an art form, as is writing sexps.

Edit: If you think lisp is ugly, compare with regexps. For bonus points, explore writing regexps with lisp, e.g. with Emacs's `rx` macro. I think you won't find a more easily maintainable way to write them.

Re: Why Operators Are Useful

#7

Post by chongli » Sat, Mar 16, 2019, 2:30 PM UTC

explainplease wrote: post #6

QuadrupleA wrote: post #4

Earlier quoted context omitted.

Lisp is pretty ugly :) (eql (* x (+ y z)) (+ (* x y) (* x z))) I wonder if its famed sense of enlightenment is partly just overcoming the mental hurdle of it's syntax. Edit: typo fix, had x/z mixed up

You don't have to do it like that. You could do: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (+ (* x z) (* y z)) (* x (+ y z))) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) I think the last one makes the relationships quite clear. Writing legible equations is an art form, as is writing sexps. Ed…

Some would argue that the fact that you have all of those alternative forms is part of the problem. Lisp is one of the (if not the) most individualistic programming languages around. Lisp makes it easy for a programmer to create their very own impenetrable, arcane, domain specific languages. This causes large organizations to avoid it like the plague.

Large teams don't want artists, they want replaceable parts.

Re: Why Operators Are Useful

#8

Post by Symmetry » Sat, Mar 16, 2019, 2:34 PM UTC

Operators can certainly be nice. And I do like allowing the programmer to create new ones too, though I'd tend to prefer the Haskell approach of creating new ones out of existing symbols like >< or such rather than the C++ approach of letting the programmer redefine an existing operator for a new use, << in the streams library being one of the worst common examples.

Re: Why Operators Are Useful

#9

Post by nanaya » Sat, Mar 16, 2019, 2:36 PM UTC

explainplease wrote: post #6

QuadrupleA wrote: post #4

Earlier quoted context omitted.

Lisp is pretty ugly :) (eql (* x (+ y z)) (+ (* x y) (* x z))) I wonder if its famed sense of enlightenment is partly just overcoming the mental hurdle of it's syntax. Edit: typo fix, had x/z mixed up

You don't have to do it like that. You could do: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (+ (* x z) (* y z)) (* x (+ y z))) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) I think the last one makes the relationships quite clear. Writing legible equations is an art form, as is writing sexps. Ed…

Sorry, is it

xz + yz = x(y + z)

when using operators?

That seems wrong.

Re: Why Operators Are Useful

#10

Post by quietbritishjim » Sat, Mar 16, 2019, 2:41 PM UTC

nanaya wrote: post #9

explainplease wrote: post #6

Earlier quoted context omitted.

You don't have to do it like that. You could do: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (* x (+ y z)) (+ (* x z) (* y z))) Or: (= (+ (* x z) (* y z)) (* x (+ y z))) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) Or: (= (+ (* x z) (* y z)) (* (+ y z) x)) I think the last one makes the relationships quite clear. Writing legible equations is an art form, as is writing sexps. Ed…

Sorry, is it xz + yz = x(y + z) when using operators? That seems wrong.

I don't know any Lisp, but I would decode

    (= (* x (+ y z))
       (+ (* x z) (* y z)))

As

  x*(y + z) = x*z + y*z

e.g. (+ y z) means you add y and z with highest priority.