逻辑题：如果 Go 的运行时刻意禁用了所有的堆内存分配（Heap-free），你该如何设计一个完整的 HTTP 服务器？

尊敬的各位技术专家、开发者同仁：

欢迎来到今天的讲座，我们将探讨一个在 Go 语言领域极具挑战性且引人深思的话题：如何在 Go 运行时刻意禁用所有的堆内存分配（Heap-free），从而设计并实现一个完整的 HTTP 服务器。这听起来似乎与 Go 语言的核心哲学——即通过垃圾回收（GC）简化内存管理——背道而驰，但正是这种“极限生存”的挑战，能够帮助我们更深刻地理解 Go 语言的底层机制，以及在面对极端性能或资源受限场景时，如何挖掘其潜力。

追求极致性能与可预测性：为何要“禁用堆内存”？

Go 语言以其高效的并发模型、简洁的语法和强大的标准库而闻名，已成为构建高性能网络服务和分布式系统的首选语言之一。其内置的垃圾回收（GC）机制极大地简化了内存管理，降低了内存泄漏的风险，并提升了开发效率。然而，在某些对延迟、吞吐量可预测性或资源消耗有极其严苛要求的场景中，即使是 Go 语言高度优化的并发垃圾回收器，也可能引入短暂但不可接受的停顿（GC Latency）。

这些场景包括：

1. 高频交易系统（HFT）：毫秒甚至微秒级的延迟差异都可能意味着巨大的经济损失。任何由 GC 引起的微小停顿都必须被消除。
2. 实时音视频处理：需要连续、低延迟的数据流，GC 停顿可能导致音视频卡顿或不同步。
3. 嵌入式系统或边缘计算设备：这些设备通常内存资源极其有限，且要求程序运行具有高度可预测性，避免因内存动态分配而产生的不可控行为。
4. 软实时系统：对响应时间有一定上限要求，GC 暂停可能导致错过截止时间。

在这些场景下，传统的堆内存分配和垃圾回收模型可能成为瓶颈。因此，探索一种“堆内存无关”（Heap-free）的编程范式，即在程序运行时不进行任何动态堆内存分配，所有内存都预先分配或在栈上分配，就变得有意义。这并非 Go 语言的常规用法，而是一种为了特定目标而采取的极端优化策略。

Go 语言的内存管理与垃圾回收机制概述

在深入探讨堆内存无关的 HTTP 服务器设计之前，我们有必要回顾一下 Go 语言的内存管理基础。

Go 运行时通过其内存分配器（runtime/malloc.go）管理堆内存。它向操作系统申请大块内存（称为 Arena），然后将这些大块内存细分为不同大小的 Span。当程序需要内存时，分配器会从这些 Span 中分配对象。

Go 1.8 以后引入的并发标记清除（Concurrent Mark-Sweep）垃圾回收器，旨在最大程度地减少应用程序的“Stop The World”（STW）停顿时间。它将 GC 周期的大部分工作与应用程序并发执行，仅在少数关键阶段（如标记根对象、清扫阶段的某些同步点）需要短暂暂停所有 goroutine。

Go GC 的优点：

• 自动化：开发者无需手动管理内存，降低了心智负担。
• 安全性：有效防止了内存泄漏和悬垂指针等常见内存错误。
• 效率：Go GC 经过高度优化，在大多数场景下性能表现出色。

Go GC 的潜在局限性（对于极端场景）：

• STW 暂停：尽管 Go GC 努力减少 STW 时间，但在某些情况下（如堆内存非常大、并发压力极高时），仍可能发生短暂的暂停。
• 内存分配开销：即使没有 GC 暂停，内存分配本身也需要时间。频繁的小对象分配会增加分配器的负担，并可能加速 GC 触发。
• 内存峰值：动态内存分配可能导致程序在特定时刻的内存占用达到峰值，这在内存受限的环境中是不可接受的。

“堆内存分配禁用”的精确含义在 Go 语境下

在 Go 语言中，实现一个真正意义上的“堆内存无关”程序，意味着我们需要严格遵守以下原则：

1. 杜绝 make 的使用：不通过 make 函数创建任何切片 ([]T)、映射 (map[K]V)、通道 (chan T)，因为这些操作都会在堆上分配内存。
2. 避免 new 和 &Type{} 语法：不使用 new 关键字或结构体字面量 &Type{} 来创建结构体实例，因为这些同样会导致堆分配。
3. 禁止切片扩容：绝不使用 append 操作导致切片底层数组的重新分配（reallocation）。所有切片必须在程序启动时预分配足够大的容量，并在后续操作中严格限制在其容量之内。
4. 消除 string 的新创建：Go 语言的 string 类型是不可变的，通常存储在堆上。任何从 []byte 到 string 的转换、字符串拼接或子字符串提取，如果产生新的 string 对象，都必须避免。
5. 规避标准库的隐式堆分配：Go 标准库中的许多函数和方法，尤其是在 io、net、fmt 等包中，都会在内部进行堆分配。我们需要绕开这些函数，或者使用它们的底层原语。
6. 手动内存管理：利用 unsafe 包来直接操作内存地址，将内存视为一个连续的字节序列。

这意味着，我们将把所有需要的数据结构和缓冲区，在程序启动时就一次性地预分配到一块连续的内存区域中，并在程序的整个生命周期内复用这些资源。

构建堆内存无关 Go 程序的基石

为了实现一个堆内存无关的 HTTP 服务器，我们需要一系列定制化的基础构建块。

1. 内存竞技场（Memory Arena）

内存竞技场是一种高效的内存管理技术，特别适用于生命周期管理简单的场景（如处理一个 HTTP 请求的整个过程中所需的内存）。它预先从操作系统申请一大块连续内存，然后在这个大块内部进行小块的线性分配。分配时只需简单地移动一个指针，因此速度极快，是 O(1) 操作，且没有内存碎片问题。

实现挑战：在 Go 中，我们无法直接声明一个“静态”的、非 Go 堆管理的巨大切片。make([]byte, size) 总是会导致堆分配。为了真正实现堆内存无关，我们需要：

• Cgo 与 mmap：通过 Cgo 调用 C 语言的 malloc 或 mmap 系统调用，从操作系统层面获取一块不归 Go GC 管理的原始内存。
• 全局静态变量：对于较小的、编译时已知大小的数据，可以声明为全局变量，它们通常会被编译器放置在程序的 .data 或 .bss 段，而非 Go 堆。但对于大块内存，Go 编译器可能仍会将其内容初始化到堆上。
• unsafe 包：获取这块原始内存的起始地址，并使用 unsafe.Pointer 和 uintptr 进行操作。

为了本讲座的演示目的，我们假设 NewArena 能够获取到一块“外部”的、不被 Go GC 管理的内存地址。在实际生产环境中，这通常通过 Cgo 与 mmap 结合来实现。

package main

import (
    "fmt"
    "reflect"
    "sync"
    "unsafe"
)

const (
    // 定义 Arena 的总大小，例如 16MB
    // 在实际应用中，这个大小需要根据预期的最大内存需求来确定。
    arenaSize = 16 * 1024 * 1024
)

// Arena 结构体管理一块预分配的连续内存。
// 所有的分配都发生在这块内存内部，不触发 Go 的堆分配。
type Arena struct {
    mu sync.Mutex // 保护并发访问
    // base 是内存块的起始地址。
    // 在真正的 heap-free 场景下，这通常来自 Cgo 的 mmap/malloc
    // 或一个非常大的全局静态数组的地址。
    base unsafe.Pointer
    // ptr 是当前分配的指针位置，每次分配后向后移动。
    ptr uintptr
    // limit 是内存块的结束地址，用于检查是否越界。
    limit uintptr
}

// NewArena 初始化一个新的 Arena。
// 参数 size 是 Arena 的总字节大小。
// 重要的假设：这里 base 和 limit 之间的内存是预先分配好的，且不属于 Go GC 管理的堆。
// 为了演示，我们使用一个全局的静态数组来模拟这个非 Go 堆内存。
// 注意：在实际 Go 程序中，如果 globalStaticMemory 足够大，Go 编译器可能会将其内容放在堆上。
// 最严格的 heap-free 方法是使用 Cgo 调用 `mmap` 或 `VirtualAlloc`。
var globalStaticMemory [arenaSize]byte

func NewArena(size uintptr) (*Arena, error) {
    // 获取全局静态数组的起始地址
    base := unsafe.Pointer(&globalStaticMemory[0])
    ptr := uintptr(base)
    limit := ptr + size

    return &Arena{
        base:  base,
        ptr:   ptr,
        limit: limit,
    }, nil
}

// Alloc 从 Arena 分配指定大小的内存，并确保内存对齐。
// size: 需要分配的字节数。
// alignment: 对齐字节数 (例如 8 字节对齐)。
// 返回一个 unsafe.Pointer，指向分配到的内存块。
func (a *Arena) Alloc(size, alignment uintptr) (unsafe.Pointer, error) {
    a.mu.Lock()
    defer a.mu.Unlock()

    // 计算对齐后的地址
    currentPtr := a.ptr
    // (currentPtr + alignment - 1) 向上取整到 alignment 的倍数
    alignedPtr := (currentPtr + alignment - 1) &^ (alignment - 1)

    if alignedPtr+size > a.limit {
        return nil, fmt.Errorf("arena out of memory: requested %d bytes (aligned to %d), available %d bytes",
            size, alignment, a.limit-alignedPtr)
    }

    a.ptr = alignedPtr + size
    return unsafe.Pointer(alignedPtr), nil
}

// Reset 将 Arena 的分配指针重置回起始位置，但不释放底层内存。
// 这使得 Arena 中的所有内存可以被重新使用，实现了高效的批量内存回收。
func (a *Arena) Reset() {
    a.mu.Lock()
    defer a.mu.Unlock()
    a.ptr = uintptr(a.base)
}

// AllocBytes 从 Arena 分配一个指定大小的 []byte 切片。
// 返回的切片其底层数组在 Arena 内部，不触发 Go 堆分配。
func (a *Arena) AllocBytes(size int) ([]byte, error) {
    ptr, err := a.Alloc(uintptr(size), 1) // 字节切片通常只需 1 字节对齐
    if err != nil {
        return nil, err
    }
    // 使用 reflect.SliceHeader 和 unsafe 包将原始指针转换为 []byte。
    // 注意：这里的切片头本身（Data, Len, Cap）可能在栈上或预分配的结构体中，
    // 但其指向的数据始终在 Arena 中。
    header := reflect.SliceHeader{
        Data: uintptr(ptr),
        Len:  size,
        Cap:  size,
    }
    return *(*[]byte)(unsafe.Pointer(&header)), nil
}

// AllocObject 从 Arena 分配一个指定类型 T 的对象，并返回其指针。
// 参数 objType 是对象的 reflect.Type。
// 返回的 interface{} 实际是一个 *T。
func (a *Arena) AllocObject(objType reflect.Type) (interface{}, error) {
    size := objType.Size()
    alignment := objType.Align()

    ptr, err := a.Alloc(size, alignment)
    if err != nil {
        return nil, err
    }
    // 使用 reflect.NewAt 创建一个指向 Arena 内存的类型化指针。
    // 注意：reflect.NewAt 本身不会分配新的内存，它只是在给定地址上“构造”一个值。
    return reflect.NewAt(objType, ptr).Interface(), nil
}

2. 对象池（Object Pool）与缓冲区池（Buffer Pool）

为了避免频繁的内存分配和 GC 压力，对象复用是关键。标准库 sync.Pool 提供了对象复用机制，但在严格的堆内存无关场景中，sync.Pool 仍然可能在内部进行堆分配（例如，当池为空时调用 New 函数，或者池的内部结构本身）。因此，我们需要一个自定义的、基于预分配内存的池。

我们的自定义池将基于 Arena 分配的缓冲区或结构体。

// MyBufferPool 是一个用于 []byte 缓冲区的自定义池。
// 内部使用一个 chan 来实现简单的并发安全队列。
// 注意：chan 本身在 Go 中是堆分配的。为了严格 heap-free，
// 这里的 `make(chan)` 必须在程序启动时执行一次，其开销被认为是初始化成本，
// 或者使用基于 Arena/静态数组的自定义无锁队列。
// 在本演示中，我们接受 `make(chan)` 的初始堆分配，但池中的缓冲区本身是 heap-free 的。
type MyBufferPool struct {
    pool chan []byte // 存放可用的缓冲区
    size int         // 池中每个缓冲区的固定大小
}

// NewMyBufferPool 创建一个新的缓冲区池。
// bufferCount: 池中缓冲区的数量。
// bufferSize: 每个缓冲区的大小。
// arena: 用于分配底层缓冲区的 Arena 实例。
func NewMyBufferPool(bufferCount, bufferSize int, arena *Arena) (*MyBufferPool, error) {
    p := &MyBufferPool{
        pool: make(chan []byte, bufferCount), // chan 结构体本身是堆分配，但只发生一次
        size: bufferSize,
    }

    // 从 Arena 分配所有缓冲区，并放入池中。
    for i := 0; i < bufferCount; i++ {
        buf, err := arena.AllocBytes(bufferSize)
        if err != nil {
            return nil, fmt.Errorf("failed to allocate buffer %d from arena for pool: %w", i, err)
        }
        p.pool <- buf
    }
    return p, nil
}

// Get 从池中获取一个缓冲区。
func (p *MyBufferPool) Get() []byte {
    return <-p.pool
}

// Put 将缓冲区归还给池。
func (p *MyBufferPool) Put(buf []byte) {
    // 确保归还的缓冲区大小正确，防止误用。
    if cap(buf) != p.size {
        // 在严格的系统中，这可能是一个 panic 或致命错误。
        panic(fmt.Sprintf("buffer size mismatch when returning to pool: expected %d, got %d", p.size, cap(buf)))
    }
    p.pool <- buf
}

// MyObjectPool 是一个通用的对象池，用于复用指定类型的结构体实例。
// 同样，chan 的堆分配仅限于初始化阶段。
type MyObjectPool struct {
    pool chan interface{}
    objType reflect.Type
}

// NewMyObjectPool 创建一个新的对象池。
// count: 池中对象的数量。
// objType: 对象的反射类型。
// arena: 用于分配底层对象的 Arena 实例。
func NewMyObjectPool(count int, objType reflect.Type, arena *Arena) (*MyObjectPool, error) {
    p := &MyObjectPool{
        pool: make(chan interface{}, count),
        objType: objType,
    }

    for i := 0; i < count; i++ {
        obj, err := arena.AllocObject(objType)
        if err != nil {
            return nil, fmt.Errorf("failed to allocate object %d of type %s from arena for pool: %w", i, objType.String(), err)
        }
        p.pool <- obj
    }
    return p, nil
}

// GetObject 从池中获取一个对象。
func (p *MyObjectPool) GetObject() interface{} {
    return <-p.pool
}

// PutObject 将对象归还给池。
func (p *MyObjectPool) PutObject(obj interface{}) {
    if reflect.TypeOf(obj) != p.objType {
        panic(fmt.Sprintf("object type mismatch when returning to pool: expected %s, got %s", p.objType.String(), reflect.TypeOf(obj).String()))
    }
    p.pool <- obj
}

3. 避免 string 分配与 ByteString 视图

Go 的 string 类型是不可变的，且通常在堆上分配。任何从 []byte 到 string 的转换都会导致新的堆分配。为了避免这种情况，我们采取以下策略：

• 直接使用 []byte：尽可能直接操作字节切片。
• ByteString 视图：定义一个自定义结构体 ByteString，它不拥有数据，而是作为底层 []byte 的一个不可变视图（指向原始字节数据和长度）。
• 字符串内部化（String Interning）：对于频繁出现的、固定的字符串（如 HTTP 方法 "GET"、"POST"，或常见的 HTTP 头字段 "Host"、"Content-Type"），在程序启动时预先创建它们，并确保它们的底层字节数据存储在静态内存区域，然后复用这些 ByteString 实例。

// ByteString 结构体，作为底层 []byte 的一个视图，避免堆分配。
// 它仅包含指向原始字节数据的指针和长度。
type ByteString struct {
    ptr  unsafe.Pointer // 指向底层字节数据
    len  int            // 数据的长度
    hash uint32         // 可选：预计算哈希值，用于快速比较和查找
}

// FromBytes 初始化 ByteString，使其指向给定的 []byte。
// 不会复制数据，也不会进行堆分配。
func (bs *ByteString) FromBytes(b []byte) {
    if len(b) == 0 {
        bs.ptr = nil
        bs.len = 0
        bs.hash = 0
        return
    }
    bs.ptr = unsafe.Pointer(&b[0])
    bs.len = len(b)
    // 预计算哈希，例如 FNV-1a 算法，用于快速比较。
    h := uint32(2166136261) // FNV offset basis
    for i := 0; i < bs.len; i++ {
        h ^= uint32(*(*byte)(unsafe.Pointer(uintptr(bs.ptr) + uintptr(i))))
        h *= 16777619 // FNV prime
    }
    bs.hash = h
}

// Equals 比较两个 ByteString 是否相等，高效且无堆分配。
func (bs *ByteString) Equals(other *ByteString) bool {
    if bs.len != other.len {
        return false
    }
    if bs.hash != other.hash { // 快速路径：哈希不一致则不相等
        return false
    }
    // 逐字节比较，确保内容完全一致
    for i := 0; i < bs.len; i++ {
        b1 := *(*byte)(unsafe.Pointer(uintptr(bs.ptr) + uintptr(i)))
        b2 := *(*byte)(unsafe.Pointer(uintptr(other.ptr) + uintptr(i)))
        if b1 != b2 {
            return false
        }
    }
    return true
}

// ToString 将 ByteString 转换为 Go string。
// 注意：此操作会触发堆分配，因为 Go string 是不可变的且通常存储在堆上。
// 仅在绝对必要（例如与标准库交互）且可以接受一次性堆分配的场景下使用，
// 或者用于调试输出。在核心逻辑中应避免。
func (bs *ByteString) ToString() string {
    if bs.len == 0 {
        return ""
    }
    // 创建一个新的 Go string，其底层数据从 ByteString 指向的内存复制而来。
    // 这会引发堆分配。
    return string(unsafe.Slice((*byte)(bs.ptr), bs.len))
}

// InternedStrings：预先内部化的常用字符串。
// 这些字符串的底层字节数据在程序启动时被分配（或在编译时嵌入），
// 并且它们的 ByteString 视图可以被安全地复用，而不会引起运行时堆分配。
var (
    // 用于内部化字符串的辅助函数，确保其底层字节数据是静态的。
    // 注意：这里的 `[]byte(s)` 仍然会产生堆分配，
    // 但我们假设这个过程发生在程序启动时，且其结果的内存是“持久化”的。
    // 更严格的做法是：这些字节数据是硬编码到二进制文件的数据段中，
    // 然后通过 unsafe.Pointer 直接指向这些地址。
    // 为了演示，我们接受此初始分配一次。
    globalInternedBytes [1024]byte // 假设一个足够大的静态缓冲区存放所有内部化字符串的字节数据
    globalInternedOffset int

    // internStringHelper 用于在启动时将 Go string 转换为 ByteString 并存储在静态内存中
    internStringHelper = func(s string) ByteString {
        b := []byte(s) // 这会是堆分配，但仅在启动时进行一次
        if globalInternedOffset+len(b) > len(globalInternedBytes) {
            panic("Static interned string buffer exhausted")
        }
        copy(globalInternedBytes[globalInternedOffset:], b)
        bs := ByteString{}
        bs.FromBytes(globalInternedBytes[globalInternedOffset : globalInternedOffset+len(b)])
        globalInternedOffset += len(b)
        return bs
    }

    // 预内部化的 HTTP 方法和头部名称
    // 它们的底层数据存储在 globalInternedBytes 中，不引起运行时堆分配。
    InternedGET    = internStringHelper("GET")
    InternedPOST   = internStringHelper("POST")
    InternedHost   = internStringHelper("Host")
    InternedUserAgent = internStringHelper("User-Agent")
    InternedContentType = internStringHelper("Content-Type")
    InternedContentLength = internStringHelper("Content-Length")
    InternedHTTP11 = internStringHelper("HTTP/1.1")
    InternedOK     = internStringHelper("OK")
    InternedNotFound = internStringHelper("Not Found")
    InternedBadRequest = internStringHelper("Bad Request")
    InternedCRLF   = internStringHelper("rn") // 换行符也内部化
)

重新构想 HTTP 服务器架构

Go 标准库的 net/http 包大量使用了堆分配（例如，http.Request 和 http.Response 结构体、各种缓冲区、map 等）。为了实现堆内存无关，我们必须从头开始，以字节为单位，使用我们的堆内存无关基石来构建 HTTP 协议的各个层。

1. 网络层：net.Listener 与 net.Conn 的封装

• 避免 net.Listen 和 net.Accept 的堆分配：net.Listen 返回的 net.Listener 和 listener.Accept() 返回的 net.Conn 都是接口类型，其底层实现（如 *net.TCPConn）在 Go 运行时通常是堆分配的。我们需要直接使用 syscall 包来创建和管理 socket 文件描述符（FD）。
• 预分配连接结构体：为每个并发连接预分配一个 SimulatedConn 结构体，它将持有 socket FD、读写缓冲区（从 MyBufferPool 获取）以及其他连接状态。

// SimulatedConn 封装了底层的文件描述符和缓冲区，用于一个 HTTP 连接。
// 整个结构体及其字段都设计为堆内存无关。
type SimulatedConn struct {
    fd           int          // socket 文件描述符
    remoteAddr   ByteString   // 远程地址 (作为 ByteString 视图)
    localAddr    ByteString   // 本地地址 (作为 ByteString 视图)
    readBuffer   []byte       // 读缓冲区，从 MyBufferPool 获取
    writeBuffer  []byte       // 写缓冲区，从 MyBufferPool 获取
    readOffset   int          // 读缓冲区当前处理位置
    writeOffset  int          // 写缓冲区当前写入位置
    closed       bool         // 连接是否已关闭
    // ... 其他连接状态，如超时计时器等
}

// initForNewConn 在复用 SimulatedConn 时重置其状态，准备处理新连接。
// 避免在每次新连接时创建新的结构体。
func (c *SimulatedConn) initForNewConn(fd int, remoteAddr, localAddr ByteString, readBuf, writeBuf []byte) {
    c.fd = fd
    c.remoteAddr = remoteAddr
    c.localAddr = localAddr
    c.readBuffer = readBuf
    c.writeBuffer = writeBuf
    c.readOffset = 0
    c.writeOffset = 0
    c.closed = false
}

// ReadRaw 从 socket 读取原始字节到预分配的缓冲区。
// 实际应用中会调用 syscall.Read。
func (c *SimulatedConn) ReadRaw() (n int, err error) {
    // 实际代码中：n, err = syscall.Read(c.fd, c.readBuffer[c.readOffset:])
    // 为了演示，我们模拟读取 HTTP 请求。
    mockRequest := []byte("GET /hello HTTP/1.1rnHost: example.comrnUser-Agent: Go-Heap-Free-ClientrnAccept: */*rnrn")
    if c.readOffset+len(mockRequest) > len(c.readBuffer) {
        return 0, fmt.Errorf("read buffer too small for mock request")
    }
    copy(c.readBuffer[c.readOffset:], mockRequest)
    n = len(mockRequest)
    c.readOffset += n
    return n, nil
}

// WriteRaw 将原始字节从预分配的缓冲区写入 socket。
// 实际应用中会调用 syscall.Write。
func (c *SimulatedConn) WriteRaw() (n int, err error) {
    // 实际代码中：n, err = syscall.Write(c.fd, c.writeBuffer[:c.writeOffset])
    // 为了演示，我们打印模拟写入内容。
    // fmt.Printf("SimulatedConn: Writing %d bytes:n%sn", c.writeOffset, string(c.writeBuffer[:c.writeOffset]))
    n = c.writeOffset // 假设全部写入
    c.writeOffset = 0 // 重置写入偏移
    return n, nil
}

// Close 关闭连接的 FD。
// 实际应用中会调用 syscall.Close。
func (c *SimulatedConn) Close() error {
    if !c.closed {
        // syscall.Close(c.fd) // 实际关闭 FD
        c.closed = true
    }
    return nil
}

2. 请求/响应解析与构建

• 预分配的请求/响应结构体：定义 HTTPRequest 和 HTTPResponse 结构体。所有字符串字段都替换为 ByteString，指向底层的读写缓冲区。所有头字段也使用预分配的数组。
• 字节流解析器：实现一个基于状态机的 HTTP 协议解析器，逐字节地从连接的读缓冲区中解析请求。解析过程中，不创建任何新的切片或字符串，所有数据都直接引用原始读缓冲区。

const (
    MaxHeaders = 32 // 每个请求/响应预分配的最大头部数量
)

// HTTPHeader 堆内存无关的头部键值对。
type HTTPHeader struct {
    Key   ByteString
    Value ByteString
}

// HTTPRequest 堆内存无关的请求结构体。
// 所有字段都设计为不引起堆分配。
type HTTPRequest struct {
    Method      ByteString
    Path        ByteString
    Version