Ante: A low-level functional language

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

InfluxDB - Power Real-Time Data Analytics at Scale
Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
www.influxdata.com
featured
SaaSHub - Software Alternatives and Reviews
SaaSHub helps you find the best software and product alternatives
www.saashub.com
featured
  • ante

    A safe, easy systems language

  • burrido

    Do-notation for JavaScript

  • Looks great!

    A few questions (hopefully the author still reads it):

    * Any plan for support of arrow/monad comprehensions?

    * Semi-related: When it comes to generators it might be worth to consider making them clonable (see https://github.com/pelotom/burrido)

  • InfluxDB

    Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.

    InfluxDB logo
  • futhark

    :boom::computer::boom: A data-parallel functional programming language

  • This looks really lovely, I look forward to following the maturation of Ante in the future. I've often thought that the niche of a general purpose low-level FP language was a promising space. The only other langs that fit in there are ATS[1], which is notoriously complex/difficult-to-learn, and Futhark[2], which is more GPGPU/scientific-computing specific.

    We've got Rust, which is essentially a C-style lang that steals all kinds of goodies from the ML family; it's nice to see Ante as a kind of inverse to this: i.e. an ML style lang that borrows some of the nice bits from traditional imperative langs (and hopefully maintains their performance characteristics).

    Looking through the language tour there already seem to be a plethora of very sensible/ergonomic design decisions here. The 'loop' and 'recur' keywords are a great feature, making a nice little functional nod towards while loops. As a long-time Haskell user the explicit currying initially turned me off, but after seeing a couple examples I can see how it's actually a very reasonable solution, and moreover the ability to curry out of order is really nice instead of having to use 'flip' or similar combinators (as a side note, the explicit currying reminds me a bit of APL's α and ω arguments in dfns, a feature I'd love to see pop up more). The paired tuples also seem like they'd be a pleasure to use; certainly a bit more flexible than tuples in other ML style langs. Making '.' the pipeline operator is also a smart bit of syntax, and I can see it being very accessible to OO programmers in that it looks (and acts) like the method chaining they're familiar with. Refinement Types seem like a good alternative to full on dependent typing (ATS has an analogous (and more general) proof system for ensuring things like array indices are valid (an essential feature in a low level FP lang), but it involves threading those proofs through your program which seems much more clunky than what's presented here).

    Overall I'm really excited to see where Ante goes, it seems like a very pragmatic functional language, something the world definitely needs more of...

    [1]: http://www.ats-lang.org/Home.html

    [2]: https://futhark-lang.org/

  • mlton

    The MLton repository

  • If you’re fine with tracing GC (which depends on the situation, of course), Standard ML is a perfectly boring language (that IIUC predated and inspired Caml) and MLton[1] is a very nice optimizing compiler for it. The language is awkward at times (in particular, the separate sublanguage of modules can be downright unwieldy), and the library has some of the usual blind spots such as nonexistent Unicode support (well, not every language WG is allocated a John Cowan).

    Speaking of, Scheme can also be a delightful unexciting static language; consider for example the C-producing implementation Chicken[2]. The pattern-matching / algebraic-datatype story was still rather unsatisfying last I checked, but there are other situations where it shines—it’s complementary to SML in a way.

    You’re not going to be writing a kernel or a real-time renderer in either (though I’m certain people have taken that as a challenge), they son’t afford the flashy EDSLs of Tcl, Ruby, or Racket, and I can’t say I can prototype in them like I do in Python or sh+tools, but there is a comfortable middle ground where they fit well. (I hear others use Go in what seem like the same places, but to me it feels so thin and devoid of joy that I can’t really compare.)

    The FFI tools in both of the mentioned implementations are excellent, though not quite at the “type in C declarations” level of LuaJIT and D.

    [1] http://mlton.org/

    [2] https://call-cc.org/

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts

  • What downsides exist to Futhark? Seems almost too good to be true?

    1 project | /r/CUDA | 29 Jun 2023
  • GPU Programming: When, Why and How?

    4 projects | news.ycombinator.com | 19 Jun 2023
  • Does This Language Exist?

    4 projects | /r/ProgrammingLanguages | 22 May 2023
  • Functional GPU programming: what are alternatives or generalizations of the idea of "number of cycles must be known at compile time"?

    1 project | /r/ProgrammingLanguages | 4 Apr 2023
  • The Futhark Programming Language: Functional Array Programming in CUDA

    1 project | news.ycombinator.com | 7 Mar 2023