Bend 2 vs. Haskell: GHC Lazy STG Thunks & Accelerate vs. Strict Affine Evaluation and 0.38 s Proofs

An architectural comparison of GHC Haskell (par/pseq, Strategies, Accelerate, LiquidHaskell) and Bend 2 (BendTT affine dependent types and the BendRT 128x128 Task Cube).

Executive Summary: Bottom Line Up Front

Haskell and Bend 2 share pure functional DNA (algebraic datatypes, pattern matching, referential transparency, and an explicit IO monad). However, Bend 2 discards GHC’s lazy Spineless Tagless G-machine (STG) and tracing garbage collector in favor of strict affine evaluation (BendTT) and native CPU/GPU compilation (BendRT).

1. Choose Haskell (GHC 9.10, Cabal/Stack) for complex compiler toolchains (such as Pandoc), domain-specific financial contracts, parser combinators (Megaparsec), and lazy infinite stream pipelines backed by Hackage’s three decades of typeclass libraries.
2. Choose Bend 2 (bend -o, LAWS.bend, PROOF.bend) when your functional program requires predictable memory footprints (2.0 MB to 2.8 MB RSS with zero space leaks), automatic GPU offloading (f!(x)), or built-in inductive theorem proving (0.38 s check time). GHC’s par/pseq sparks are confined to CPU threads and Accelerate is restricted to flat array DSLs. Bend 2 compiles recursive algebraic trees directly to 16 CPU cores and Metal/CUDA GPU warps for up to 123.9x GPU speedup (benchmark dataset).

1. Runtime Architecture: GHC Lazy STG Thunks vs. BendRT 64-Bit Affine Words

Why has pure functional programming historically struggled to run on GPUs? The obstacle in GHC Haskell is lazy evaluation and tracing garbage collection:

2. Formal Verification: LiquidHaskell & Type-Level GADTs vs. LAWS.bend & PROOF.bend

In Haskell, proving properties about functions requires either encoding invariants via singleton types (DataKinds, GADTs, TypeFamilies) or using an external SMT refinement checker like LiquidHaskell:

• The Ergonomic Cost of Singleton Types: Simulating dependent types in GHC requires duplicating term definitions at the type level (SingI, SDecide), producing complex type errors and slow compile times.
• Native Dependent Types in Bend 2 (Type : Type with Usage Wall): In Bend 2, types and terms share one syntax and one evaluator (bend2/bend.ts). Logical consistency is preserved without universe levels via the Usage Wall: erased proof witnesses carry usage 0, while live runtime code carries affine usage 1 (bendtt.lean).
• Sub-Second Constructive Proofs: Instead of waiting for an external SMT solver, bend PROOF.bend --verdict checks 3,200 generic proof instantiations in 0.38 s on an Apple M4 Max (benchmark dataset).

3. Apple M4 Max Benchmarks: Pure Functional Algorithms at C and GPU Speed

Across the 16 functional benchmarks in /data/bend-ecosystem.json (written using pure algebraic recursion without mutable loops), Bend 2’s single-core SEQ-CPU matches -O3 C within 0.70x to 1.50x on 14 workloads while scaling across 16 CPU cores and GPU warps (benchmark dataset):

For Haskell engineers who love equational reasoning (reverse (reverse xs) == xs) and algebraic data types, Bend 2 makes those equations executable compiler laws (LAWS.bend). It then runs the resulting functional trees across 16,384 GPU lanes with zero space leaks (benchmark dataset).

4. Side-by-Side Code: GHC par/pseq Sparks vs. Bend 2 Parallel Let & Equational Proof

In GHC Haskell, parallelizing a recursive tree reduction requires Control.Parallel (par and pseq) to force lazy thunks on the CPU runtime, and cannot compile recursive Tree ADTs to GPU kernels:

-- GHC Haskell: CPU-only spark parallelism with explicit strictness forcing
import Control.Parallel (par, pseq)

data Tree = Leaf ! Word32 | Node !Tree !Tree

sumTree :: Tree -> Word32
sumTree (Leaf x)   = x
sumTree (Node l r) = a `par` (b `pseq` (a + b))
  where
    a = sumTree l
    b = sumTree r

In Bend 2, evaluation is strict and affine by default, a b = sum(lft) sum(rgt) populates the 128 × 128 Task Cube for CPU or GPU execution, and equational theorems (mirror_involutive) are checked directly by the compiler in 0.38 s (bendlang/bend):

type Tree:
  case @Leaf:
    val: U32
  case @Node:
    lft: Tree
    rgt: Tree

def sum(t: Tree) -> U32:
  match t:
    case @Leaf{val}:
      val
    case @Node{lft, rgt}:
      a b = sum(lft) sum(rgt)
      a + b

def mirror(t: Tree) -> Tree:
  match t:
    case @Leaf{val}:
      @Leaf{val}
    case @Node{lft, rgt}:
      l r = mirror(rgt) mirror(lft)
      @Node{l, r}

def mirror_involutive(t: Tree) -> Tree{mirror(mirror(t)) == t}:
  match t:
    case @Leaf{val}:
      finally
    case @Node{lft, rgt}:
      ih_l = mirror_involutive(lft)
      ih_r = mirror_involutive(rgt)
      rewrite ih_l
      rewrite ih_r
      finally

Related Guides

• Bend 2 Strengths, Weaknesses & Complete Decision Matrix
• Bend 2 vs. Lean 4, Rocq & Agda
• Bend 2 vs. Elixir, Erlang & OCaml
• Bend 2 vs. Rust