feat(compiler): Abilities

[DieMyst]

No description provided.

[linear]

LNG-123 Introduce `scope` expression

On the early days of Fluence development, Aqua programs were very low-level, taking every service, every topology move as a first class citizen.

Now we have Workers, Clients, CLI, builtins like Registry, Spells, and so on. It brings new requirements on the table:

• Services are usually resolved by-alias, but available only on particular peers, e.g. Init peer or a Worker of the specified Subnet
• Service resolution is too verbose to do manually every time
• Services do not capture their location, so to call a service developer needs to wrap this service call with a closure, which might be hard to consider and takes a lot of boilerplate to do
• Topology with on … via … is very fragile, especially with workers: hard to understand whether you need to have this via or not?
• Complex behaviors, involving worker, host, init peer, and emergent systems like Registry, is being done on function level (with func …), which is again not easy wrt topology, service resolution

This proposal provides one more approach to solve better composability, help organizing libraries and reusing emergent behaviors, and simplify developers live.

Let's make two new top-level expressions, scope and lib, to describe the scope in the sense of topology, service resolutions, and local behaviors.

Example might look like the following:

-- Lib wraps some functions that needs topology provided
lib SpellLib:
  -- Need Spell service defined in scope
  Spell

  -- Closure
  run = ():
    -- Can use services, functions of the lib
    Spell.run_script()

-- Libraries may extend other libraries
lib WorkerSpellLib extends SpellLib:
  -- Resolve a service
  Spell "worker-spell"

  -- Require another Spell service to be resolved as OtherSpell
  -- So we can use two instances of the same service type
  Spell as OtherSpell

  -- Adding another closure
  stop = ():
    OtherSpell.kill_worker()

-- Scope definition may not be abstract: all services must be resolved, topology must be defined
scope Worker(peer: PeerId)
  -- May extend libs
  extends WorkerSpellLib
  -- Topology resolution is required
  on peer via HOST_PEER_ID:
    -- Unresolved services must be resolved
    OtherSpell "other-spell"

scope OtherWorker(peer: PeerId)
  -- May extend 0 or more scopes
  -- If extends a scope, topology resolution is delegated to that scope
  -- If extends more than one scope, topology resolutions of all scopes must be the same
  extends Worker(peer), OtherLib: -- extend a lib as well

    -- A scope may reference other scopes
    parent = PeerRootWorker(HOST_PEER_ID)

-- Usage of a scope from a detached function
func smth(peer: PeerId):
  -- Worker is a new data type that falls into the same namespace as arrows and variables
  worker = Worker(peer)

  -- OtherService is resolved in Worker, function is called on peer via HOST_PEER_ID
  worker.OtherSpell.callIt()

  -- closures capture worker's position
  worker.doLocally(peer)

  -- on ... via ... should be considered a super low level thing, so just no need to use it
  -- no need to do service resolutions; it should be eventually deprecated in service definitions and outside of scopes
  -- later, may do `func smth() on worker: Worker` or smth like that to move execution into given scope

[InversionSpaces]

Please, add comment on what this function returns. Also I think it would be better to define a case class for return type at this point.

[InversionSpaces]

nit:
(Exports[S].exports, getOutsideStreamNames).flatMapN { (oldExports, outsideDeclaredStreams) =>
(with import cats.syntax.apply)

[folex]

Is it possible to have several abilities of the same type passed to a single function?

[folex]

Is it possible to pass an array of abilities?

[InversionSpaces]

Suggested change

	SeqModel.wrap(ops.reverse: _*),
	SeqModel.wrap(ops.reverse),