T>;(define (h x gx)
T>;  (display gx)(display x)(newline))

T>;(define (g x)
T>;  set-cdr! x '(a b c))

T>;(define (f1 x)
T>;  (h x (g x)))
T>;(define (f2 x)
T>;  (h (g x) x))
T>;(f1 '(cat dog))
T>;(f2 '(cat dog))
T>;

(define (h x gx)
  (display gx)(display x)(newline))

(define (g x)
  (set-cdr! x x)
  "This is a scheme longcat: ")

(define (f x)
  (h x (g x)))

(f '(cat))

PGF95™ native OpenMP and auto-parallel Fortran 90/95 compiler
PGF77® native OpenMP and auto-parallel FORTRAN 77 compiler
PGF95™ native OpenMP and auto-parallel Fortran 90/95 compiler
PGF77® native OpenMP and auto-parallel FORTRAN 77 compiler
Threads-based auto-parallelization using both PGF77 and PGF95
Threads-based auto-parallelization of FOR loops in PGCC and PGC++
Full native OpenMP parallelization directives in PGF77 and PGF95
Full native OpenMP parallelization pragmas in PGCC and PGC++

We evaluate the performance achieved by our translation scheme on seven representative OpenMP applications, two from SPEC OMPM2001 and ve from the NAS Parallel Benchmarks suite, on two dierent platforms. The average scalability (execution time relative to the serial version) achieved is within 12% of that achieved by corresponding hand-tuned MPI applications.

T>>Попробуй. Если я ещё и доказательства прикручу в виде типов классов, то никакие generics не спасут.

{-# LANGUAGE EmptyDataDecls, GADTs, PatternSignatures, ScopedTypeVariables #-}
{-# LANGUAGE FlexibleContexts, MultiParamTypeClasses, FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}

-------------------------------------------------------------------------------
-- Type-level arithmetic.

class Nat a where
    fromNat :: a -> Int

data Z
data S n

instance Nat Z where
    fromNat _ = 0

instance Nat n => Nat (S n) where
    fromNat sn = 1+fromNat n
        where
            nsn :: S n -> n
            nsn = undefined
            n = nsn sn

class (Nat a, Nat b, Nat r) => Plus a b r | a b -> r, a r -> b
instance Nat b => Plus Z b b
instance (Nat a, Nat b, Nat r, Plus a b r) => Plus (S a) b (S r)

natPlus :: (Nat a, Nat b, Nat r, Plus a b r) => a -> b -> r; natPlus = undefined

class GE a b -- | a -> b, b -> a
instance           GE  Z     Z
instance           GE (S a)  Z
instance GE a b => GE (S a) (S b)

type ONE = S Z
type TWO = S (S Z)
type THREE = S TWO
type FOUR = S THREE
type EIGHT = S (S (S (S FOUR)))

-------------------------------------------------------------------------------
-- Buses and netlist elements.

data Bus size = Bus Int

type BitBus = Bus ONE

busSize :: Bus size -> size; busSize = undefined

type Netlist = [NetlistElem]

data NetlistElem where
    Join     :: (Nat sa, Nat sb, Plus sa sb sr)
             => Bus sa -> Bus sb -> Bus sr -> NetlistElem
    Split    :: (Nat high, Nat low, Nat big, Plus high low hl, GE big hl)
             => Bus big -> Bus high -> Bus low -> NetlistElem

G>Я не только MSDN читаю

unsafePerformIO :: IO a -> a

Использовать агенты в HPC — немного совсем малоэффективное решение.

Therefore, we refer to our scheme as partial-replication. Data replication comes at the cost of limiting the data scalability of programs that is, programs will not be able to handle n-times larger data sets on n processors.