Bend/HVM2 Interaction Net visualization

Use the wasd Keys to step trough the visualizations. All visualizations where generated in sequential mode.

Simple calculation

def main() -> u24:
  return ((1 * 2) + (3 * 4))

Sequential Sum of 1 to 5

def Sum(start, target):
  if start == target:
    return start
  else:
    return start + Sum(start + 1, target)

def main():
  # This translates to (1 + (2 + (3 + (...... + (999999 + 1000000)))))
  return Sum(1, 5)

Parallel Sum of 1 to 5

def Sum(start, target):
  if start == target:
    return start
  else:
    half = (start + target) / 2
    left = Sum(start, half)
    right = Sum(half + 1, target)
    return left + right

def main():
  # This translates to (((1 + 2) + (3 + 4)) + ... (999999 + 1000000)...)
  return Sum(1, 5)

Index a list

def index(list: List(_), idx: u24) -> _:
  match list:
    case List/Nil:
      return 99999
    case List/Cons:
      if idx == 0:
        return list.head
      else:
        return index(list.tail, idx - 1)

def main() -> u24:
  list = [0, 1, 2, 3, 4]
  return index(list, 2)

Index a list twice

def index(list: List(_), idx: u24) -> _:
  match list:
    case List/Nil:
      return 99999
    case List/Cons:
      if idx == 0:
        return list.head
      else:
        return index(list.tail, idx - 1)

def main() -> u24:
  list = [0, 1, 2, 3, 4]
  a = index(list, 2)
  b = index(list, 2)
  return a + b

Mergesort 16 elements

#
# Mergesort from https://github.com/HigherOrderCO/Bend/issues/606
#

from data import data_list

def split(list, len):
  switch len:
    case 0:
      return ([], list)
    case _:
      match list:
        case List/Cons:
          (left, right) = split(list.tail, len-1)
          return (List/Cons(list.head, left), right)
        case List/Nil:
          return ([], [])

def mergesort(list, len):
  match list:
    case List/Cons:
      match list.tail:
        case List/Cons:
          new_len = len / 2
          (left, right) = split(List/Cons(list.head, list.tail), new_len)
          return merge(mergesort(left, new_len), mergesort(right, len - new_len))
        case List/Nil:
          return [list.head]
    case List/Nil:
      return []

def merge(left, right):
  match left:
    case List/Cons:
      match right:
        case List/Cons:
          if (left.head <= right.head):
            return List/Cons(left.head, merge(left.tail, (right)))
          else:
            return List/Cons(right.head, merge(left, right.tail))
        case List/Nil:
          return left
    case List/Nil:
      return right

def main() -> u24:
  (len, list) = List/length(data_list)
  sorted = mergesort(list, len)
  match sorted:
    case List/Nil:
      return 99999
    case List/Cons:
      return sorted.head