Ten patterns.
Two runtimes.

package Patterns

import System
import System.Collections.Generic

func poolProduce(count int32, jobs out chan[int32]) {
    try {
        for value in 0 ... count {
            jobs <- value
        }
    } finally {
        jobs.Close()
    }
}

func poolWorker(jobs in chan[int32], results out chan[int32]) {
    for job in jobs {
        results <- job * 2
    }
}

func poolWorkers(jobs in chan[int32], results out chan[int32]) {
    try {
        scope {
            for worker in 0 ... 4 {
                go poolWorker(jobs, results)
            }
        }
    } finally {
        results.Close()
    }
}

func runPool(count int32) int32 {
    let jobs = chan[int32](4)
    let results = chan[int32](4)
    let seen = HashSet[int32]()
    var sum = 0
    scope {
        go poolProduce(count, jobs)
        go poolWorkers(jobs, results)
        for value in results {
            verify(seen.Add(value), "duplicate result")
            sum += value
        }
    }
    verify(seen.Count == count, "lost work")
    return sum
}

func workerPoolExample() {
    verify(runPool(0) == 0, "empty pool")
    verify(runPool(40) == 1560, "pool result")
    Console.WriteLine("worker-pool count=40 sum=1560 empty=0")
}

package Patterns

import System
import System.Threading

class LimitState {
    public let Gate Object = Object()
    public var Active int32
    public var Peak int32
    public var Completed int32
    public var Failed int32
}

func limitedWork(id int32, permits SemaphoreSlim, state LimitState) {
    try {
        lock state.Gate {
            state.Active++
            state.Peak = Math.Max(state.Peak, state.Active)
        }
        try {
            if id == 7 {
                throw InvalidOperationException("expected work failure")
            }
            Thread.Yield()
        } catch (e InvalidOperationException) {
            lock state.Gate {
                state.Failed++
            }
        } finally {
            lock state.Gate {
                state.Active--
                state.Completed++
            }
        }
    } finally {
        permits.Release()
    }
}

func boundedExample() {
    using let permits = SemaphoreSlim(3, 3)
    let state = LimitState()
    scope {
        for id in 0 ... 24 {
            await permits.WaitAsync()
            go limitedWork(id, permits, state)
        }
    }
    verify(state.Peak <= 3, "concurrency limit")
    verify(state.Completed == 24 && state.Failed == 1, "completion or failure accounting")
    verify(state.Active == 0 && permits.CurrentCount == 3, "permit leak")
    Console.WriteLine("bounded limit=3 completed=24 failures=1 permits=3")
}

package Patterns

import Gsharp.Concurrency
import System
import System.Threading

class PipelineState {
    public var Exited int32
}

func pipelineProduce(count int32, output out chan[int32], state PipelineState, context Context) {
    try {
        for value in 0 ... count {
            output <- value
        }
    } catch (e OperationCanceledException) {
        if !context.IsCancelled {
            rethrow
        }
    } finally {
        output.Close()
        Interlocked.Increment(ref state.Exited)
    }
}

func pipelineDouble(input in chan[int32], output out chan[int32], state PipelineState, context Context) {
    try {
        for value in input {
            output <- value * 2
        }
    } catch (e OperationCanceledException) {
        if !context.IsCancelled {
            rethrow
        }
    } finally {
        output.Close()
        Interlocked.Increment(ref state.Exited)
    }
}

func runPipeline(size int32, stopAfter int32)(int32, int32) {
    let first = chan[int32](2)
    let second = chan[int32](2)
    let state = PipelineState()
    var count = 0
    var sum = 0
    scope {
        go pipelineProduce(size, first, state, ctx)
        go pipelineDouble(first, second, state, ctx)
        for value in second {
            count++
            sum += value
            if stopAfter > 0 && count == stopAfter {
                ctx.TryCancel()
                break
            }
        }
    }
    verify(state.Exited == 2, "pipeline did not join both stages")
    return (count, sum)
}

func pipelineExample() {
    let (empty, _) = runPipeline(0, 0)
    let (complete, total) = runPipeline(8, 0)
    let (partial, subtotal) = runPipeline(100, 3)
    verify(empty == 0 && complete == 8 && total == 56, "pipeline completion")
    verify(partial == 3 && subtotal == 6, "pipeline cancellation")
    Console.WriteLine("pipeline full=8/56 cancelled=3/6 joined=2 empty=0")
}

package Patterns

import Gsharp.Concurrency
import System
import System.Collections.Generic

func fanProduce(output out chan[int32], offset int32) {
    try {
        for value in 0 ... 5 {
            output <- offset + value
        }
    } finally {
        output.Close()
    }
}

func fanForward(input in chan[int32], output out chan[int32]) {
    for value in input {
        output <- value
    }
}

func fanSources(count int32, output out chan[int32]) {
    try {
        scope {
            for id in 0 ... count {
                let input = chan[int32](2)
                go fanProduce(input, id * 10)
                go fanForward(input, output)
            }
        }
    } finally {
        output.Close()
    }
}

func mergeSources(count int32) int32 {
    let output = chan[int32](2)
    let seen = HashSet[int32]()
    var sum = 0
    scope {
        go fanSources(count, output)
        for value in output {
            verify(seen.Add(value), "fan-in duplicated a value")
            sum += value
        }
    }
    verify(seen.Count == count * 5, "fan-in lost a value")
    return sum
}

func fanInExample() {
    verify(mergeSources(0) == 0, "empty fan-in")
    verify(mergeSources(3) == 180, "merged sum")
    let left = chan[int32](1)
    let right = chan[int32](1)
    left <- 1
    right <- 2
    left.Close()
    right.Close()
    var helperSum = 0
    for value in merge[int32](left, right) {
        helperSum += value
    }
    verify(helperSum == 3, "SDK merge helper")
    var empty = 0
    for value in merge[int32]() {
        empty++
    }
    verify(empty == 0, "empty SDK merge")
    Console.WriteLine("fan-in count=15 sum=180 empty=0")
}

package Patterns

import System
import System.Collections.Generic
import System.Threading

data class CacheEntry(Value string, Expires int64)

class TtlCache {
    private let gate ReaderWriterLockSlim = ReaderWriterLockSlim()
    private let entries Dictionary[string, CacheEntry] = Dictionary[string, CacheEntry]()
    private let ttl int64
    private let now() -> int64

    init(ttl int64, now() -> int64) {
        verify(ttl > 0, "TTL must be positive")
        this.ttl = ttl
        this.now = now
    }

    func Set(key string, value string) {
        gate.EnterWriteLock()
        defer gate.ExitWriteLock()
        let tick = now()
        verify(tick >= 0 && tick <= Int64.MaxValue - ttl, "TTL overflow")
        entries[key] = CacheEntry(value, tick + ttl)
    }

    func Get(key string) string? {
        gate.EnterReadLock()
        defer gate.ExitReadLock()
        if !entries.ContainsKey(key) {
            return nil
        }
        let entry = entries[key]
        return now() < entry.Expires ? entry.Value: nil
    }

    func Dispose() {
        gate.Dispose()
    }
}

func cacheAccess(cache TtlCache, id int32) {
    let key = id.ToString()
    cache.Set(key, key)
    verify(cache.Get(key) == key, "concurrent cache access")
}

func ttlCacheExample() {
    var tick int64 = 0
    let cache = TtlCache(10, () -> tick)
    try {
        verify(cache.Get("missing") == nil, "missing cache entry")
        cache.Set("a", "value")
        tick = 9
        verify(cache.Get("a") == "value", "early expiry")
        tick = 10
        verify(cache.Get("a") == nil, "expiry boundary")
        scope {
            for id in 0 ... 40 {
                go cacheAccess(cache, id)
            }
        }
        tick = Int64.MaxValue
        var rejected = false
        try {
            cache.Set("overflow", "value")
        } catch (e InvalidOperationException) {
            rejected = e.Message == "TTL overflow"
        }
        verify(rejected, "expiry overflow")
    } finally {
        cache.Dispose()
    }
    Console.WriteLine("ttl-cache hit=1 expired=1 missing=1 concurrent=40")
}

package Patterns

import System
import System.Collections.Generic
import System.Threading

class Bucket {
    public var Tokens int32
    public var Last int64
    init(tokens int32, last int64) {
        Tokens = tokens
        Last = last
    }
}

class KeyedLimiter {
    private let gate Object = Object()
    private let buckets Dictionary[string, Bucket] = Dictionary[string, Bucket]()
    private let capacity int32
    private let period int64

    init(capacity int32, period int64) {
        verify(capacity > 0 && period > 0, "positive capacity and period required")
        this.capacity = capacity
        this.period = period
    }

    func Allow(key string, now int64) bool {
        lock gate {
            if !buckets.ContainsKey(key) {
                buckets[key] = Bucket(capacity, now)
            }
            let bucket = buckets[key]
            verify(now >= bucket.Last, "clock moved backwards")
            let added = (now - bucket.Last) / period
            if added > 0 {
                bucket.Tokens = added >= capacity - bucket.Tokens ? capacity: bucket.Tokens + int32(added)
                bucket.Last += added * period
            }
            if bucket.Tokens == 0 {
                return false
            }
            bucket.Tokens--
            return true
        }
    }
}

class RateState {
    public var Accepted int32
}

func requestToken(limiter KeyedLimiter, state RateState) {
    if limiter.Allow("parallel", 200) {
        Interlocked.Increment(ref state.Accepted)
    }
}

func rateLimitExample() {
    let limiter = KeyedLimiter(2, 10)
    verify(limiter.Allow("a", 0) && limiter.Allow("a", 0), "initial burst")
    verify(!limiter.Allow("a", 5), "fractional refill")
    verify(limiter.Allow("b", 5), "independent key")
    verify(limiter.Allow("a", 10) && !limiter.Allow("a", 10), "refill boundary")
    verify(limiter.Allow("a", 100) && limiter.Allow("a", 100) && !limiter.Allow("a", 100), "capacity cap")
    let state = RateState()
    scope {
        for id in 0 ... 40 {
            go requestToken(limiter, state)
        }
    }
    verify(state.Accepted == 2, "atomic token admission")
    var rejected = false
    try {
        limiter.Allow("a", 0)
    } catch (e InvalidOperationException) {
        rejected = e.Message == "clock moved backwards"
    }
    verify(rejected, "backwards clock")
    Console.WriteLine("rate-limit burst=2 refill=1 parallel=2 rollback=rejected")
}