Up to Main Index                         Up to Journal for September, 2023

                   JOURNAL FOR THURSDAY 7TH SEPTEMBER, 2023

SUBJECT: On types of typing…
   DATE: Thu  7 Sep 21:18:08 BST 2023

September already, where did that come from? I have been slowly working on
making Mere a better programming language by add runtime error checking with
nice error messages. Due to a bit of a dilemma I ended up procrastinating for
a while, mulling over my options…

The thing is, Mere was originally a strongly typed language. It’s only been
since the rewrite that it became a dynamically typed language with strong type
checking. For example you can have an int ‘x’ and turn it into a uint ‘x’, but
you can’t add an int and a uint together. However, dynamic typing requires a
lot of runtime support which slows everything down.

Hence my procrastination. In basic terms, do I keep Mere dynamically typed and
slow or strongly typed and fast? There other features at play as well like
compile time static analysis and compile time optimizations.

To that end I’ve been experimenting to see what it would take to make Mere
once again a strongly typed language. So far I have added a new operator ‘?’
which can be read as ‘what is’ and is used to define a variable’s type:

     i ? int    // what is i ? it is an int!
    ia ? []int  // what is ia? it is an int array!
    im ? [int]  // what is im? it is an int map!

Do those comments make anyone else think of Sam Vimes reading “Where’s my
cow?” :) There is also the ‘?=’ operator for type inference:

     j ?= 1                      // j  is the inferred int type
    ja ?= []int 1 2 3            // ja is the inferred int array type
    jm ?= [int] 1 "one" 2 "two"  // jm is the inferred int map type

The format is quite flexible: “x ? int”, “x?int” and “x ?int” all work.

If you’re wondering why the question mark, it was that or the commercial at
‘@’ or some Unicode symbol people complain about and say they can’t type. All
the other symbols were used and I needed something easy for experimenting. I
was going to use the colon, but there were too many issues with label usage
and untangling that wasn’t going to be the quick I was looking for.

Function parameter types are working, return types not so much yes. This
works, but the return type is currently being ignored:

    add: func a?int b?int
      return a+b
    endfunc ?int

A small, complete example:

    >cat -n strict.mr
         1	x ?= 3
         2	y ?= 5
         3	//(x?int, y?int) >< 3, 5
         4	println call add x y
         6	add: func a?int, b?int
         7	  return a+b
         8	endfunc ?int
    >mere strict.mr

If I change line 1 to “x ?= 3u” and make ‘x’ a uint, then run the code again:

    >mere strict.mr
    testdata/test.mr:6: invalid type for parameter 2 on call,
                        have: uint want: int
    testdata/test.mr:7: operator "+" does not match signature iu

While I’m experimenting, the errors are currently runtime checks — but they
will eventually be compile time errors. So far I’ve just been playing with the
int and uint data types, but it seems to be working out well and performance
is good.

The main issue I’m struggling with at the moment are maps. Maps always seem to
be the fly in the ointment. For example, should these two chunks of code be

    im ?= [int] 1 "a"
    im[1] = 2u         // change int element to uint?

    range k; v; [int] 1 1, 2 2u
      x ?= v           // x would need to be re-definable
      println type x

I don’t think “im[1] = 2u” should be allowed, simply because of the way Mere
uses maps as a poor man’s object. The range-next loop is more of an issue. I
could introduce an ‘any’, which then puts runtime checking back on table. Of
course you could then use ‘any’ to make “im[1] = 2u” work as well:

    im ?= [int] 1 any "a"
    im[1] = 2u

    x ? any
    range k; v; [int] 1 1, 2 2u
      x = v
      println type x

Another alternative might be to make ‘v’ in the range-next loop take on the
type of the element regardless. Then you could look at the type of ‘v’ to
decide how to handle it:

    range k; v; [int] 1 1, 2 2u
      if type v == "int"
        i ? int = v
        println literal i
      elif type v == "uint"
        u ? uint = v
        println literal u

And that ends up looking a bit of a mess really…

I’m still experimenting and playing with ideas. Your comments, suggestions and
ideas are welcome as always: diddymus@wolfmud.org


  Up to Main Index                         Up to Journal for September, 2023