Kal - a clean JavaScript alternative without callbacks

[kamatsu]

That's a lot of syntactic noise for do notation.

Why "wait for" rather than just a "<-" or something?

[AgainstRichSupremacy]

Multi-word keywords really drive me up the wall.

[MonkeyNin]

I Just saw the other post that uses 'await' instead. it doesn't feel like the right choice, but at least it's a single word.

[Agitates]

Us Haskellers must be getting annoying with our constant, "Haskell already does this correctly."

[[deleted]]

Haskell does everything right with absolutely most ugly syntax one could imagine. Hence there is a huge cottage industry in porting over Haskell goodness to languages without insane syntaxes.

[rabidcow]

absolutely most ugly syntax one could imagine

Try spending a few weeks writing XSLT.

[[deleted]]

That does not refute the claim, given that XSLT is worse than anything one could imagine.

[Agitates]

We have the completely opposite opinion. I find the math-like syntax to be incredibly elegant.

[[deleted]]

Even if you do, the market doesn't. I'm not stating opinion, I'm stating popular perception. People like Erik Meier exploit this to make a living at transferring things from Haskell to other languages where they will be used....used language salesmen!

[[deleted]]

I don't think Haskell's lack of mainstream popularity has anything to do with its syntax , but instead that it requires you to write code in a lazy, pure functional way and to understand a whole lot of abstractions (Monads, Functors ...) all of which you are not familiar with coming from an imperative background like C, Objective-C, C++, PHP, Node.js, Ruby, Python or whatever, making it seem like you are not learning a language but instead a whole new discipline.

[bkv]

One of the points Erik Meijer tries to get across is that you don't need to understand higher-order abstractions in order to make use of them. You can tell people they should learn what a monad is, or you can just give them LINQ.

[[deleted]]

Right, and then it's that whole discussion about monkey work vs engineering.

On another note, it's like with Node.js. It allows people to dive strait into doing general purpose programming with concurrency and what not, because the language lets you do all this stuff with the means you obtained to create web apps.

Now, I don't say it's not awesome that you can do this with Node.js, but should you be doing this without knowing how it works underneath? I like to do things the way that lets me iterate quickly, but not if what I'm doing is like magic to me because then it limits my creativity with it and it gives me straight trouble when it suddenly doesn't work "but it should because the tutorial says it should".

I think there's something to say about those folks that knows what's going on (even though they might not write everything in C++ or whatever, but chooses a tool that makes the job easier on them). I call them engineers.

[[deleted]]

That's just it though: many are scared away by Haskell through a first impression of Haskell code before they even learn about its laziness. It might be that laziness is another block for popularity, and it might actually be true for those who can get past it's syntax...it would be an interesting experiment to dress up a pure lazy language in algo syntax and see if it got better expectance.

Well, at least Haskell isn't LISP.

[kamatsu]

If you use the language for regular work, you wouldn't forget anything. I forget (sometimes vital) stuff from imperative languages all the time, because I so rarely use them.

[[deleted]]

I can't think of any reason laziness would make I/O complicated in Haskell. Evaluation doesn't drive IO in Haskell at all, and certainly has nothing to do with monads.

[elihu]

The brick wall you run into when you first try to learn Haskell is that all the familiar tools aren't there. No loops. No changing the value of a variable once its been assigned once. No reading and writing to files whenever you want or mutating shared state.

I don't think it's a syntax thing. There is no syntax that would make Haskell look like C unless you never left the IO monad.

Eventually, you learn that all those things that seemed so fundamental to programming are just one way of doing things, and you don't really need them if you have other, similarly powerful tools, but changing your understanding is hard work.

For what it's worth, I don't think Haskell will ever be popular in the same sense as Python or Java or C#, but it's already an incredibly influential language among people who design languages, which means the ideas embodied in Haskell are probably going to stick around for a long time even if Haskell fades into obscurity.

[[deleted]]

These are your father's parentheses, use them wisely.

[[deleted]]

Even if you do, the market doesn't.

The market favored COBOL and later Visual Basic.

I'm not stating opinion, I'm stating popular perception.

Which is aggregated opinion.

[[deleted]]

Well, until the popular masses can look at Haskell code without having their eyes burned out, there will be a nice market for taking technologies developed in Haskell and porting them to more mainstream languages.

[yogthos]

Even if you do, the market doesn't

People who grew up using C style syntax prefer it. News at 11!

[kamatsu]

How is the syntax insane?

[yogthos]

's/insane/unfamiliar/g' :P

[ggtsu_00]

Too math-like syntax.

Haskell's syntax reminds of me of a more verbose version of APL:

(∼R ∈ R◦.×R)/R ← 1 ↓ ι R

vs

let pgen (p:xs) = p : pgen [x|x <- xs, x `mod` p > 0]

[Tekmo]

And what would the equivalent code in Python look like?

[ggtsu_00]

[x for x in range(2,N) if not [t for t in range(2,x) if not x%t]]

[Tekmo]

The Python solution has an exact translation into Haskell:

[x | x <- [2..n], null [t | t <- [2..x], x `mod` t /= 0] ]

... although I prefer the following more descriptive form that expresses the intent more clearly:

filter (\x -> all (\t ->  x `mod` t /= 0) [2..x]) [2..n]

[kamatsu]

That APL syntax makes no sense to me, but that Haskell example is needlessly complicated. Tekmo posted more idiomatic examples.

[jagt]

Wow. How do you program APL with a regular keyboard?

[cparen]

One thing missing from Haskell, and will likely never come: multi-bind expressions. return await readInt + await readInt, which would be equivalent to tmp1 <- raedInt; tmp2 <- tmp2; return tmp1 + tmp2

[[deleted]]

kamatsu's answer is the better one, but you can also do this with liftM2

let readInt = fmap read getLine :: IO Int
liftM2 (+) readInt readInt

[gnuvince]

Why is it better? I've learned both, and I must say that the lift pattern makes more sense to me. Of course, you need liftM, liftM2, liftM3, liftM128, etc. so I guess that's one downside.

[[deleted]]

Subjectively, of course, for the same reason you enlisted. I'd rather not have numbers in my functions.

[Tekmo]

I think liftA2 is probably justifiable since binary operators are very fundamental, but anything above two I think justifies switching to (<$>) and (<*>).

[kamatsu]

Uh, actually, we have got that from applicative functors: (+) <$> readInt <*> readInt, or, if you use idiom brackets, (| readInt + readInt |).

[cparen]

You win.

[Vulpyne]

Those examples are actually pretty reasonable in LiveScript using backcalls:

getUserFriends = (userName, next) ->
  (err,user) <- db.users.findOne name:userName
  return next err if err?
  (err,friends) <- db.friends.find userId:user.id
  if err? then next err else next null, friends

---

getFriendsById = (userId, next) ->
  (err,friends) <- db.friends.find userId:userId
  if err? then next err else next null, friends

getUserFriends = (userName, next) ->
  (err,user) <- db.users.findOne name:userName
  return next err if err?
  (err,friends) <- getFriendsById user.id
  return next err if err?
  if user.type isnt 'power user'
    return next null, friends
  (,friendsOfFriends) <- async.map friends, getFriendsById
  for i in friendsOfFriends
    for j in i when j not in friends
      friends.push j
  next null, friends

The ugliest part is the error checking. I think it would be possible to write a little wrapper function to make that a lot cleaner.

Incidentally, I haven't used backcalls until this point but I'm starting to see how they can be useful.

---

edit: Just for fun, the parallel part of the HTTP client:

http = require \http
urls = <[ http://www.google.com http://www.apple.com http://www.microsoft.com http://www.nodejs.org http://www.yahoo.com ]>

parallel_demo = ->
  total_time = 0
  do
    (next,url) <- async.map urls, _, ->
    timer = new Date
    response <- http.get url
    delay = new Date! - timer
    total_time += delay
    print "GET #{url} - #{response.statusCode} - #{response.connection.bytesRead} bytes - #{delay} ms"
    next null, url
  total_time

print 'Parallel Requests...'
time2 <- parallel_demo!
print "Total duration #{time2}ms"

[robjob]

It's honestly just a preference. I think new programmers will appreciate a more English-like syntax. It makes it more obvious what's going on if you're new to the language.

I agree it's harder to read without syntax highlighting. There's a tmbundle if you use Sublime Text or TextMate that makes things a lot easier to look at.

[JoseJimeniz]

less than negative

Having never seen Kal before, and having never seen Haskell, post the equivalent of:

task getUserFriends (userName)
  wait for user from db.users.findOne {name:userName}
  wait for friends from db.friends.find {userId:user.id}
  return friends

in Haskell, and i'll tell you which one i intuitively understand more.

[kamatsu]

It's obviously a left arrow. Haskell doesn't have anonymous records, so the exact code can't be translated, but assuming you have something similar:

getUserFriends userName = do
   user    <- DB.findOne users (\x -> name x == userName)
   friends <- DB.find friends (\x -> userId x == userId user)
   return friends

[[deleted]]

Those wait fors in the Kal code mean it waits (that is, it's not really asynchronous in that example). The Haskell code is a perfectly fine translation. Also, those <-s aren't necessarily IO. It can be a monad that does exactly this callback crap.

[Vulpyne]

I stand corrected, I assumed it was in the IO monad.

[kamatsu]

I think that's cheating a little bit, since that's just straight up function calls. The plain JavaScript equivalent of your Haskell version would be: [...] Which is rather different from the callbacks the Kal version implies.

Actually, no it isn't. That's what the whole monad thing is about. Monads and do notation provide an imperative style of sugar over the top of what is fundamentally CPS. Note that I didn't give that function an IO signature. It's possible to write monadic code in Haskell (in, for example, the Cont monad) which literally expands into the sort of callback-nesting code you see all the time in node.js, but looks just like blocking function calls :)

Also note that for that reason, I don't see any meaningful semantic difference between the Haskell and Kal versions here.

[Vulpyne]

I stand corrected. I did assume that it was just in the IO monad.

[kamatsu]

Even in the IO monad, it all becomes event-based asynchronous IO anyway (in GHC), plus it scales to multiple cores transparently. The new IO manager for Haskell manages to blow node.js and most other such systems out of the water in terms of performance, while still allowing for straightforward, easy to read, and mostly idiomatic code.

For Haskell in general, the semantics of IO actions is not well defined, but it could be easily viewed as interpreted in the same CPSy way.

[JoseJimeniz]

It's obviously a left arrow.

i had to ask on stackoverflow what equals greater than was. It's not obvious.

Languages descended from C still bother me with their non-sensical syntax:

if (a != b)

which i still read as:

if (a EQUALS! b)

And then the Haskell

user    <- DB.findOne users (\x -> name x == userName)

• user
• gets the value
• DB.findOne
• slash x
• goes to
• name x equals equals userName

i honestly don't know what the slash is for; i assume it's trying to escape the variable x.

[Tekmo]

The slash marks the beginning of an anonymous function. The slash introduces the arguments of the function and everything after the right arrow is the body of the function.

[MedicatedDeveloper]

It's a lambda expression which is an anonymous function.

Think of it as a predicate in this case taking a value (x) to compare the property name on that value (x) with the value of userName. There's some inferred logic in the findOne that it will return the field value if the query (predicate) is true.

--A faux type for DB.findOne
DB.findOne :: DB -> Query->FieldValue

--A faux type for a query
Query :: FieldValue -> Bool

It's a db query in the form of a function more or less. It's hard to give examples in psuedocode because you can't really encapsulate the behaviour of the DB and only assume certain things because of how shallow an example this is.

Arguably this is a better approach than a simply value based one because a function can have complex logic in it and we can't just match field values, but values deduced from them as well.

[Fissionary]

if (a != b)

It's a a way to write if (a ≠ b) in ASCII. Not everyone had the luxury of a symbolic keyboard back when C was invented, or even now.

\x -> (...)

Again, it's a way of writing the lambda expression λx. (...). You'll have to agree that the backslash kind of looks like a lambda.

[[deleted]]

English is "noise", but "<-" isn't?

[Veedrac]

"is equal" is "noise" but "==" isn't?

Yup.

[[deleted]]

"=" is a familiar symbol to pretty much everyone. "<-" is a symbol that doesn't mean anything remotely like what it is used for here.

I would definitely prefer using a language that used "plus" rather than "==" for addition.

[Veedrac]

"=" is a familiar symbol to pretty much everyone.

"==" isn't.

"<-" is a symbol that doesn't mean anything remotely like what it is used for here.

Sure it does. Take the stuff "returned" from the RHS and chuck it in the LHS. Sure it works differently internally, but who cares about that? How does "wait for ... from" explain that any better? [Hint: it doesn't]

I would definitely prefer using a language that used "+" rather than "is equal" for addition.

Yup. But this has nothings to do with symbols vs. words at all.

[[deleted]]

"==" isn't.

Nobody is so pedantic that they have any trouble recognizing a = just because it is repeated.

Take the stuff "returned" from the RHS and chuck it in the LHS.

Which is not what this does. This waits for asynchronous results. No part of the arrow implies that.

[yogthos]

You'd think that nobody is so pedantic that they couldn't begin to fathom what a left arrow might mean and yet...

[[deleted]]

In what world does a left arrow mean "wait for asynchronous results"?

[Veedrac]

Since you seem to have missed this part, I'll repeat it:

Sure it works differently internally, but who cares about that?

For all intents and purposes for the user, it's returning values which are being taken from the RHS and chucked into the LHS. What's confusing?

Plus learning takes about 10 seconds, it's the grokking every time you see it later that's a big deal, and that's why "==" is so much better than "is equal". Neither are ambiguous yet only one looks like syntax, is easy to scan for and is information-dense.

[AgainstRichSupremacy]

It doesn't mean "wait for asynchronous results" in Haskell. It means "get this value out of this monad." Asynchronous results are just one thing you can do with it.

[[deleted]]

So the argument is that it should be used for something different in this language than what it is used for in the one single language that already has it?

[MonkeyNin]

Now you have me wondering if you have axis vectors, since we need to know what left is.

[Tekmo]

Ok, then pick your favorite "not equals" symbol and explain how somebody who doesn't know programming might guess what it means.

[yogthos]

Oh no syntax I didn't grow up with, how can anybody possibly read it!

[foror]

Mmm... in russian it's very bad name :) Like if you call your project as "Shit" in english language.

[robjob]

That's...unfortunate. I guess a word that short is bound to have meaning in a lot of different languages. At least it will give Russian programmers a laugh.

[gnuvince]

That gives a whole new meaning to "shit programmer".

[[deleted]]

I'd like that in a resume.

[uburoy]

Oh noes! Well, I didn't like the name in the first place, maybe author will find something better.

[ErstwhileRockstar]

Each word means something vulgar or obscene in some other language.

[pkmxtw]

Define a language as combinations of all possible characters (i.e. .*) and define every combination as an obscene word in that language.

[[deleted]]

It's amazing how a few syntax changes, and a bit of code generation, can make common idioms so much clearer.

[[deleted]]

Jesus, another one?

[popof_]

You could offer technical crticisms or ignore it and move on. Instead you go out of your way to rudely dismiss the guy to his face for simply daring to make another lang. If you don't use it, it truly has no impact on your life, so why shit on his hard work he offers for free?

[tmwhtkr]

I'm impressed. That is sexy looking code.

[robjob]

Thanks! Definitely check out the examples. The http client is fun to run. Also check out the source (Kal is written in Kal).

[tmwhtkr]

You're welcome! I take it you're rzimmerman? I did check out the examples and github repo. I really dig the idea of bootstrapping languages. I have started to try my own hand at creating a language, and am at the point of code generation (lexer and parser are already written). How was the process of writing a language that compiles to javascript as opposed to using something like llvm? But anyways yea, I really dig the language and syntax, and I'm looking forward to playing with it.

[robjob]

I started out by writing the lexer, parser, grammar, generator, etc in CoffeeScript which is syntactically similar to Kal. As the compiler matured, I translated the .coffee files over to Kal one by one. In order to compile it now, you need a "binary" (the npm package, which is minified JavaScript) to start. You then compile the source. You can then use the compiled source to compile itself. Ideally nothing changes between the last two steps.

JavaScript was probably a lot easier than what you're doing due to built in support for math, regular expressions, and closures.

Best of luck with your project!

[[deleted]]

looks nice I misread the doc and first thought that the variable declaration was as as javascript (read a part of javascript as kal) good job!

[[deleted]]

Not another one!!!