Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Ante: A low-level functional language

antelang.org

Post reply on HN
Print view View original

21–30 of 226 posts

Re: Ante: A low-level functional language

#21

Post by jkarni »

dthul wrote: post #11

Looks very cool! Can somebody enlighten me what's happening in the Algebraic Effects example? Specifically this part: handle f () | flip () -> (resume true + resume false) / 2.0 Does `handle f ()` call `calculation` and the `| ...` part "injects" the `flip` effect? I am also quite confused by the part following `| flip ()`. It somehow returns true or false with a probability of 50%? And why does this give you the exp…

I don't fully understand it yet, but I think it resumes twice, adds the results, and divides by two.

the `| flip ()` is pattern matching on that effect term, I believe. So essentially: when you see `flip ()` inside anything in the argument of `expected_value`, capture the continuation there, run that argument once with `true` and once with `false`, add the results, divide by two.

Re: Ante: A low-level functional language

#23

Post by curryhoward »

Escapado wrote: post #3

The syntax looks a little funky to me but it's still quite interesting. Is there a reason why you would make fn(1) and fn 1 equivalent? For me personally it makes readability worse and looks strange when chaining functions like in their last example on their landing page. On mobile horizontal scrolling through the code snippets will trigger switching to the next snippet on my phone.

> Is there a reason why you would make fn(1) and fn 1 equivalent?

For the same reason you'd make 1 + 2 the same as 1 + (2). Parentheses can be used to group arbitrary subexpressions.

Re: Ante: A low-level functional language

#24

Post by chriswarbo »

DeathArrow wrote: post #2

Very interesting stuff! I didn't even thought is possible to implement a low level functional languages, I always thought a functional language requires a ton of abstractions.

It's certainly possible, although certain styles are more appropriate than others.

For example, ATS is ostensibly an ML-like language; but its "low level" examples look more like "C with stricter types" (e.g. its Cairo examples)

https://en.wikipedia.org/wiki/ATS_(programming_language)

Re: Ante: A low-level functional language

#25

Post by arethuza »

tazjin wrote: post #5
Escapado wrote: post #3

The syntax looks a little funky to me but it's still quite interesting. Is there a reason why you would make fn(1) and fn 1 equivalent? For me personally it makes readability worse and looks strange when chaining functions like in their last example on their landing page. On mobile horizontal scrolling through the code snippets will trigger switching to the next snippet on my phone.

> Is there a reason why you would make fn(1) and fn 1 equivalent? If your standard function call convention is just `f x`, but you also support precedence operators, then `f (x)` automatically becomes possible. It reminds me of an old Lisp joke, though: f x -- too mathematical! (f x) -- too many parenthesis! f(x) -- just right!

Pity it doesn't include a line for:

   x f

Re: Ante: A low-level functional language

#26

Post by HelloNurse »

curryhoward wrote: post #23
Escapado wrote: post #3

The syntax looks a little funky to me but it's still quite interesting. Is there a reason why you would make fn(1) and fn 1 equivalent? For me personally it makes readability worse and looks strange when chaining functions like in their last example on their landing page. On mobile horizontal scrolling through the code snippets will trigger switching to the next snippet on my phone.

> Is there a reason why you would make fn(1) and fn 1 equivalent? For the same reason you'd make 1 + 2 the same as 1 + (2). Parentheses can be used to group arbitrary subexpressions.

If fn 1 is an allowed function call syntax then fn (1) should be synonymous because 1 is expected to be the same as (1) except for a slightly different parse tree; but there might be good reasons to make fn 1 not a function call (for example, the implicit operator in a sequence of two expression without parentheses could be string concatenation rather than function application).

Re: Ante: A low-level functional language

#27

Post by quickthrower2 »

YetAnotherNick wrote: post #16
mellavora wrote: post #12

Earlier quoted context omitted.

As an old lisp fan, I never got this. (f x) and f(x) have the same number of parenthesis. and the nice thing about (f x) is that the parenthesis group f with x; so you have the whole call inside the (). Consistent and simple to understand. vs i.e. print(f"a string"), where it isn't even clear that the "f" is a function call.

> (f x) and f(x) have the same number of parenthesis. That's the joke

I have heard that if you count { and ( as parens, a Java program for example has just as many parens as. lisp one.

A lisp paren can do both jobs: expression and scopes.

Re: Ante: A low-level functional language

#28

Post by cwillu »

arethuza wrote: post #25
tazjin wrote: post #5

Earlier quoted context omitted.

> Is there a reason why you would make fn(1) and fn 1 equivalent? If your standard function call convention is just `f x`, but you also support precedence operators, then `f (x)` automatically becomes possible. It reminds me of an old Lisp joke, though: f x -- too mathematical! (f x) -- too many parenthesis! f(x) -- just right!

Pity it doesn't include a line for: x f

That line necessarily comes after all the arguments about it.

Re: Ante: A low-level functional language

#30

Post by shirogane86x »

markoutso wrote: post #14

How is this low level exactly?

quoting the github readme:

> In general, ante is low-level (no GC, values aren't boxed by default) while also trying to be as readable as possible by encouraging high-level approaches that can be optimized with low-level details later on.

Post reply on HN