Renato Athaydes

A have a look at Unison: a revolutionary programming language

Written on Solar, 08 Jan 2023 23:22:00 +0000

Unison is a pure practical programming language that comes with a couple of revolutionary concepts. Critically, it makes all the pieces we’re used to, like lengthy builds, dependency model conflicts, assessments that run each single construct even when nothing checked by them has modified, guide encoding and serialization of information, and plenty extra appear to be primitive stuff from the time we have been programming in caves. For that reason, I’ve been following Unison growth excitedly, if quietly, for a couple of years now.

As I write this in early 2023, lastly, I believe it has reached a degree of maturity the place it’s really usable for actual work, so I made a decision to put in writing about my impressions utilizing the language for one thing non-trivial.

May it actually be the language of the long run, as its web site cheekily proclaims?! What’s so revolutionary about it? Why are we not utilizing its revolutionary concepts in different languages but if they’re so nice?!

Let’s have a better look. It truly is value it!

Introduction to the large thought

The Unison web site may be very cool and has a full page devoted
to explaining the large thought behind Unison. So, I extremely advocate studying that earlier than you proceed. Please come again after you’re performed!

Of their phrases, right here it’s:

Every Unison definition is recognized by a hash of its syntax tree.

Put one other method, Unison code is content-addressed.

Sure, that’s very concise and will not sound terribly attention-grabbing. However this straightforward thought permits stuff you in all probability didn’t even suppose have been attainable.

For instance, Unison does away with builds. Utterly! Have you ever been on the lookout for a language that has nice compile occasions whereas nonetheless being strongly typed? Effectively, how a few language with principally zero compilation time??

It sounds outrageous, I do know… I additionally thought it was principally bs earlier than trying into it in additional element. However, consider me, it’s not.

Code is just not saved in a number of, seemingly unrelated textual content information in Unison. It’s saved in an precise database. One you can solely append to, just like a Git repository.

The rationale Unison doesn’t have builds is that code is already saved in its type-checked, AST (Summary Syntax Tree) kind in that database, linked to different definitions by its hash.

For those who write the identical perform with completely different names, even with completely different variable names and maybe declaring bindings in several order, for instance, Unison will simply retailer one perform, however add an alias to it when you really need it. It has a canonical illustration for all code, which permits it to try this.

Even documentation and kinds are saved this manner, although you could use distinctive sort to keep away from identically structured varieties to be thought-about the identical.

Once you change the kind of a perform, it solely impacts different code that makes use of it when you explicitly use Unison refactoring capabilities to replace that perform all over the place it’s used (we’ll see precisely how to try this later).
It’s merely unattainable to commit code that wouldn’t compile. You may select to go away the outdated perform alone and simply bind the identify to a brand new perform, or rename the outdated one, that’s superb too! It’s your alternative.

Meaning there’s no model conflicts both in Unison. You may have completely different capabilities utilizing completely different variations of another perform on the similar time. The completely different variations are completely different hashes, and capabilities solely confer with the hash of different capabilities, so there’s by no means a battle.

This concept additionally permits straightforward distributed computing, in spite of everything, sending a computation, code, knowledge and all, to a different machine, is way simpler when you realize precisely what the code dependencies of the computation are, what the info sort definitions are, and are distinctive and can’t battle.

This isn’t an authentic thought

Many readers could also be interjecting that this concept is an outdated thought: Smalltalk already had the thought of an “picture” the place all supply code was saved as a substitute of textual content information.

Different readers might bear in mind Joe Armstrong’s well-known discuss, The mess we’re in, the place the thought of utilizing (unspoofable) hashes as a substitute of names to facilitate distributed computing, amongst different issues, is expanded at across the 36:00 mark.

Nonetheless, Unison would be the first time this concept has been carried out in such a method that the complete advantages described within the earlier part could be totally realized. Even when it’s not, I consider it’s nonetheless an exquisite implementation of that concept, specifically when mixed with pure, statically typed practical programming.

No IDE required

Although an IDE is just not required with Unison, as this part will present, you should utilize one, in fact.
They’re engaged on an LSP implementation for Unison, for instance.
Verify the Editor Setup documentation for extra on that.

I already talked about how code could be refactored trivially with Unison. However discover that you just don’t want an IDE or another instrument to try this. Unison has one thing known as the Unison Codebase Manager (used by way of the ucm instrument) which is used to govern the code base. That features including, altering, refactoring code.

As a substitute of simply speaking about it, it’s time to really present the way it all works… I can’t clarify the Unison language itself (test the Unison at a glance web page for that)… if you realize Haskell, it should look very acquainted.

What’s actually attention-grabbing is the way you write Unison code. No IDE is required, simply fireplace up your favorite textual content editor, so long as it has an built-in terminal, as you’ll want one!

I selected to make use of emacs. On one buffer (or “window” when you’re not an emacs consumer), fireplace up ucm (I discovered that utilizing ucm from M-x shell works fairly nicely):

On one other buffer, in the identical listing, create a .u file (use any identify you need with the .u extension, it gained’t matter)… that’s solely used so that you can write new code and watch expressions.

Preserve each buffers seen always.

To begin with, consider a few expressions, which is finished by prepending the > character to them as proven under:

Discover that code and expressions are entered by way of the .u file, NOT on the ucm terminal! The ucm CLI is just not a REPL. This may turn out to be clear quickly.

> checklist = [1, 2, 3]

> head checklist

> reverse  checklist

Now, save the file with the above contents whereas trying on the ucm shell. It is going to appear to be this:

Seems to be very cool, however let’s see what occurs after we make a mistake:

> kind [4, 2, 3, 1]

Consequence:

This exhibits how a lot consideration the Unison builders have spent on giving good error messages.

It appears the issue is that kind is ambiguous so we should specify which one we imply to make use of. Discover how the error message says there’s a Heap.kind and a Listing.kind… so we will use one in every of them:

use base.knowledge.Listing

> Listing.kind [4, 2, 3, 1]

Consequence:

That’s higher, however what I’m actually serious about is actual world code that does one thing helpful, which implies I would like to make use of plenty of IO!

That brings us to how we will use ucm to find Unison performance. By studying the Unison docs briefly, I do know that there’s a sort known as IO, however not a lot else… so we will sort discover IO in ucm to see what is obtainable… this being such a generic question, it should checklist a variety of issues, however you need to see this proper to start with:

1.    builtin sort base.IO

That’s in all probability what we’re on the lookout for. To verify that, checklist the contents of base.IO with ls:

A lot of helpful stuff in there. To know what a few of it does, you should utilize docs:

Discover you can confer with the quantity within the beforehand listed definitions as a substitute of the complete identify.
In different phrases, docs 4 above is identical as docs base.IO.FilePath.

You may as well use view to view the precise definition of a logo.

For those who sort ui, it should open the complete hyperlinked Unison documentation on a browser, in case you’re not a fan of looking docs on a terminal!

Working with actual Unison code

Earlier than continuing, as we are going to wish to really retailer code within the ucm database, we have to create a namespace and fork base into its lib namespace (the place all dependencies of a challenge go).

By exploring the documentation, it was straightforward to learn how to learn a textual content file line by line. However Unison doesn’t have a easy perform to learn the entire contents of the file, and Deal with.getLine doesn’t allow us to specify the encoding, it simply makes use of the platform default encoding (however there’s a word within the docs that this shall be fastened quickly…).

So, let’s write a perform to learn the complete contents of a file as UTF-8:

use base.IO.FilePath
use base.IO.FilePath.open
use base.IO.Deal with
use base.IO.FilePath.FileMode.Learn

readAllBytes path =
         hdl = open (FilePath path) Learn
         lastly '(Deal with.shut hdl) do
             use Bytes ++
             recur learn =
                 if Deal with.isEOF hdl then
                    Bytes.empty
                 else
                    !learn ++ recur learn
             recur '(Deal with.getSomeBytes hdl 4096)

readUtf8 = readAllBytes >> Textual content.fromUtf8

Consequence:

Discover how Unison has inferred the varieties of the capabilities with out us having to explicitly write them!
The {IO, Exception} half means the perform requires the IO and Exception abilities.

Talents are one other actually cool thought in Unison which confer with effectful computations, or albebraic results to make use of the educational time period… sadly, together with a correct dialogue of talents would make this publish too lengthy, however I do advocate studying about it within the Unison documentation later because it’s very attention-grabbing.

The readUtf8 perform above makes use of the >> operator (learn as andThen), one of many function application operators in Unison.

The others are <<, |> and <|. Each << and >> return capabilities, however <| and |> return values.

Additionally attention-grabbing is the ' citation, which is a solution to create a delayed computation.

For those who attempt to run readUtf8 from the ucm, you’ll run into an issue.

It is a little annoying, solely capabilities that take no arguments could be executed with run. Keep in mind, ucm is NOT a REPL!

Additionally, watch expressions don’t have the IO potential, so making an attempt to execute an expression like this:

> unsafeRun! '(readUtf8 "hello.txt")

Leads to an error:

To my information, the one solution to run capabilities that require IO and take arguments is to put in writing a brief main-like perform that reads arguments from IO.getArgs.

Earlier than we attempt that, let’s add the 2 capabilities now we have already outlined to the database:

Now, we will take away these definitions from the buffer, and add the momentary fundamental perform.

For instance:

tempMain _ =
           match head !getArgs with
                 Some file -> readUtf8 file
                 None -> "<no args offered>"

-- this can be a remark
--- something under this line is ignored as a result of it begins with '---'.

-- this lets you maintain some definitions seen,
-- with out always re-defining issues.

This instance exhibits the ! operator getting used to invoke the no-args perform, IO.getArgs. ! is principally the reverse of the ' citation operator, i.e. to invoke a delayed computation of sort 'a, like getArgs, you are able to do !getArgs. However discover that’s simply equal to getArgs (), which is invoking getArgs with an empty argument checklist, however it avoids having to wrap it inside parens all over the place.

Now, we will use run to invoke tempMain because it has the proper signature:

It really works! ????

However there are some issues we have to repair on this program. First, if we compile and execute this program, it gained’t really print something as a result of tempMain returns the Textual content however doesn’t use it… we solely see the lead to ucm as a result of it prints the results of the run name.

Second, after we attempt to learn a file that doesn’t exist, we get a Unison error report… it’s good and all, however we in all probability wouldn’t need an actual world software to try this.

For these causes, let’s have a look at how we will deal with errors in Unison and print to stdout/stderr.

Coping with errors

Many programming languages look good when engaged on pure code that simply does math, however are horrible at serving to the programmer cope with the mess of the true world – in different phrases, they’re unhealthy at error dealing with.

Let’s see how we will cope with the true world in Unison by making certain that our fundamental perform handles errors. That’s onerous as a result of all the pieces might fail at runtime, together with issues that almost all programming languages ignore, like printing to stdout.

Unison has many varieties/talents that assist with errors, like Throw, Exception, Failure and Abort.

Verify the Error Handling Documentation
for extra particulars.

Right here’s my preliminary, not so nice try at writing one thing like cat in Unison, based mostly on the beforehand added readUtf8 perform and with out letting fundamental propagate any errors:

use lib.base.talents.Throw

{{ Logs `message` to {stdErr}. Crashes this system if it can't write. }}
logError! : Textual content ->{IO} ()
logError! message =
          put msg = unsafeRun! '(putText stdErr msg)
          put message
          put "n"

logFailure! failure =
            logError! (Failure.message failure)

{{ Get the method arguments, returning the primary argument.
   If the quantity of arguments is just not precisely 1, a {sort Throw} happens.
}}
singleArgOrFail : '{IO, Throw Textual content} Textual content
singleArgOrFail _ =
                match catch getArgs with
                    Proper (arg +: []) -> arg
                    Proper _ ->
                          throw "A single arg have to be offered."
                    Left failure ->
                         use Textual content ++
                         throw <| "Unable to learn arguments because of: " ++ (message failure)

-- Takes an motion that requires Exception potential and removes that.
inside.errorHandler : (() ->{IO, Exception} ()) ->{IO} ()
inside.errorHandler motion =
                      match catch motion with
                            Left failure -> logFailure! failure
                            Proper _ -> ()

-- no Exception potential, so `fundamental` can't exit with a stacktrace.
fundamental : '{IO} ()
fundamental _ =
     inside.errorHandler do
                           file = Throw.toException (e -> failure e ()) singleArgOrFail
                           readUtf8 file |> printLine

This time, I made a decision to explicitly sort most capabilities to make sure that they don’t by accident get talents I didn’t imply so as to add.

For exploration, I used each the Exception and the Throw talents. Throw appears to be a barely simplified Exception, however I’m not positive that on this case, utilizing it was significantly better… we are going to revisit that quickly.

The vital factor is that now, I can really compile and run this program from the terminal as a substitute of solely from ucm! An actual app, if you’ll!!

To create a compiled file with solely the mandatory definitions, in our case fundamental and its dependencies, first we have to add the brand new definitions, then name compile:

Now, we will run this system from any terminal:

▶ ucm run.compiled unison-cat.uc hello.txt
Howdy Unison!

That is only a textual content file.

The generated .uc file has solely 33069 bytes and appears to be a type of multi-platform bytecode file, like a Java jar. It runs fairly quick as nicely, I can print a file of round 1MB in underneath 80ms, and a 25MB file piped to /dev/null in 0.4 seconds (contemplating the file is being totally loaded into reminiscence and it’s simply concatenating bytes from small 4KB chunks, that’s not too unhealthy – it could be attention-grabbing to make use of a pre-allocated buffer as a substitute, as Unison appears to have amenities for writing excessive efficiency code, however that shall be left for a future publish).

I consider Unison has plans to compile on to native binaries as nicely, however after I tried to run compile.native, it didn’t work. One thing to attend for.

Updating code and reviewing adjustments

One of many fundamental issues builders see with the Unison strategy of letting go of our expensive textual content supply code information is that it makes it more durable to assessment adjustments.

Effectively, however that’s not likely true anymore: Unison supplies respectable instruments to department, change stuff, then generate the diffs earlier than merging adjustments again to fundamental, newest and so on.

We are able to attempt it out by modifying the code within the earlier sections to cease utilizing Throw and utilizing solely Exception for error dealing with.

The very first thing to do when modifying an present code base is to fork it, so we will later get a diff simply, then cd into the brand new, forked namespace. The next exhibits methods to do it from a contemporary ucm session (together with making a fundamental namespace to make use of as the event “department”):

Discover that on the finish, we’re inside the namespace mylib.prs.improveErrorHandling, and that’s only a fork of mylib.fundamental with none adjustments, up to now.

Now, we wish to edit the singleArgOrFail perform to cease utilizing Throw, so we sort edit singleArgOrFail in ucm, which masses the present definition of that perform into the scratch.u file:

singleArgOrFail : '{IO, Throw Textual content} Textual content
singleArgOrFail _ =
  match catch getArgs with
    Proper (arg +: []) -> arg
    Proper _           -> throw "A single arg have to be offered."
    Left failure      ->
      use Textual content ++
      throw <| "Unable to learn arguments because of: " ++ message failure

By altering this perform to make use of the Exception potential, we tremendously simplify it as we don’t must catch the Exception from getArgs anymore:

singleArgOrFail : '{IO, Exception} Textual content
singleArgOrFail _ =
  match !getArgs with
    arg +: [] -> arg
    args      -> Exception.increase <| failure "A single arg have to be offered." args

Consequence:

I initially thought that Unison had failed to note that fundamental was utilizing the earlier definition, so it shouldn’t have allowed me to replace this… however on additional inspection, it seems fundamental nonetheless labored anyway as a result of it already had the Exception potential… The code dealing with Throw grew to become ineffective, however it nonetheless compiled superb!

Let’s revisit the present definition of fundamental (sort view fundamental in ucm):

fundamental : '{IO} ()
fundamental _ =
  errorHandler do
    file = Throw.toException (e -> !(failure e)) singleArgOrFail
    readUtf8 file |> printLine

This could now be simplified as nicely:

fundamental : '{IO} ()
fundamental _ =
  errorHandler do
    file = !singleArgOrFail
    readUtf8 file |> printLine

A lot nicer, and Unison allowed me to replace it with out points.

However what if we made a breaking change? Like altering the return sort of a perform:

singleArgOrFail : '{IO, Exception} [Text]
singleArgOrFail = getArgs

On replace:

Discover how Unison permits even this replace, however it doesn’t really change the dependent capabilities mechanically… they maintain referring to the outdated one, as you may see after I did view fundamental above:

  fundamental : '{IO} ()
  fundamental _ =
    errorHandler do
      file = !#p8nm43hb6r
      readUtf8 file |> printLine

As a result of the outdated definition now has no identify, its precise hash is proven the place it’s used. We have to use the todo command to see what else wants to vary, then edit all the pieces to hopefully use the brand new definition (or one thing else).

On this case, I simply wish to revert the newest change, so I undo it:

Discover how todo says all the pieces is up-to-date now, and when you view fundamental once more, it should present the named perform once more!

You may learn extra particulars about how refactoring works in Unison on the How to update code part of the Documentation.

Code Assessment

This part of this weblog publish will in all probability be up to date sooner or later as Unison continues to be defining how pull requests, patches and code assessment basically ought to work.

Verify the Organizing your code base article for the present advised solution to handle this.

What follows is my private suggestion on how you can do code assessment in your Unison code base.

As soon as we’re glad with our adjustments, we wish to submit it for code assessment and hopefully merge the adjustments into fundamental.

The Unison docs about Organizing your code base exhibits methods to create a pull-request, push, pull and merge it utilizing ucm.

Nonetheless, it doesn’t actually clarify how one can generate a correct diff to assessment the adjustments. I got here up with the next process to get a single diff the place I can see all of the adjustments utilizing no matter diff instrument I like, for instance emacs’ ediff. So long as you may see the diff between two information, this can be just right for you.

1. create two empty .u information: earlier than.u and after.u.
2. test what phrases have been modified within the namespace with diff.namespace.
3. cd into the bottom namespace.
4. load the earlier than.u file (because it’s empty, this simply units the present buffer for ucm).
5. edit all of the phrases which have been modified.
6. cd into the brand new namespace.
7. load the after.u file.
8. edit all of the phrases which have been modified.

That is what doing this seems to be like:

Now, the earlier than.u and after.u information could be in contrast utilizing your most well-liked diff instrument.

For my present adjustments, it seems to be like this on emacs:

Hopefully, this process could be automated sooner or later, making this simpler to do.

One very last thing to do is merge the adjustments!

To do this, we use the merge command, clearly:

All adjustments are actually merged into the .mylib.fundamental namespace.

One downside I seen is that, as you may see within the message from Unison above, a patch was created, which is often used to replace references to modified capabilities whose sort weren’t modified by operating patch patch. Nonetheless, after I run that, I get a message This had no impact., so I believe Unison simply bought confused by some means. You may eliminate the patch by operating delete.patch patch.

And whilst you’re at it, when you don’t need the PR namespace to hold round, run additionally delete.namespace prs.improveErrorHandling.

Conclusion

Unison is a tremendous new programming language that I’m positive won’t solely begin getting used, very quickly, within the niches that may largely profit from its purely practical nature and distributed computing friendliness, however it is usually set to essentially affect what is anticipated of software program growth UX within the years to come back.

It solves issues that almost all of us didn’t even know have been issues that could possibly be solved. And it’s only a very good language throughout. I discovered it rather a lot simpler to understand than Haskell, for instance, whereas nonetheless feeling that it offers me greater than sufficient energy to put in writing clear, dependable code with out subjecting me to some problem that almost all different languages would (lengthy, advanced builds, unreliable assessments, dependency model conflicts…).

It’s not excellent, positive… working with namespaces and forks, pulls, merges is complicated with git, and maybe even extra when it’s such a basic a part of utilizing the language. The error messages, whereas usually prime notch, can typically be fairly unhelpful. However Unison has already come a great distance from a few years in the past, after I first tried it, and it’s quickly bettering not too long ago.

There are numerous extra attention-grabbing issues that I didn’t discover house to cowl on this weblog publish, like
code documentation,
testing,
using/publishing libraries (together with some very good libraries, like
@runarorama/codec which makes it a breeze to work with binary encoding) and, specifically, Unison support for distributed computing, which I believe might not be prepared for manufacturing utilization simply but, and anyway I in all probability couldn’t do justice to the subject given my restricted period of time and information within the space.

In any case, I hope extra folks will really feel serious about Unison and assist unfold it, or a minimum of its concepts, in order that the language can develop to its full potential and possibly revolutionize the best way software program is made sooner or later.