1. 库介绍

Adobe Source Libraries (ASL)，现在由 stlab 维护，是一组专注于提供高质量、经过实战检验的 C++ 组件的集合。它最初由 Adobe 公司开发，旨在解决构建复杂桌面应用程序（如 Photoshop, Illustrator 等）中遇到的常见挑战。ASL 的核心目标是提升 C++ 开发的抽象层次，提供更安全、更健壮、更易于维护的基础设施。

这个库并非一个大而全的框架，而是一系列相对独立但设计理念一致的模块，开发者可以根据需要选用。其设计哲学深受泛型编程、函数式编程以及对 C++ 语言特性深刻理解的影响，强调正确性、性能和表达力。

ASL 的主要贡献在于引入了一些强大的抽象概念，尤其是在用户界面 (UI) 布局、数据模型和并发处理方面。它提供了一套不同于传统 C++ 库（如 Boost 或 Qt）的解决方案，特别适合需要精细控制、高性能和复杂状态管理的应用程序。

2. 库特点

ASL 拥有许多独特且强大的特点，使其在 C++ 库生态中占有一席之地：

• 强大的属性模型 (Property Model): 这是 ASL 最核心和最具特色的部分之一。它提供了一种机制来定义、观察和操作数据模型。这不仅仅是简单的 getter/setter，而是一个支持事务、依赖跟踪、单元化（支持不同类型的值，如整数、布尔值、枚举等）和双向绑定的复杂系统。它极大地简化了 UI 状态与底层数据模型的同步问题。
• 声明式 UI 布局 (Adam & Eve): ASL 包含一个名为 Adam 的运行时布局引擎和一个名为 Eve 的声明式布局语言。开发者可以使用类似 CSS 的语法（Eve 文件）来描述 UI 元素的布局关系（如相对位置、对齐、尺寸约束等），Adam 引擎则负责在运行时解析这些规则并高效地计算出最终的布局。这种方式将布局逻辑与命令式代码分离，使得 UI 设计更灵活、更易于维护和修改。
• 现代并发原语: ASL 提供了先进的并发工具，如 adobe::future（类似于 std::future 但功能更强，支持延续、取消等）、adobe::channel（用于线程间通信）以及基于 Grand Central Dispatch (GCD) 思想的调度队列 (adobe::dispatch)。这些工具旨在简化异步编程，提高多核处理器的利用率，并确保线程安全。
• 泛型算法扩展: 除了标准库提供的算法，ASL 还包含了一些额外的、实用的泛型算法，通常针对其特有的数据结构或设计模式进行了优化。
• 类型擦除与 adobe::any_regular: adobe::any_regular 是一个强大的类型擦除容器，类似于 std::any 或 boost::any，但它要求存储的类型满足 "Regular" 概念（即可拷贝、可赋值、可比较等）。这在需要处理多种类型但又希望保持类型安全和值语义的场景下非常有用，尤其是在属性模型中。
• 强调正确性和健壮性: ASL 的设计非常注重代码的正确性。例如，属性模型中的事务机制确保了数据的一致性，并发原语的设计考虑了异常安全和资源管理。
• 平台抽象层 (部分): 虽然不是一个完整的跨平台 UI 框架，ASL 包含了一些用于抽象底层平台差异的组件，尤其是在窗口、事件处理等方面，但现代 C++ 开发中这部分可能需要结合其他库使用。

3. 详细模块分类

ASL 由多个逻辑模块组成，以下是一些关键模块的详细介绍：

3.1 adobe::property_model(属性模型)

这是 ASL 的基石之一。它允许你定义结构化的数据模型，并能自动通知观察者数据的变化。

• 核心概念:
• Cell: 模型的基本单元，代表一个数据项。它可以是输入单元 (Input Cell)、输出单元 (Output Cell) 或常量单元 (Constant Cell)。
• Interface: 定义了一组相关的 Cell，类似于一个接口或结构体。
• Sheet: adobe::sheet 是属性模型的具体实现，它管理一组 Cell 和它们之间的依赖关系。你可以把它想象成一个“电子表格”，其中的单元格可以相互引用和计算。
• Observer: 可以附加到 Cell 上，当 Cell 的值发生变化时，观察者会被通知。
• Transaction: 对模型的修改通常在事务中进行，确保原子性和一致性。
• 优势:
• 数据绑定: 极大地简化了 UI 控件状态与应用程序数据模型之间的同步。
• 依赖跟踪: 模型能自动管理 Cell 之间的依赖关系，当一个 Cell 的值改变时，依赖于它的其他 Cell 会自动重新计算。
• 灵活性: 支持存储各种类型的数据（通过 adobe::any_regular）。
• 可测试性: 将数据逻辑与 UI 分离，使得模型更容易进行单元测试。

3.2 adobe::layout(Adam & Eve 布局引擎)

该模块提供了声明式的 UI 布局解决方案。

• Eve 语言: 一种专门用于描述 UI 布局的声明式语言。语法简洁，易于理解。你可以定义视图（View）、容器（Container）、控件（Widget）以及它们之间的布局约束（水平排列、垂直排列、边距、对齐方式、相对尺寸等）。
• Adam 引擎: C++ 运行时库，负责解析 Eve 文件（或等效的 C++ 数据结构），并根据定义的约束计算出每个 UI 元素的实际位置和大小。它通常使用高效的线性约束求解算法。
• 优势:
• 关注点分离: 将布局逻辑从 C++ 代码中分离出来，使代码更清晰。
• 易于修改和维护: 修改布局通常只需要编辑 Eve 文件，无需重新编译 C++ 代码。
• 响应式设计: 布局规则可以基于容器大小动态调整，更容易实现响应式 UI。
• 性能: Adam 引擎经过优化，能够高效地处理复杂的布局计算。

3.3 adobe::dispatch和 adobe::future(并发与异步)

提供了用于现代 C++ 并发编程的工具。

• adobe::dispatch:
• 调度队列 (Dispatch Queue): 类似于 Apple 的 Grand Central Dispatch (GCD)。你可以创建串行或并发队列，并将任务（函数或 lambda 表达式）提交到这些队列上异步执行。
• 主队列 (Main Queue): 通常用于在主线程（UI 线程）上执行任务，确保 UI 更新的线程安全。
• 后台队列 (Background Queue): 用于执行耗时操作，避免阻塞主线程。
• adobe::future<T>:
• 异步结果: 代表一个可能尚未完成的异步操作的结果。
• 延续 (Continuations): 可以使用 .then() 方法链式地附加回调函数，当 future 完成时，回调函数会被自动调度执行（可以在指定队列上执行）。
• 组合 (Composition): 支持组合多个 future（例如 when_all, when_any）。
• 取消 (Cancellation): 支持尝试取消关联的异步操作。
• adobe::channel<T>:
• 线程安全通信: 提供了一种在不同线程（或队列）之间安全传递数据的方式，类似于 Go 语言的 channel。
• 优势:
• 简化异步逻辑: future 和延续使得异步代码的编写和理解更加线性化。
• 避免回调地狱: 通过链式调用 .then() 避免深层嵌套的回调。
• 高效利用多核: 通过调度队列轻松实现任务并行化。
• 线程安全: 提供了安全的线程间通信和任务调度机制。

3.4 adobe::algorithm(算法扩展)

包含对 C++ 标准库算法的补充和扩展。

• 示例: 可能包含针对特定数据结构（如 ASL 自己的容器或属性模型）优化的算法，或者一些标准库未直接提供的常用算法模式。例如，可能包含更方便的查找、排序、转换算法等。
• 目的: 提供更便捷、更高效或针对 ASL 设计理念的算法工具。

3.5 adobe::any_regular(类型擦除)

一个强大的类型擦除类，用于存储满足 "Regular" 概念的任意类型的值。

• Regular 概念: 指类型支持默认构造、拷贝构造、拷贝赋值、析构、相等比较 (==) 和不等比较 (!=)，并且这些操作具有值语义（拷贝即深拷贝）。
• 与 std::any 的区别: std::any 对存储的类型要求较低（只需要可拷贝构造和析构），而 adobe::any_regular 要求更高（Regular 类型），这使得 adobe::any_regular 可以进行比较等操作。
• 应用: 在属性模型中广泛使用，允许 Cell 存储不同类型的数据（如 int, double, std::string, bool 等），同时保持类型安全和值语义。

3.6 adobe::widget和 adobe::view(UI 元素)

提供了构建用户界面的基础组件。

• adobe::widget: 代表具体的 UI 控件，如按钮、文本框、滑块等。ASL 提供了一些基本的 Widget 实现。
• adobe::view: 通常指 UI 元素的可见表示和事件处理部分。
• 集成: 这些组件通常与属性模型和布局引擎紧密集成。Widget 的状态（如文本框的内容、复选框的选中状态）可以绑定到属性模型的 Cell，而其在屏幕上的位置和大小则由 Adam 布局引擎决定。
• 注意: ASL 本身不是一个完整的跨平台 UI 框架。adobe::widget 的实现可能依赖特定的平台后端（如 Windows API, Cocoa），或者需要与其他 UI 库（如 Qt, wxWidgets）桥接。在现代应用中，可能更多地使用 ASL 的核心逻辑（属性模型、布局、并发）搭配其他 UI 渲染技术。

3.7 adobe::sheet(表格数据模型)

adobe::sheet 是属性模型的一种具体实现方式，可以看作是其核心容器。

• 功能: 管理一组 Cell（输入、输出、常量），维护它们之间的依赖关系图，处理事务更新，并通知观察者。
• 使用: 开发者通过创建 adobe::sheet 实例来构建具体的数据模型。

4. 应用场景

ASL 特别适用于以下类型的 C++ 应用程序：

• 复杂状态管理的桌面应用程序: 如数字内容创作工具（图像编辑、视频编辑、排版软件）、工程软件 (CAD)、数据可视化工具等。这些应用通常具有大量的用户可配置选项、复杂的内部状态和需要实时同步的 UI。ASL 的属性模型是处理这种复杂性的利器。
• 需要自定义、高性能 UI 布局的应用: 当标准 UI 框架的布局系统无法满足需求，或者需要更精细的控制和更高的性能时，ASL 的 Adam/Eve 布局引擎提供了一个强大的替代方案。
• 数据驱动的应用程序: 当应用程序的核心是围绕一个结构化的数据模型构建，并且 UI 需要准确反映和修改这个模型时，ASL 的数据绑定能力非常有价值。
• 需要健壮并发处理的应用: 对于需要大量后台处理、异步 I/O 或并行计算的应用，ASL 的 future 和 dispatch 提供了比裸线程和锁更高级、更安全的抽象。
• 构建跨平台核心逻辑: 可以使用 ASL 构建应用程序的核心数据模型、业务逻辑和并发处理部分，这部分代码是高度可移植的。然后针对不同平台选择合适的 UI 库与 ASL 的核心进行集成。
• 开发工具和内部应用: 对于需要快速开发具有复杂界面的内部工具，ASL 的声明式 UI 和属性模型可以提高开发效率。

5. 各功能模块代码示例

以下是一些关键模块的简化代码示例，旨在说明其基本用法。

注意: 这些示例是说明性的，可能需要适当的头文件包含和 ASL 环境设置才能编译。

5.1 adobe::property_model示例

 #include <adobe/future/widgets/headers/platform_sheet.hpp> // 通常包含平台相关的 sheet 实现
 #include <adobe/future/widgets/headers/platform_label.hpp> // 示例：标签控件
 #include <adobe/future/widgets/headers/platform_edit_text.hpp> // 示例：文本编辑框
 #include <adobe/any_regular.hpp>
 #include <adobe/name.hpp>
 #include <iostream>
 #include <string>
 
 // 定义一些名称（用于标识 Cell）
 // 通常使用 ADOBE_NAME 宏来创建静态名称，效率更高
 static const adobe::name_t name_username("username");
 static const adobe::name_t name_greeting("greeting");
 static const adobe::name_t name_char_count("char_count");
 
 int main() {
     // 1. 创建一个 Sheet 实例
     adobe::sheet_t sheet;
 
     // 2. 添加输入 Cell (例如，用于绑定到一个文本输入框)
     // 初始值为空字符串
     sheet.add_input(name_username, adobe::any_regular_t(std::string("")));
 
     // 3. 添加输出 Cell (计算得到的 Cell)
     // greeting 依赖于 username
     sheet.add_output(name_greeting, [&](const adobe::sheet_t& s) -> adobe::any_regular_t {
         std::string username = s.get(name_username).cast<std::string>();
         if (username.empty()) {
             return adobe::any_regular_t(std::string("Hello, guest!"));
         } else {
             return adobe::any_regular_t(std::string("Hello, ") + username + "!");
         }
     });
 
     // char_count 也依赖于 username
      sheet.add_output(name_char_count, [&](const adobe::sheet_t& s) -> adobe::any_regular_t {
         std::string username = s.get(name_username).cast<std::string>();
         return adobe::any_regular_t(static_cast<int>(username.length())); // 假设我们关心字符数（int）
     });
 
 
     // 4. 附加观察者 (例如，当 greeting 变化时打印)
     adobe::observer_t greeting_observer = sheet.monitor_output(name_greeting, [&](const adobe::any_regular_t& value) {
         std::cout << "Greeting changed: " << value.cast<std::string>() << std::endl;
     });
 
     adobe::observer_t count_observer = sheet.monitor_output(name_char_count, [&](const adobe::any_regular_t& value) {
         std::cout << "Username length: " << value.cast<int>() << std::endl;
     });
 
     // 5. 模拟用户输入 (修改输入 Cell 的值)
     std::cout << "Initial state:" << std::endl;
     sheet.enable_updates(); // 初始时可能需要显式启用更新传播
 
     std::cout << "\nSetting username to 'Alice'..." << std::endl;
     // 在事务中修改值
     adobe::transaction_t transaction(sheet, "Set Username");
     sheet.set(name_username, adobe::any_regular_t(std::string("Alice")));
     // 事务结束时，变化会自动传播，观察者会被调用
 
     std::cout << "\nSetting username to 'Bob'..." << std::endl;
     { // 使用 RAII 方式管理事务
        adobe::transaction_t transaction2(sheet, "Set Username 2");
        sheet.set(name_username, adobe::any_regular_t(std::string("Bob")));
     }
 
     std::cout << "\nClearing username..." << std::endl;
      {
        adobe::transaction_t transaction3(sheet, "Clear Username");
        sheet.set(name_username, adobe::any_regular_t(std::string("")));
     }
 
     // 通常在实际应用中，sheet 会与 UI 控件绑定
     // 例如：
     // adobe::edit_text_t username_edit_text;
     // adobe::label_t greeting_label;
     // adobe::bind_edit_text(username_edit_text, sheet, name_username);
     // adobe::bind_label(greeting_label, sheet, name_greeting);
 
     return 0;
 }

5.2 adobe::layout (Adam & Eve) 示例

 sheet my_sheet // 假设与一个名为 my_sheet 的属性模型关联
 
 view dialog(name: "main_dialog", placement: place_row) // 顶层视图，行布局
 {
     // 定义一些常量或从 sheet 读取
     margin: cell(my_sheet.margin_size); // 从 sheet 读取边距
     spacing: 10; // 固定间距
 
     // 子控件
     label(name: "username_label", bind: @greeting); // 绑定到 sheet 的 greeting cell
     edit_text(name: "username_input", bind: @username); // 绑定到 sheet 的 username cell
     button(name: "ok_button", label: "OK");
 
     // 布局约束示例
     guide // 添加一些布局辅助线或约束
     {
         // 让输入框水平填充可用空间
         username_input.horizontal: align_fill;
         // 让标签和按钮宽度固定
         username_label.horizontal: align_left;
         ok_button.horizontal: align_right;
         // 垂直方向居中对齐 (假设父容器是行布局)
         username_label.vertical: align_center;
         username_input.vertical: align_center;
         ok_button.vertical: align_center;
     }
 }
 
 **C++ (概念性代码，实际集成会更复杂):**
 
 #include <adobe/future/widgets/headers/platform_sheet.hpp>
 #include <adobe/future/widgets/headers/platform_window.hpp>
 #include <adobe/adam.hpp> // Adam 引擎头文件
 #include <fstream>
 #include <sstream>
 
 // ... (假设 sheet 实例已创建并填充如上例)
 
 int main_adam_example() {
     adobe::sheet_t my_sheet;
     // ... 初始化 my_sheet (添加 username, greeting cell 等)
     my_sheet.add_input(adobe::static_name_t("margin_size"), adobe::any_regular_t(15)); // 添加布局需要的 cell
 
     // 1. 加载 Eve 文件内容
     std::ifstream eve_file("my_layout.eve");
     std::stringstream buffer;
     buffer << eve_file.rdbuf();
     std::string eve_content = buffer.str();
 
     // 2. 创建 Adam 解析器和控制器
     adobe::adam_parser_t parser(eve_content.c_str(), eve_content.size(), adobe::static_name_t("my_layout.eve"));
     adobe::controller_t adam_controller(parser.sheet(), parser.callbacks()); // callbacks 用于处理事件等
 
     // 3. 将 Adam 控制器与 Sheet 关联
     // (这一步的具体 API 可能因版本而异，核心是让 Adam 能访问 Sheet)
     // 通常 Adam 会自动查找名为 "my_sheet" (或 Eve 文件中指定名称) 的 sheet
     // 可能需要注册 sheet 到某个全局上下文或直接传递给 Adam 相关对象
 
     // 4. 创建平台窗口和根视图
     adobe::platform_window_t main_window("My Dialog");
     // ... 创建一个根视图容器，Adam 将在这个容器内进行布局
 
     // 5. 将 Adam 应用到根视图和 Sheet
     // adobe::attach_adam(root_view_container, adam_controller, my_sheet); // 概念性函数
 
     // 6. 显示窗口并运行事件循环
     // main_window.show();
     // run_event_loop();
 
     return 0;
 }

5.3 adobe::future 和 adobe::dispatch 示例

 #include <adobe/future/future.hpp>
 #include <adobe/future/dispatch.hpp>
 #include <iostream>
 #include <string>
 #include <thread>
 #include <chrono>
 
 // 模拟一个耗时操作
 std::string perform_long_computation(int input) {
     std::cout << "Starting long computation for input " << input << " on thread " << std::this_thread::get_id() << std::endl;
     std::this_thread::sleep_for(std::chrono::seconds(2));
     std::cout << "Finished long computation for input " << input << std::endl;
     return "Result(" + std::to_string(input * input) + ")";
 }
 
 // 模拟一个快速的后续处理
 std::string process_result(const std::string& result) {
      std::cout << "Processing result '" << result << "' on thread " << std::this_thread::get_id() << std::endl;
      return "Processed: " + result;
 }
 
 int main() {
     std::cout << "Main thread: " << std::this_thread::get_id() << std::endl;
 
     // 获取后台并发队列和主线程串行队列
     auto background_queue = adobe::dispatch::background_queue();
     auto main_queue = adobe::dispatch::main_queue(); // 通常是 UI 线程
 
     // 1. 在后台队列异步执行耗时操作
     adobe::future<std::string> computation_future = adobe::dispatch::async(background_queue, [=]() {
     return perform_long_computation(42);
     });
 
     std::cout << "Async task dispatched." << std::endl;
 
     // 2. 使用 .then() 添加延续任务
     // 第一个延续：仍在后台处理结果
     adobe::future<std::string> processing_future = computation_future.then(background_queue, [=](adobe::future<std::string> completed_future) {
     // 注意：延续的参数是完成的 future 本身
     // 需要检查 future 的状态（虽然在这里 dispatch::async 保证成功时才调用）
     if (completed_future.is_ready() && !completed_future.has_exception()) {
          return process_result(completed_future.get()); // 获取结果
     }
     return std::string("Error or cancelled");
     });
 
      // 第二个延续：将最终结果切换到主队列（例如更新 UI）
     adobe::future<void> final_future = processing_future.then(main_queue, [=](adobe::future<std::string> completed_future) {
      std::cout << "Final update on thread " << std::this_thread::get_id() << std::endl;
      if (completed_future.is_ready() && !completed_future.has_exception()) {
          std::cout << "Final Result: " << completed_future.get() << std::endl;
          // 在这里可以安全地更新 UI 元素
      } else {
          std::cout << "An error occurred during processing." << std::endl;
      }
      // 可以调用退出事件循环的函数
      // adobe::dispatch::stop(); // 假设有这样的函数
     });
 
     std::cout << "Continuations attached." << std::endl;
 
     // 3. 运行事件循环 (或等待)
     // 在实际应用中，通常是 UI 框架的事件循环
     // 这里用一个简单的等待来模拟，直到主队列任务完成
     std::cout << "Starting dispatch loop (simulated)..." << std::endl;
     // adobe::dispatch::main() // 启动事件循环 (如果适用)
     // 或者简单等待 future 完成 (仅用于示例)
     try {
     final_future.get(); // 阻塞等待最终 future 完成
     std::cout << "Future chain completed." << std::endl;
     } catch (const std::exception& e) {
     std::cerr << "Exception caught: " << e.what() << std::endl;
     } catch (...) {
      std::cerr << "Unknown exception caught." << std::endl;
     }
 
 
     // 如果使用 dispatch::main()，需要一个停止机制
     // 例如在 final_future 的回调中调用 adobe::dispatch::stop()
 
     return 0;
 }

5.4 adobe::any_regular 示例

 #include <adobe/any_regular.hpp>
 #include <adobe/regular.hpp> // 包含 regular_t 概念检查
 #include <iostream>
 #include <string>
 #include <vector>
 
 struct MyData {
     int id;
     std::string name;
 
     // 为了能放入 any_regular，需要满足 Regular 概念
     // 默认构造
     MyData() : id(0), name("") {}
     MyData(int i, std::string n) : id(i), name(std::move(n)) {}
     // 拷贝构造 (默认即可)
     // 拷贝赋值 (默认即可)
     // 析构 (默认即可)
     // 相等比较
     friend bool operator==(const MyData& lhs, const MyData& rhs) {
     return lhs.id == rhs.id && lhs.name == rhs.name;
     }
     // 不等比较 (通常基于 == 实现)
      friend bool operator!=(const MyData& lhs, const MyData& rhs) {
     return !(lhs == rhs);
     }
 };
 
 // 显式告诉编译器 MyData 是 Regular 类型 (可选，但有助于静态检查)
 ADOBE_DEFINE_REGULAR_CONCEPT_T(MyData)
 
 int main() {
     std::vector<adobe::any_regular_t> items;
 
     // 存储不同类型的数据
     items.push_back(adobe::any_regular_t(42));                   // int
     items.push_back(adobe::any_regular_t(3.14));                 // double
     items.push_back(adobe::any_regular_t(std::string("Hello"))); // std::string
     items.push_back(adobe::any_regular_t(true));                 // bool
     items.push_back(adobe::any_regular_t(MyData(1, "Test")));    // 自定义类型 MyData
 
     // 遍历并处理不同类型
     for (const auto& item : items) {
     if (item.type_info() == typeid(int)) {
         std::cout << "Got an int: " << item.cast<int>() << std::endl;
     } else if (item.type_info() == typeid(double)) {
         std::cout << "Got a double: " << item.cast<double>() << std::endl;
     } else if (item.type_info() == typeid(std::string)) {
         std::cout << "Got a string: \"" << item.cast<std::string>() << "\"" << std::endl;
     } else if (item.type_info() == typeid(bool)) {
          std::cout << "Got a bool: " << (item.cast<bool>() ? "true" : "false") << std::endl;
     } else if (item.type_info() == typeid(MyData)) {
         const MyData& data = item.cast<const MyData&>(); // 可以用引用避免拷贝
         std::cout << "Got MyData: id=" << data.id << ", name=" << data.name << std::endl;
     } else {
         std::cout << "Got an unknown type." << std::endl;
     }
     }
 
     // any_regular 支持比较 (如果内部类型支持)
     adobe::any_regular_t v1(42);
     adobe::any_regular_t v2(42);
     adobe::any_regular_t v3(99);
     adobe::any_regular_t v4(std::string("Hello"));
 
     std::cout << "v1 == v2: " << (v1 == v2) << std::endl; // true
     std::cout << "v1 == v3: " << (v1 == v3) << std::endl; // false
     // std::cout << "v1 == v4: " << (v1 == v4) << std::endl; // 运行时错误或未定义行为，类型不同
 
     return 0;
 }

6. 总结

Adobe Source Libraries (ASL) / stlab 提供了一套强大而独特的 C++ 组件，特别是在属性模型、声明式 UI 布局和现代并发方面。它并非一个包罗万象的框架，而是专注于解决特定领域（尤其是复杂 GUI 应用）的核心挑战。通过学习和应用 ASL 的设计理念和工具，开发者可以构建出更健壮、更灵活、更易于维护的高性能 C++ 应用程序。

虽然 ASL 的学习曲线可能比一些更传统的库要陡峭一些，但其提供的抽象能力和带来的代码质量提升，对于合适的项目来说是非常有价值的。建议从理解其核心概念（尤其是属性模型）入手，并结合具体示例进行实践。

希望这篇开发者指南能帮助你开始探索和使用 ASL！