HVM1

milar to how HVM works with their "Interaction nets"? https://github.com/HigherOrderCO/HVM https://www.idris-lang.org/ https://clojure.org/ I'm afraid I don't even understand what the difference between code, data, and types are anymore... it used to make sense, but these new languages have dissolved those boundaries in my mind, and I am not sure how to build it back up again.

heir rewrite counts. Here are the tables: Fn V1 N | rewrites - | -------- 0 | 402 1 | 802 2 | 1202 3 | 1602 4 | 2002 5 | 2402 6 | 2802 7 | 3202 8 | 3602 9 | 4002 Fn V2 N | rewrites - | -------- 0 | 1403 1 | 1408 2 | 1413 3 | 1418 4 | 1423 5 | 1428 6 | 1433 7 | 1438 8 | 1443 9 | 1448 From these numbers, we can tell V2 scales better than V1, without doing any benchmark. Not only that, but we're able to write explicit formulas for the runtime cost of each version: TimeComplexity(FnV1(N)) = 402 + 400*N rewrites TimeComplexity(FnV2(N)) = 1403 + 5*N rewrites Which means both are O(N), but V2 has a 80x smaller linear coefficient. This precision extends to memory and space too. This is why we're so excited to build Kindelia to apply HVM to the context of blockchain VMs, as this granular measurability isn't available on GHC, which is why Cardano can't use the Haskell compiler, and must resort to an interpreter, greatly affecting its throughput. Of course, this is just one of many the applications of the HVM.

f Interaction Net. Symmetric Interaction Combinators is not related to lambda calculus in a trivial way, and thus as noted in the README, HVM does not 'support' the full Lambda Calculus. In a vast majority of cases the HVM approach really does simply evaluate lambda terms at impressive speed, but the failure cases are quite tricky to handle, in that they will fail silently, simply evaluating the term incorrectly. This issue however, is acknowledged in the README and can be tackled by the method described there, or by type-checking for these 'failure' cases https://github.com/HigherOrderCO/HVM/discussions/97. The issue mentioned in #60 however, seems to be quite fundamental - HVM makes lambda evaluation fast by implementing lambda evaluation in terms of Symmetric Interaction Combinators and making sure each operation of SIC evaluates in constant time. This works in most cases, but as acknowledged in Asperti and Guerrini, in some cases the SIC representation of lambda terms simply become themselves very (exponentially) large. Victor appears to acknowledge that he is simply building a practical counterpart upon the theory as cited from Asperti and Guerrini, citing Asperti and Guerrini's 'safe rules', which has not yet been implemented, as his plan to prevent very large representations of lambda terms from occurring, but Asperti and Guerrini themselves acknowledge that their rules are probably incomplete. Crucially, these terms appear to show up in regular functional programming folds. The promise of HVM is that we have finally found a way to naturally implement the parallelism inherent in pure lambda terms, without special annotation or extra accommodation for the runtime. As it stands, HVM still falls short of the lofty dream.

p-and-borrowing-in... [1] https://verdagon.dev/blog/zero-cost-memory-safety-regions-pa... [2] https://www.strlen.com/lobster/ [3] https://github.com/HigherOrderCO/HVM