Making the IR more composable by allowing local references in addition to fully qualified ones

[AttilaMihaly]

Multiple community members brought up the wish to handle smaller portions of the IR as independent units instead of always working with an entire distribution. While the IR is very composable and you can independently define individual types or functions one specific design choice makes that less feasible:

The fact that we use fully qualified names in every reference (types, values, constructors) means that even when you are looking at a single definition you still need to be aware of the whole IR structure when you are trying to resolve a reference even if it is local.

To give a specific example when you are defining something like this:

module MyModule exposing (..)

type Foo = String

type Bar = Foo

The Morpir IR representation of this will look more like:

module MyModule exposing (..)

type Foo = Morphir.SDK.String

type Bar = MyPackage.MyModule.Foo

This means that if you are processing just this module and you get to Bar you need to know about the package name to understand that MyPackage.MyModule.Foo refers to the other type in the same module.

While this was a conscious design decision to avoid downstream consumers having to do name resolution, it is also limiting the composability of the IR.

We could change this by allowing references to be more local by defining something like this:

type Reference
    = ModuleLocalReference Name 
    | PackageLocalReference ModuleName Name
    | GlobalReference PackageName ModuleName Name

[DamianReeves]

I like the idea.

Are we talking about Reference in the Type module or some other new top-level Reference object?

Do you mind including an example on how it would manifest itself in the Type and Value IR? Is this intended to be a replacement for FQName or just a local substitute for FQName?

[AttilaMihaly]

I'm thinking of a new type that is then used in Type and Value. Looking at this a bit more, we already have these concepts in the form of Name, QName and FQName so we shoulkd probably use those:

module Morphir.IR.Ref exposing (..)

type Ref
    = ModuleLocalRef Name
    | PackageLocalRef QName
    | GlobalRef FQName

Then we can replace FQName in Reference in both places:

module Morphir.IR.Type exposing (..)

type Type a
    = ...
    | Reference a Ref (List (Type a))
    | ...

module Morphir.IR.Value exposing (..)

type Value ta va
    = ...
    | Reference va Ref
    | ...

How does that sound?

[DamianReeves]

That sounds good to me.
Though I think we probably want to also add that to Constructor for Value.

module Morphir.IR.Value exposing (..)

type Value ta va
    = ...
    | Constructor va Ref
    | Reference va Ref
    | ...

[AttilaMihaly]

Good point. I missed that. As discussed on Slack I'll turn this into an issue that we can pick up at some point.

[AttilaMihaly]

Issue created: #224