unison

Alt opinion: syntax is the least important part of a programming language. I can't wait for the day someone invents one where it's defined entirely as an AST (with the S standing for Semantic). Just bring your own weird syntax. I guess Unison is the closest to this platonic ideal right now? https://github.com/unisonweb/unison/issues/499

We do have an FFI now! https://github.com/unisonweb/unison/pull/6008 It's very recent and we'll be adding more types to it soon, this first PR was just focused on the core machinery. This is in the 1.0 release, btw. Let us know if you give it a whirl.

Used something similar to this in the past: https://github.com/bmabey/provenance. Curious to see similarities/differences. Also reminds me of Unison at a conceptual level: https://github.com/unisonweb/unison

Last time I looked, [Unison code] -> [entry in the AST DB] was a one-way process. Adding a function means writing it (with whatever style you like) and seeing if what you wrote constitutes a new function or an existing one. You can't fluff db entries back up in to human friendly code. I don't see why it couldn't be done though, I think it just hasn't been a priority. Heck, you could have 100 different users collaborating in 100 different "languages", and so long as they serialized to the same AST and back, none of them would ever have to see the atrocious syntax which the other users prefer. Their editors and browsers could just render everything according to their users' preferences. Edit: it appears that Unison has an issue for this feature: https://github.com/unisonweb/unison/issues/499

Website: https://www.unison-lang.org Repo: https://github.com/unisonweb/unison

The Unison language (https://www.unison-lang.org/) knows how to compute whether the semantic meaning of the code has changed (though I don't think it's possible to get the actual diff to visualize it). You can edit a function you've committed into the Unison code repo, and if you didn't change the semantics of the function, it's actually stored under the exact same hash... All places using the function refer to it by its hash, so nothing needs to be recompiled either, and no tests need to be rerun. Things like renaming variables, reordering code whose order doesn't matter (common in functional programming) and things like that do NOT change the hash. I believe this is only possible because Unison is a Pure Functional Language. If it's not, it becomes a NP problem to decide if two programs are exactly equivalent, probably. I wonder if Uni

Short version: no type classes (yet) Longer version: Building upon what Quekid5 mentioned, Unison abilities are an implementation of what is referred to as algebraic effects in programming language literature. They represent capabilities like IO, state, exceptions, etc. They aren't really a replacement for type classes, though in some cases you can shoehorn abilities in where you might otherwise use a type class. For someone coming from a Haskell background, I think that abilities are closer to a replacement for monad transformers. But in my opinion they are much more ergonomic. Discusson of type classes comes up a lot. Here is a long-standing GitHub issue: https://github.com/unisonweb/unison/issues/502 For what it's worth, I've written Unison quite a lot over the past few years and while I've missed type classes at times, I think that re

Hi, one of the Unison creators here. We've talked about adding pluggable syntax[1]. It's in principle straightforward (the code is already stored in a database as its abstract syntax tree, not text) and I imagine a future version of Unison could let you pick from a variety of syntaxes. But we haven't gotten to it yet. [1] https://github.com/unisonweb/unison/issues/499 ... that said, the language semantics and libraries are still going to be different, so even if we have a python-ish or typescript-y syntax, there'll still be new things to learn. :)

I've been following the Unison lang [1] for quite some. Wing seem to set similar goals? From the first glance Wing looks more polished, but there's "The Big Idea" behind Unison - is there something similar? [1]: https://github.com/unisonweb/unison

So many new programming languages coming up with clever features that makes me wish I could mix and match their core features while using libraries from more popular languages. Up and coming Languages I am excited about - 1. Roc - https://www.youtube.com/watch?v=vzfy4EKwG_Y 2. Zig - https://ziglang.org/ 3. Scopes - https://sr.ht/~duangle/scopes/ 4. Gleam - https://gleam.run/ 5. Odin - https://github.com/odin-lang/Odin 6. Koka - https://github.com/koka-lang/koka 7. Unison - https://github.com/unisonweb/unison

The Unison language [1] also has a very interesting effect system. [1] https://github.com/unisonweb/unison