Hacker News Reader

> return/if/while/break/continue actually work in Hylang. Common Lisp doesn't have these.

It has all of them!

Return:

    CL-USER> (defun foo () (return-from foo 1) 2)
    → FOO
    CL-USER> (foo)
    → 1

If:

    CL-USER> (if t 1 2)
    → 1
    CL-USER> (if nil 1 2)
    → 2

While:

    CL-USER> (let ((x t))
               (loop for j from 1 to 10
                     while x
                     do (when (= j 3)
                          (setf x nil))
                     collect j))
    → (1 2 3)

Break:

    CL-USER> (loop for i from 1 to 10 do (format t "~&i: ~a~%" i) when (> i 4) do (return) do (format t "~& -~%"))
    i: 1
    -
    i: 2
    -
    i: 3
    -
    i: 4
    -
    i: 5
    → NIL

Continue:

    CL-USER> (do ((i 1 (1+ i))) 
                 ((> i 10))
               (format t "~&i: ~a~%" i)
               (when (= i 4) (go end))
               (format t "~& -~%")
               end)
    i: 1
    -
    i: 2
    -
    i: 3
    -
    i: 4
    i: 5
    -
    i: 6
    -
    i: 7
    -
    i: 8
    -
    i: 9
    -
    i: 10
    -
    → NIL

Common Lisp has goto, has traditional control structures and can be as imperative as you like.

I made a mistake of mentioning Common Lisp in the same line. Common Lisp has pointers (cons) as well.

Hylang doesn't have goto, as Python doesn't have it.

Well you can always implement a goto by having

1. A list made of lambdas. List gives numeric addresses. Dict will give you named addresses.

2. Pass the above list itself to each of the lambda or make it a global variable called ADDRESSES.

No one talks about the cool imperative features of Common Lisp right ? The was the point I was trying to make.

Scripting is imperative.

Python is a scripting language .. right ? That makes Hylang a scripting language too. Hylang is (Python).

Not disputing the central point, imperative is ok, but Common Lisp has all of it in one or other way - It's pretty much imperative, indeed.

Having started with C at college and then moving onto Common Lisp on my own was a massive headscratch when I first started. I abandoned lisp after that. Common Lisp has tagbody and go of course ... but there is so much shame around it. Why ?

How did people learn sh, perl, ruby, python ? By writing dumb imperative scripts of course! Why the shame ?

Even from a cursory glance Hylang has more libraries than all the lisps combined. FACT. I think it fits perfectly for scripting tasks and for a change its easier for beginners to get started with. ipdb works with hylang folks!

I had to google it. Remember Liskell ? The Lisp that mapped onto Haskell ? I think Hylang and Sibilant should be treated as minimal lisps along the same lines. As compared to Common Lisp .. Hylang is worse and that can only be a good thing.

> return/if/while/break/continue actually work in Hylang. Common Lisp doesn't have these.

Don't know where you get your facts from, but Common Lisp certainly has those.

This is how it looks in Hylang because it maps onto Python semantics.

  (for [element (range 1 10)]
    (print element)
    (if (= element 5)
      (break)))

I prefer this over Common Lisp because it looks shamelessly imperative.

are you sure you have ever used Common Lisp? Maybe you were thinking about a different language.

  CL-USER 51 > (loop for element from 1 upto 10 do
                     (print element)
                     (if (= element 5)
                         (return)))

  1 
  2 
  3 
  4 
  5 
  NIL

I have not used CL. I was horrified by the loop macro infact because I jumped from C to CL.

I definitely made a stupid mistake of clubbing CL with scheme and clojure but in those languages they avoid these imperative features.

I have made other points as well which makes Hylang different from the rest.

1. Hylang is a transpiler. Don't compare it with other lisps. Sibilant and Liskell are others in the same league.

2. Hylang has more useful libraries than all the other lisps.

3. Right now, I find Hylang best suited to write good old imperative dirty scripts that get stuff done. If you have used Python, Ruby, Perl ... it's practically heaven.

4. I stress the imperative part again because ... because that's my stupidity of choice. I'm a scripting guy! I'm familiar with that stuff. The best part of lisp for me is not the macros. It's that I don't have to google for syntax that often and "-" beats the "_" for variable names.

5. ipdb works too!

> I was horrified by the loop macro infact because I jumped from C to CL.

But you are aware that the FOR loop code you posted looks almost exactly like the LOOP FOR code in Common Lisp?

>The fight against imperative programming has come so far that we banned not just goto but every commonly used control flow primitive.

Not really. We have not banned them from anywhere, except where they were not part of the culture (e.g. Scheme -- and even there you can use them trivially).

Almost all working professional programmers (say, 99% of them, aside a statistically insignificant percentage working professionally with Haskell and Lisp and F# and so on) use for, while, if, exceptions, and so on. Hardly "banned".

>We have banned global variables too

And for good reason.

>and FP purists want to go even further and remove the assignment operator

Your initial data and constants need to come from somewhere, so nobody bans the assignment operator. But if you can avoid mutations, sure.

>What is the end result except more confusing code ?

Clearer code that you didn't took any time to study the concepts of to understand?

Having to know fewer concepts to use a language is not the same thing as the code being easier to understand.

A language with fewer concepts can lead to weak expressibility, so you need to e.g. write 100 lines to do what another does in 5, and with their intention more explicit in the code.

For an extreme example, consider how easy it is to understand a piece of code doing the same thing in assembly and in C. The C code will be much easier to follow, despite requiring you to learn more language constructs.

And inversely, a BASIC programmer could say the same things you said, but about, say, Python: "Why do we need all those language features, aren't line numbers and GOTO simpler?"

If learning 5 new concepts makes it possible to handle the same functionality in half the code, understand old codebases better, and write the same thing with less bugs, then those 5 concepts lead to simpler code -- even if they add to what someone already knows.

>What is a monad exactly if not the ";"?

Tons of other things.

> return/if/while/break/continue actually work in Hylang. Common Lisp doesn't have these. Scheme purists won't let you have them.

Common Lisp does have them, as does. Scheme purists will let you have pretty much whatever imperative control structures you like (that's what macros are for), but you would be right if you said that none of the Scheme standards mandate simple equivalents for all of those (though since Scheme looping is usually recursive—which is perfectly imperative—“break” is usually just not recursing.)

> The fight against imperative programming has come so far that we banned not just goto but every commonly used control flow primitive.

Well, they weren't banned, Hough of course you won't find them in pure functional languages like Haskell. But CL and Scheme and Lisp-family languages with strong roots in those have robust imperative controlled structures and the foundations for building more if you need them.

The monad does enable imperative programming in Haskell, yes. But it is not needless complexity. It enables an imperative program to be assembled using a pure functional program. Imperative statements become first class values, control flow constructs can be just user-defined functions, no macros needed. Monads, of course, also allow us to change the meaning of a semi-colon. This can be used, for example, to implement lightweight fiber threads with custom schedulers, again all without macros.

It has been said that Haskell is the world's best imperative programming language: https://stackoverflow.com/questions/6622524/why-is-haskell-s...

Meh, continue seems like a weird keyword to use, since it means you act on a "negative" condition. If this is true, skip the rest. Most code like thay could just be inverted and be perfectly readable.

For when you really need it, you could just use a block in CL and emulate it using return-from. Return and break are really the same thing, and don't really need to be separate.

CL is really an imperative language as well, it is just that it doesn't force you to be imperative to return things from an if or such things.

Scheme is a different beast. Since it provides you with the mother of all control structures (call/cc or prompts in guile/racket) mutability isn't really good if you want safety.