worker declaration not allowed in isolated function

[navaneeth-algorithm]

import ballerina/io;
import ballerina/http;


configurable int port = 8080;



# Init file
function init(){

       io:println("Initing....done");

       io:println("Configured port...",port);

       
}
isolated function compute(int a,int b) returns  int{
    worker A {
        a->B;
        b->C;
    }

    worker B {
        int x1 = <-A;

        x1->function;
    }

    worker C {
        int x2 = <-A;

        x2->function ;
    }

    int x1 = <-B;

    int x2 = <-C;


    return x1 + x2;


    
}


//base path
service /demo on new http:Listener(port) {
    resource function get hello () returns string{
        return "Hello, Good morning";
    }

    resource function get hello/[string name] () returns string{
        
        return string`Hello, Good mornig ${name}`;
    }


     isolated resource function get computy/[int a]/[int b] () returns  json{
       int r =  compute(a,b);
        return {"result":r};
        
    }
}

I got error ,
Error: worker declaration not allowed in an 'isolated' function!!

If i remove isolated keyword from compute then i will get error

Error: invalid invocation of a non-isolated function in an 'isolated' function

It works if i remove isolated keyword from resource but i get warning

Warning: concurrent calls will not be made to this method since the method is not an 'isolated' method

Is this warning normal or will cause any problem in production?
So how do i call function compute with worker within it?

[MaryamZi]

Worker declarations (and start actions) are not allowed in isolated functions at the moment. However, with the upcoming Swan Lake Update 2 (2201.2.0) release they will be allowed if they meet a set of conditions.

The worker has to meet conditions similar to that of an isolated function for it to be allowed in an isolated function. Any reference to a local variable defined outside the worker will be treated similar to a captured variable with anonymous functions, and therefore, must refer to variables that are
both final (either explicitly or implicitly) and have a static type that is a
subtype of readonly|isolated object {} for the worker to be allowed an isolated function.

Since these conditions are met in your example, it will compile without an issue with Swan Lake Update 2.

Please see the release note draft for more details about this change.