Arc Forum | Lisp-style definitions considered harmful

I always thought that was just because Scheme tries to be minimal, and using the single special-form "define" for two different purposes helps with that. Scheme also does two different things with "let":

 (let ((foo ...)) ...)
 (let foo ((bar ...)) ...)

 {foo x y z} -> ...
 {bar x y z} -> ...
 {~ x y z} -> ...

 -> x y z (+ x y z)

 (fn (x y z) (+ x y z))

 # Nulan
 (def foo -> a b c ...)
 (def foo 5)
 ; Arc
 (= foo (fn (a b c) ...))
 (= foo 5)

How about a language that's like Haskell/Shen: currying everywhere. This language would be based heavily on functions, of course, which are expressed with "->" as follows:

 foo %x -> %x + 2

 (def foo (x) (+ x 2))

As a quick test of this system, I went through some semi-contrived examples taken from http://en.wikipedia.org/wiki/Duck_typing

 class Duck:
 def quack(self):
 print("Quack")
 def fly(self):
 print("Flap, Flap")
 
 class Person:
 def __init__(self, name):
 self.name = name
 def quack(self):
 print("{} walks in the forest and imitates ducks to draw them".format(self.name))
 def fly(self):
 print("{} takes an airplane".format(self.name))
 
 def quack_and_fly(duck):
 duck.quack()
 duck.fly()
 
 quack_and_fly(Duck())
 quack_and_fly(Person("Jules Verne"))

 duck ->
 [ quack -> prn "Quack"
 fly -> prn "Flap, Flap" ]
 person %n ->
 [ quack -> prn "@%n walks in the forest and imitates ducks to draw them"
 fly -> prn "@%n takes an airplane" ]
 quack-and-fly [ quack %q fly %f ] -> %q; %f
 quack-and-fly duck
 quack-and-fly person "Jules Verne"

If you wanted to, you could use parens like Shen instead of no-parens like Haskell.

Some downsides? Well, since it's using currying, there could be some issues with that. In particular, variable argument functions wouldn't be possible. There's also potentially some scoping issues and such.

Overall though, I think this idea is cool enough to actually try and implement it in a simple interpreter, to figure out all the kinks.

-----

 [ foo = 5 | bar = 10 ]

 pattern = [ foo = 5 | bar = 10 ]

 pattern [ foo ]
 pattern [ bar ]

 pattern [ foo | bar ]

Also, in Haskell you might write this:

 fib 0 = 0
 fib 1 = 1
 fib n = fib (n-1) + fib (n-2)

 [ fib 0 = 0
 | fib 1 = 1
 | fib %n = fib (%n - 1) + fib (%n - 2) ]

 duck =
 quack = prn "Quack"
 fly = prn "Flap, Flap"
 person %n =
 quack = prn "@%n walks in the forest and imitates ducks to draw them"
 fly = prn "@%n takes an airplane"
 quack-and-fly %x = %x quack; %x fly
 quack-and-fly: duck
 quack-and-fly: person "Jules Verne"

 (duck) ->
 [ quack -> (prn "Quack")
 fly -> (prn "Flap, Flap") ]
 (person %n) ->
 [ quack -> (prn "@%n walks in the forest and imitates ducks to draw them")
 fly -> (prn "@%n takes an airplane") ]
 (quack-and-fly [ quack %q fly %f ]) -> (%q); (%f)
 (quack-and-fly (duck))
 (quack-and-fly (person "Jules Verne"))

 duck =
 [ quack = (prn "Quack")
 fly = (prn "Flap, Flap") ]
 person %n =
 [ quack = (prn "@%n walks in the forest and imitates ducks to draw them")
 fly = (prn "@%n takes an airplane") ]
 quack-and-fly [ quack %q fly %f ] = %q; %f
 quack-and-fly duck
 quack-and-fly person "Jules Verne"

 quack-and-fly person "Jules Verne"

 quack-and-fly (person "Jules Verne")

No, that's a reasonable way to solve it. But I still would like optional args, variable args, and vaus. Wheee a dynamic Haskell with vaus~

Hmm... with a little syntax, you could write this:

 quack-and-fly: person "Jules Verne"

 ; Arc
 (mac and args
 (if args
 (if (cdr args)
 `(if ,(car args) (and ,@(cdr args)))
 (car args))
 't))
 ; Shen
 (defmacro andmacro
 [and] -> true
 [and X] -> X
 [and X | R] -> [if X [and | R]])

 (defmacro twomacro
 2 -> 2.5)

---

* [1]: http://shenlanguage.org/learn-shen/macros.html

-----

But why does Shen even bother naming these macros? What operations can you perform on andmacro?

-----

 def (a = b)
 ..

 # basic type-based dispatch
 mac (lhs <- rhs) :case list?.lhs
 ..

When wart sees a symbol that is punctuation, it treats it as an infix operator, so that (a + b) and (a = b) work, etc.

As for :case, that's basically equivalent to "extend" in Arc. In other words, in Arc you write this:

 (extend foo ... (bar ...))

 def foo ... :case (bar ...)

---

So, if you put it all together, that means this:

 def (a = b)
 ..

 (def = (a b)
 ..)

And this:

 mac (lhs <- rhs) :case list?.lhs
 ..

 (mac <- (lhs rhs)
 (when (list? lhs)
 ..))

I would have to get used to not always seeing the function name first, but I like the symmetry this produces between definition and call.

Added: So when wart got infix (http://arclanguage.org/item?id=16775), Kartik gave this example for defining your own infix ops:

 def (<>) (a b)
 (~iso a b)

 def (a <> b)
 (~iso a b)

Thanks Pauan for the clarifying comments!

-----