Because exitFailure only works on main thread. Can i force it with some throwTo main_tid?

The code below is my attempt at implementing the Token Ring Algorithm. Only two nodes can access the resources after which the program terminates. The await statements were used to force Haskell to execute the statements. It works for the Erlang backend so I am guessing the issue is with the Haskell backend.

`module TokenRingMod;

def Int numNodes() = 10;

interface Node {
Unit setNextNode(Node n);
Unit setTokenAtt();
}

interface Server{
Unit resources(Int id);
}

class ServerImpl implements Server{
Unit resources(Int id){
println("resources accessed by node: " + toString(id));

}
}

class NodeImpl(Int id, Server s) implements Node {

Node next;
Bool hasToken = False;
Unit run(){
if(hasToken == False){
await hasToken == True;
s!resources(id);
hasToken = False;
await next!= null;
await next!setTokenAtt();
}
}

Unit setNextNode(Node n) {
next = n;
}

Unit setTokenAtt(){
this.hasToken = True;
await this.hasToken == False;
}
}

{
List nodes = Nil;
Int num = numNodes();
Server s = new ServerImpl();
Node nextNode;
Node n;
Node first;

first = new NodeImpl(0, s);
nextNode = first;
Int id = num-1;
while (id > 0) {
n = new NodeImpl(id, s);
n!setNextNode(nextNode);
nextNode = n;
nodes = Cons(n,nodes);
id = id -1;
}
assert first != null;
first!setNextNode(n);
await first!setTokenAtt();

}`

Example code:

module Test;
class C {
  Unit m(Int x) {
    x=x+1;
  }
}

Not a big problem, because in general it is considered bad practice; even in certain OO languages (OCaml,Scala) it is disallowed.

It could possibly be fixed by generating extra local variables on the method body, but it is redundant when it is not needed, and makes generation of distributed method calls easier.

Right now the callee can only be this, or Var, or Field, but no arbitrary PureExp like: id(this).

Example:

{ 
  Int x = 3;
  case x {
     y => {  y = y+4; // modification of captured not allowed
             println(toString(y)); }
  }
}

For performance reasons, I do not provide Ord instances for Futures and Objects, e.g.:

{
 Fut<Unit> f1;
 Fut<Unit> f2;
 f1 == f2; // this is fine
 f1 < f2; // cannot compile
}

This means that futures and objects cannot be stored in fast Sets or being keys of fast Maps (elements are fine).

Could be potentially fixed by attaching to the future or object a thread-safe counter.

Equality for Futures&Objects is only provided.

DisPAck_explicit.txt

The attached habs code makes an error which is not logical. The line of code which generates the error is:

w!requests(tmp2 , tmp3,  1, workerId-1);

Some clues:

1. You can asynchronously call the w!request(Int) without problem.
2. If you drop the parameters of the requests() (at its calling point, its definition, and its signature in the interface) then it does not cause error anymore

Code:

module Test;

class C {
  Int x = 3;
  {
  	case (3) {
           x => println("ok");
    }
  }
}

{
  new C(); 
}

Example code that does not typecheck with habs:

module Test4;

data List_<A> = Nil_
              | Cons_(A,List_<A>);

interface I {
  I m();
}

interface I_ extends I {
  I_ m_();
}

class C implements I {
  I m() {
    return this;
  }
}

class C_ implements I_ {
 I m() {
   return this;
 }
 I_ m_() {
   return this;
 }
}

{
 I o = new local C();
 I_ o_ = new local C_();

 Fut<I_> f_ = o_!m_();

 Fut<I> f = f_; // covariant Future breaks

 // or Fut<I_> f_ = o_!m_();
 
}

This ABS snippet should work:

interface A {}
class A implements A {}

Fix with name mangling?

This may lead to false positive tests, e.g. neg/NotInScope.abs

There are two ABS files I am working on at the moment. I get the Irrefutable pattern error once I try to compile them with habs.

1. DisPA_Formal.abs which causes the following error:

habs: src/ABS/Compiler/Codegen/Stm.hs:(1067,19)-(1069,93): Irrefutable pattern failed for pattern Just (SV symbolType
                                                             _)

2. DisPAPack.abs which causes the following error:

habs: src/ABS/Compiler/Codegen/Dec.hs:(174,40)-(176,113): Irrefutable pattern failed for pattern Just (SV symbolType
                                                            _)