DEV Community: Nevergarden

Type Rules

Nevergarden — Mon, 22 Jan 2024 08:57:30 +0000

So I decided that types are not keywords in Shiro language and primitive types can be declared as set of rules of either assembly or the output IR or anything.

Like imagine we want to declare a 8-bit signed integer number.

type i8 = rule {
  var => function(name:id, ?value:number) {
    rule.out( "%" eval(name) "= alloca i8, align 1" )
    branch {
      (value != null) => {
        rule.out( "store i8" eval(value) ", ptr %" eval(name) ", align 1" )
      }
    }
  }
}

will be part of sys/llvm/i8.shr file.
so if user includes it then they can assign an i8 variable.

var x : i8;
var y : i8 = 12;

will generate:

%x = alloca i8, align 1
%y = alloca i8, align 1
store i8 12, ptr %y, align 1

for LLVM IR.

A rule should not contain only the variable but all kind of operator functions like adding.

type i8 = rule {
  var => function(name:id, ?value:number) {
    ...
  }

  += => function(assignee:id, left:expr, right:expr) {
    rule.out( "%tmp = add i8 %" eval(left) "," eval(right) ) 
    rule.out( "store i8 %tmp, ptr %" eval(assignee) ", align 1" ) 
  }
}

And therefore:
var x : i8 = y + 12;

will result in LLVM IR:

%x = alloca i8, align 1
%tmp = add i8 %y, 12;
store i8 %tmp, ptr %x, align 1

This is just a demonstration, will change in future.

Type Declaration

Nevergarden — Fri, 19 Jan 2024 07:43:04 +0000

Introducing new keyword type for anything which goes into type table for either type-checking or type inference.

Record Types

There will be record for data structure declaration.
Therefore:

type point = record {
  var x : float;
  var y : float;
}

Also developers can define operator functions using condition statements:

type point = record {
  var x : float;
  var y : float;

  == => function(other:point) : bool {
    return (x == other.x) && (y == other.y);
  }

  [] => function(index:int) : float {
    return branch {
      index == 0 => return x;
      index == 1 => return y;
      otherwise => return float.NaN;
    }
  }

  [] => function(index:int, value:float) : void {
    branch {
      index == 0 => x = value;
      index == 1 => y = value;
      otherwise => nop;
    }
  }
}

So therefore a check like:

var p1 : point = {
  x = 1;
  y = 2;
}

var p2 : point = {
  x = 2;
  y = 2;
}

printf("%b\n", p1 == p2); // false
printf("%b\n", p1 < p2); // error: operation type(point) < type(point) is not implemented.

Generic Records

A generic record can be defined like this:

type tpoint = record : T1, T2 {
  var x : T1;
  var y : T2;
}

var p : tpoint<int, int> = {
  x = 1;
  y = 2;
}

var p2 : tpoint<string, string> = {
  x = "12";
  y = "13";
}

Record Functions

Functions can be included in a record with field, anything which does not need setting when introducing a record can be defined as field.

type point = record {
  var x : Float;
  var y : Float;

  field distance = function(other:point) : float {
    var dx = x - other.x;
    var dy = y - other.y;
    return math.sqrt( dx*dx + dy*dy );
  }
}

var p1 : point = {
  x = 2;
  y = 3;
}

var p2 : point = {
  x = 5;
  y = 6;
}

p1.distance(p2); // 4.24264

Enum Types

So enumeration types are the same as any enumeration type yet they can have underlaying type.

type invalidation_flag = enum : int {
  Text = 1;
  Color = 2;
  Size = 4;
  All = Text | Color | Size;
}

var flag1 : invalidation_flag = 1; // Valid
var flag2 : invalidation_flag = Color; // Valid
var flag3 : invalidation_flag = flag1 | flag2; // Valid
flag3 == 3; // true
var flag4 : int = All; // Invalid: All is not of type int

By default enums inherit int types and start from 0.

Union Types

Union type can only accept one of the underlaying types and it's size is the biggest value inside the union declaration.

type some_type = record {
  var x : int;
}

type number = union {
  var x : int;
  var y : float;
  var z : double;
  var n : some_type;
}

var a : number.x = 12;
var b : number.y = 0.2;
var c : number.z = 0.2;

0.2 == b; // true
c == b; // false
c.x; // 0 : double -> int conversion
a.z; // 12.0: int -> double conversion
a.n; // throw error: no viable conversion between int -> some_type.

Function Type

We can have function types when binding to a variable:

var x = function(a:int, b:int):double {
  return double(a + b);
}

type of x is now a function with underlaying type of:
int->int->double

type ftype = function (int, int) : double;
var m = function(a:ftype, d:double):double {
  return a(1, 2) + d;
}

// type of m : ftype->double->double

m(x, 3); // 6.0

Shiro Branch

Nevergarden — Thu, 18 Jan 2024 14:10:20 +0000

So I've been writing my own programming language for fun I decided to write a devlog series on what I'll be doing.

In my language I decided to omit if else and switch or any conditional statement and instead use a singular statement called branch.

It uses the same concept in CS Branching in a way that it will be much closer to it's mathematical implementation and result of this statement can be evaluated.

An example of a mathematical equation:

fx = branch x {
 < 2 => { return 12; }
 == 2 => { return 13; }
 > 2 => { return 100; }
}

Another feature is that the inner block expressions will be evaluated:

var x := 4;
var m = 10;
var fx := branch x {
  < 10 => { m = 12; return 5; }
  >= 10 => { return 2; }
}

will result in x = 4, m = 12 and fx = 5.
(variable declaration for mutable and immutable variables are not finalized yet but var name = expr is mutable variable declaration and var name := expr is immutable variable declaration for now.)

For this statement I decided to add branch => otherwise tokens to lexer.

using otherwise

otherwise is for any other condition in a mathematical function.

var y := branch {
  x == 1 => { return 1; }
  x == 2 => { return -1; }
  otherwise => { return 0; }
}

so while evaluating y if x is any number except 1 or 2 y value would be 0.

Using SQL or NoSQL

Nevergarden — Fri, 23 Apr 2021 13:10:22 +0000

This Monday on an interview I was asked if I was supposed to start a project how do I know whether I use SQL or NoSQL?
And to tell the truth I was confused and puzzled that I really never thought of when to use them?

I forgot about that question until now and then I searched for when to use them the first thing was the actual implementation of them.

Structure

SQL is structured while NoSQL can accept unstructured data.
SQL accepts gives you a form and asks you to fill it exactly as is.
But when talking NoSQL you can provide any data to any document. But then you have to check this information when you retrieve that document.

Transaction

SQL is transactional while NoSQL provides a document-level-based transaction but not what we look for.
Think you are programming some wallets and Jack transfers 100 dollars to Jills wallet.
You write a transaction in SQL like:

BEGIN TRANSACTION
UPDATE Jack.Money -= 100;
UPDATE Jill.Money += 100;
COMMIT

This way both of them should happen so if the first command works and the second one fails then Jack's money doesn't go to waste.
But with NoSQL, we have to check their documents and then request again. (I might be wrong about this)
Also, this answer explained how NoSQL databases have lighter transactions.

Feb 6 '10

Generally speaking, NoSQL solutions have lighter weight transactional semantics than relational databases, but still have facilities for atomic operations at some level.

Generally, the ones which do master-master replication provide less in the way of consistency, and more availability. So one should choose the right tool for the right problem.

…

Open Full Answer