HiLang 2.2.0

• .NETStandard 2.0

  • FSharp.Core (>= 9.0.201)
  • FsLexYacc (>= 11.3.0)
  • FsLexYacc.Runtime (>= 11.3.0)
  • Microsoft.CodeAnalysis.Analyzers (>= 3.11.0)
  • Microsoft.CodeAnalysis.CSharp (>= 4.13.0)
  • Nerdbank.GitVersioning (>= 3.7.115)

https://www.cepheis.com/hiperspace/20250329
     # Overview
     This release introduces transitive edges, which extend the Graph model provided by `Node` and `Edge` views to include transitive traversal of an entire graph without the need for recursive queries of esoteric query languages and integrated with the data views provided by `Hiperspace`.  `Graph.TransitiveEdge` encapsulates all the Edges that can be projected as a Transitive Edge using a simple set of rules.

     [Transitive Edge blog](https://www.cepheis.com/blog/blog/transitive-edge)  and [Enterprise Transitive Edge](https://www.cepheis.com/blog/blog/enterprise-transitive-edge) goes into the details of our model of `Transitive Edge`, but the [graph-automorphic](https://en.wikipedia.org/wiki/Graph_automorphism) view is that a `Transitive Edge` encapsulates all the edges between *nodes* and allows the user to focus on the ends rather than the intermediate steps between them, and view the data as relations using commodity business intelligence software without *esoteric* graph query languages.

     ## Hiperspace

     The [Hiperspace](Hiperspace) package includes the additional `Graph` package types

     | Name |░| Notes |
     |-|-|-|
     | GraphFunctions || static functions that can be sued directly, or via import in a *.hilang* schema |
     | Route || Value type that defines name and rules for projecting `Edge` as `Transitive Edge` and extending to all related nodes |
     | Rule || The rules for matching {From node type, edge type, to node type} Edges, to the transititive edge projection |

     ### SubSpace
     * `SubSpace` includes an  additional *view* `SetSpace` `TransitiveEdges` that includes all elements that implement this view
     * `FindPaths` inteface function provides a method that matches the `Graph.GraphFunctions.Paths` function, but in a way that *domain spaces* can send the graph search to a server for parallel execution on computers that have many CPU cores.

     ### Fix PartitionSpace and GenerationSpace
     These two Space interceptors provide the partitioning of data by *hash-bucket* and *date-range*, but fault in the implementation of state-machine to implement `IAsyncEnumerable<>` in .NET9, can result in the *map/reduce* channel being disposed before the last message is processed (*warning to the wise: don't use AI generated suggestions without considering the stress-environments that it doesn't have a clue about*)

     # Hilang
     The [HiLang](HiLang) schema compiler has been enhanced to include the additional {**function**, **value**,**view**,**segment**}  declarations for  features of  `Hiperspace`.

     There are three ways that an element can project a view in Hilang:
     * `entity Person = Node (From = member/this, To = member/this, Name="value", TypeName = "Person")` where each member of the view is mapped to a specific member of the element
     * `entity Person = Node()` where the view members are automatically matched by name with members of the element
     * `entity Name =  View_Name = member`  **This language element has been enhanced to include a set of values** e.g. the set returned from `TransitativeEdge` function

     # Hiperspace.SQL
     The [Hiperspace.SQL](Hiperspace.SQL) already includes the ability to access deep structure methods like `SELECT p.Father.Name AS Father FROM Persons AS p  WHERE p.Name = :parameter;', but now also allows deep structure to members to be used in `FROM` clauses to join to segments and sets within each row.

     e.g. `Person` has an extension segment `MotherChild` and property `AllRelatives` that yields a `HashSet<TransitiveEdge>`, which can now be joined to in a SQL query.

     ```
     select  p.Name as Person,
     r.To.Name as Relation,
     r.TypeName as Relationship,
     r.Length as Length,
     r.Width as Width
     from    Persons as p,
     p.AllRelatives as r
     where   p.Name = :name;

     select  p.Name as Parent, c.Name as Child
     from    Persons as p,
     p.MotherChild as c
     where   p.Name = :name;
     ```