Dictu 0.22.0!

Jason_000 — Mon, 25 Oct 2021 18:53:01 +0000

Dictu 0.22.0

A new release of Dictu is here! For those of you who do now yet know what Dictu is, please see my introductory post about it here.

Whats changed

list.findIndex()

This is very similar to .find() that is already in the language, or for those of you more versed in a language like JavaScript, has the same outcome as that. It allows you to provide a callback and find the index of an item within a list once the callback evaluates to true

const myList = [1, 2, 3, 4, 5];
print(myList.findIndex(def (item) => item == 4)); // 3

Enums

Previously in Dictu you had to provide a value to an enum when defining it, with 0.22.0 you no longer have to provide a value and instead it's value will take the index within the enum (0-based).

enum DaysOfTheWeek {
  Monday,
  Tuesday,
  Wednesday,
  Thursday,
  Friday,
  Saturday,
  Sunday
}

print(DaysOfTheWeek.Monday); // 0
print(DaysOfTheWeek.Saturday); // 6

System Module

This is a breaking change; the System module now requires an import as previously it was the only module in the standard library that did not require an import.

obj.methods()

This is a new method on all instantiated objects which returns a list of all the methods defined on the object that are marked as public. This will allow us to cleverly call methods at runtime.

class Test {
    myMethod() {

    }

    private myPrivateMethod() {

    }
}

print(Test().methods()); // ["myMethod"]

obj.getAttribute()

A bug-fix was applied to getAttribute, previously if this was used on an object to attempt to return a bound method it was returning a function object (which had no notion of the object it was bound to), instead this has been fixed so that it correctly returns a bound method.

dict.merge()

This new method allows us to merge two dictionaries into a single dictionary.

const dictOne = {"key": 1, "key1": 2, "key2": 3};
const dictTwo = {"key3": 4,"key1": 0};

print(dictOne.merge(dictTwo)); // {"key2": 3, "key": 1, "key3": 4, "key1": 0}

Env.get()

Dictu already had Env.get() through the Env module, however, this has been extended so that if the env variable is not found a suitable default value (which must be a string) is returned instead.

import Env;

print(Env.get("this really doesn't exist", "default")); // default

Result.matchUnwrap()

This is a new method that allows us to match on a result type but then immediately re-wrap the value back up that is returned from the callback. If you do not know about Dictu's method for error handling, see here first.

var response = HTTP.get("https://some/endpoint").matchWrap(
    def (data) => JSON.parse(data).unwrap(),
    def (error) => error
);

print(response); // <Result Suc>

Summary

That about sums up the 0.22.0 release in a brief overview, but there are more exciting things in the work already for the next release! Notably there has been an internal overhaul of how the standard library modules are created, and now allows for Dictu code to be ran - this will mean that parts of the standard library can (will) be written in Dictu! This is what is happening with the UnitTest library that will eventually make its way into Dictu's standard library.

For more information on Dictu see either of the below links.
Site: https://dictu-lang.com/
GitHub: https://github.com/dictu-lang/Dictu

Dictu - A simple programming language

Jason_000 — Tue, 05 Oct 2021 19:04:28 +0000

Dictu

Dictu is a high-level dynamically typed, multi-paradigm, interpreted programming language. Dictu draws inspiration from the family of languages surrounding it, such as Python, JavaScript and Lua. It's a language that I have been working on for a few years now with contributions gratefully coming in from developers from all parts of the globe.

Dictu doesn't deviate massively from the family of languages surrounding it, and it doesn't intend to replace them either - that would be incredibly difficult with the eco-system surrounding them; instead Dictu actually started off as a learning project building on the very good craftinginterpreters book. Since then however, it has grown into an actually usable language with my first "production" (public facing) application written in Dictu: https://paste.dictu-lang.com/

Examples

I always find examples useful when first exploring a language, so I'll jot a few down here.

Simple Guessing Game

const guess = 10;

while {
    const userInput = input("Input your guess: ").toNumber().unwrap();
    if (userInput == guess) {
        print("Well done!");
        break;
    } else if (userInput < guess) {
        print("Too low!");
    } else {
        print("Too high!");
    }

    System.sleep(1);
}

HTTP Request

import HTTP;
import JSON;

HTTP.get("https://api.coindesk.com/v1/bpi/currentprice.json").match(
    def (response) => {
        const data = JSON.parse(response["content"]).unwrap();
        print("${} per BTC".format(data["bpi"]["USD"]["rate"])); // $50,417.1200 per BTC
    },
    def (error) => print(error)
);

It's worth noting that Dictu handles with errors differently to languages such as Python that have exceptions, instead Dictu has a Result value. A Result is a value that is either in a Success state or an Error state that can be unwrapped. For more detail, see the documentation here.

Features

For a full overview it's better to consult the documentation, but for the sake of this post i'll list some of the standout features.

Result type error handling (explained briefly in the previous section).
Multi-paradigm, Dictu doesn't force a certain paradigm upon you and allows you to write how you want.
Functions are first class citizens.
Range of datatypes and methods relating to these datatypes built-in to the language (heavily inspired by Python).
Classes and inheritance along with access levels.
Garbage collection.
Modules.

Future

Dictu is definitely in a state where it is usable to create projects with, but it still has a long way to go, and a lot of testing to be done. It is also missing some external tools that are almost a necessity if "mainstream" adoption of the language was to ever take place, such as a package manager, but it's slowly getting there.

Priorities in its current iteration is to extend the standard library that Dictu offers with a lot of that potentially being written in Dictu itself, which will be nice to see and a whole lot of testing for any issues.

If the language has perked your interest at all the following links may be of interest:

DEV Community: Jason_000