pint° v0.0.4: hello, world!

pint° v0.0.4 introduces a few features that allow one to finally make a “hello, world”: basic literals, let declarations, method calling and non-class imports. Two of them were already highlighted (although partially) in a previous post, but we will show them again, now in their full implementation.

Basic literals #

The following literals are now supported in pint°:

Unit literals #

As basic as it can be, unit literals are (). They are currently their own thing, but when we introduce records/tuples/structs, they will be generalized to be part of them.

Dart has no inherent concept of a unit or unit literal (although it’s not hard to implement your own, and Null itself is a singletone type), so how unit compiles to Dart will depend on some heuristics, described in a previous post.

Boolean literals #

Boolean are also as basic as they could be, and the follow what Dart (an many other languages) do: true and false.

String literals #

For 0.0.4, we don’t support advanced features that one could expect for a string literal, like escaping, raw string, multi-line literals, or anything fancy, but we included a basic support for them.

In pint°, string literals are always double-quoted¹. So, for instance:

"lorem ipsum dolor sit amet"

Number literals #

This one is new in relation to the last post. As said earlier, we are still discussing some details about how we will handle numbers bases (and other things), so we decided to ship a basic version of it that only supports the most simple case for both integer and double literals.

Number literals support digit divisors out of the box, so here are some examples of some number literals:

42
1_000
1__000_000__000_000
1.0
10_000.0
0.000_000_1

Let declarations #

pint° now supports let declarations. They come in two flavors: regular let declarations and function let declarations.

Regular let declarations #

As the constrasting name implies, this one is the one presented in the post aforementioned. It allows one to declare associate a name with a value².

Here are some examples:

1
2

let name = "Mateus Pinto"
let catsHeHas = 1

Let declarations introduces the identifier in the top-level scope of your program³. These identifiers can then be referred by other let declarations or in function calls.

Function let declarations #

By appending a parameter to a let declaration identifier, it is converted to a function let declaration⁴.

1

let myFunction param = "returning a string"

pint° functions have always a single parameter⁵, and current implementation parameters are simply ignored, so you can’t use them. However, this code works and compiles to a parameterless function in Dart.

1

String myFunction() => 'returning a string';

Function calls #

If an identifier has the function type, it can be called.

1
2

let stringFunction _ = "return string"
let otherStringFunction _ = stringFunction "this parameter will be ignored, but who cares?"

Non-classes imports #

In 0.0.3, pint° could already import from Dart. However, it only imported classes. From this version, it also import top-level identifiers and methods⁶.

This enables us to… #

Finally have a (useless, but still) hello world in pint°.

1

let main _ = print "Hello, world!"

This code will be compiled to a valid “hello world” Dart code:

1

void main() => print('Hello, world!')

What’s next? #

These changes are already in the GitHub repository, but I still didn’t release it to pub.dev. We want to update the syntax highlighting for our VSCode extension before doing so.

For the next version, three things will be the focus:

1. Implementing records/tuples/structs (the name is yet to be decided);
2. By consequence, implementing function parameters;
3. And, for this to be able to happen, we need to have some basic⁷ type system implemented (subtype/supertype relation).

Contributors #

A special thanks to seha, that made his first contribution to our repository by implementing number literals.