From 6c4f8fee0762b8d5ae2c3be90e399de25b0782f3 Mon Sep 17 00:00:00 2001 From: muqiuhan Date: Thu, 30 Oct 2025 13:07:52 +0000 Subject: deploy: 8f3e9bbc15d26be576f0ab12bc39625b8edc354a --- search.xml | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) (limited to 'search.xml') diff --git a/search.xml b/search.xml index 2b0ba7f0..0c14fb16 100644 --- a/search.xml +++ b/search.xml @@ -3793,8 +3793,8 @@ NestJS 依赖其底层 HTTP 适配器（默认为 Express）来解析传入的

从那以后，我偶尔还会闻到那种味道。公交车拐弯的时候，风从窗缝里钻进来，地铁门打开的时候，站台上一阵匆忙的脚步后，忽然静下来的那一刻。我不知道它为什么会出现，也不刻意寻找。它像朋友一样，来了就坐一会儿，走了也不会留下地址。

然后我遇见了你。

起初我们并肩走在一条街上，街灯刚亮，影子从脚边拖到墙根。你说话的时候，声音不急也不慢。我听见了你的过去，但不是像在听故事那样去比较谁更动人，我只是听着你。你给我看了你的手心，那上面有被太阳晒过后的浅色纹理，也有你习惯把指甲剪得很短的认真。我心里有一种安静，它不是从谁那里借来的，而是像从很远的地方自己走来的。

-

我知道你不是他，他是一种很亮的影子，只能在黑暗里存在。而你会在这里，在光亮里也在风里，在你的沉默里也在你的笑声里。时间不会让你跟他合在一起，时间只会让你在我旁边，成为一个可以站着的人，一个愿意陪我走过同一条街、同一种气味、同一种阳光的人。

-

于是我想给你那朵黄玫瑰的记忆。不是因为我想要你变成他的样子，而是因为我在你身上看见了自己喜欢的那种安静和从容。我想让你在今后的某一天，当公交门打开，站台忽然安静下来，当你走在一条熟悉的路上，风从树梢里穿过，当你坐在窗边，光从书页上滑过去的时候，能闻到那种味道，能想起那一刻的我们，我们在傍晚的风里站着，既不躲藏也不假装，我们把时间握在手里，像握着一朵温柔得让人不需要理由的花。

+

我知道你不是她，她是一种很亮的影子，只能在黑暗里存在。而你会在这里，在光亮里也在风里，在你的沉默里也在你的笑声里。时间不会让你跟她合在一起，时间只会让你在我旁边，成为一个可以站着的人，一个愿意陪我走过同一条街、同一种气味、同一种阳光的人。

+

于是我想给你那朵黄玫瑰的记忆。不是因为我想要你变成她的样子，而是因为我在你身上看见了自己喜欢的那种安静和从容。我想让你在今后的某一天，当公交门打开，站台忽然安静下来，当你走在一条熟悉的路上，风从树梢里穿过，当你坐在窗边，光从书页上滑过去的时候，能闻到那种味道，能想起那一刻的我们，我们在傍晚的风里站着，既不躲藏也不假装，我们把时间握在手里，像握着一朵温柔得让人不需要理由的花。

如果你愿意，我可以每天傍晚经过花店门口，我们可以把那种味道带回家，用一只透明的瓶子装起来，不需要解释它来自哪里，也不需要把它和任何过去比较。它只会在你需要的时候出现，像一个老朋友，提醒你，不是每一次都要变成别人，不是每一次都需要证明你已经忘记。你可以是现在的你，我可以是现在的我。我们可以在同一个黄昏里站一会儿，看看天空从浅到深，看看风从我们旁边走过，看看影子在我们的脚边拉长。

黄玫瑰的味道不会要求我们变成谁，它只会给我们一点轻的力气，让我们在时间里往前走走。我把这份力气给你，也给我自己，然后我们就接着往前走，带着这种不喧哗的光。

]]> @@ -6125,6 +6125,19 @@ NestJS 依赖其底层 HTTP 适配器（默认为 Express）来解析传入的 Life + + 隐藏一些OCaml Effect的机制，让其语法在精神上更接近delimcc + /2023/06/28/%E9%9A%90%E8%97%8F%E4%B8%80%E4%BA%9BOCaml-Effect%E7%9A%84%E6%9C%BA%E5%88%B6%EF%BC%8C%E8%AE%A9%E5%85%B6%E8%AF%AD%E6%B3%95%E5%9C%A8%E7%B2%BE%E7%A5%9E%E4%B8%8A%E6%9B%B4%E6%8E%A5%E8%BF%91delimcc/ + delimcc_of_fxhandler这个库在OCaml5的effect handlers上实现了一些delimcc原语(shift/reset, control/prompt这些)：

+
let p = new_prompt () in
assert ([] = push_prompt p (fun () ->
               1::2::take_subcont p (fun _k -> [])));
assert ([1;2] = push_prompt p (fun () ->
               1::2::take_subcont p (fun k -> push_subcont k [])));
assert (135 =
  let p1 = new_prompt () in
  let p2 = new_prompt () in
  let p3 = new_prompt () in
  let pushtwice sk =
    sk (fun () ->
      sk (fun () ->
        shift0 p2 (fun sk2 -> sk2 (fun () ->
          sk2 (fun () -> 3))) ()))
   in
   push_prompt p1 (fun () ->
     push_prompt p2 (fun () ->
       push_prompt p3 (fun () -> shift0 p1 pushtwice ()) + 10) + 1) + 100);

print_endline "Success!"
+

另外， avsm这里可以看到一些OCaml的Effect Syntax进展。

+

还有 multi-shot continuations in OCaml，在这个仓库里面还讨论了一些有趣的问题，例如，OCaml 编译器和runtime会做出一些假设从而进行一些优化，这些优化在使用multi-shot continutation时是不可取的（或完全错误的）。编译器优化导致错误的一个例子是堆到栈的转换，例如:

+
(* An illustration of how the heap to stack optimisation is broken.
 * This example is adapted from de Vilhena and Pottier (2021).
 * file: heap2stack.ml
 * compile: ocamlopt -I $(opam var lib)/multicont multicont.cmxa heap2stack.ml
 * run: ./a.out *)

(* We first require a little bit of setup. The following declares an
   operation `Twice' which we use to implement multiple returns. *)
type _ Effect.t += Twice : unit Effect.t

(* The handler `htwice' interprets `Twice' by simply invoking its
   continuation twice. *)
let htwice : (unit, unit) Effect.Deep.handler
  = { retc = (fun x -> x)
    ; exnc = (fun e -> raise e)
    ; effc = (fun (type a) (eff : a Effect.t) ->
      let open Effect.Deep in
      match eff with
      | Twice -> Some (fun (k : (a, _) continuation) ->
         continue (Multicont.Deep.clone_continuation k) ();
         continue k ())
      | _ -> None) }

(* Now for the interesting stuff. In the code below, the compiler will
   perform an escape analysis on the reference `i' and deduce that it
   does not escape the local scope, because it is unaware of the
   semantics of `perform Twice', hence the optimiser will transform
   `i' into an immediate on the stack to save a heap allocation. As a
   consequence, the assertion `(!i = 1)' will succeed twice, whereas
   it should fail after the second return of `perform Twice'. *)
let heap2stack () =
  Effect.Deep.match_with
    (fun () ->
      let i = ref 0 in
      Effect.perform Twice;
      i := !i + 1;
      Printf.printf "i = %d\n%!" !i;
      assert (!i = 1))
    () htwice

(* The following does not trigger an assertion failure. *)
let _ = heap2stack ()

(* To fix this issue, we can wrap reference allocations in an instance
   of `Sys.opaque_identity'. However, this is not really a viable fix
   in general, as we may not have access to the client code that
   allocates the reference! *)
let heap2stack' () =
  Effect.Deep.match_with
    (fun () ->
      let i = Sys.opaque_identity (ref 0) in
      Effect.perform Twice;
      i := !i + 1;
      Printf.printf "i = %d\n%!" !i;
      assert (!i = 1))
    () htwice

(* The following triggers an assertion failure. *)
let _ = heap2stack' ()
+]]> + + Technique + + 金匮要略 /2023/03/04/%E9%87%91%E5%8C%AE%E8%A6%81%E7%95%A5/ @@ -7392,19 +7405,6 @@ NestJS 依赖其底层 HTTP 适配器（默认为 Express）来解析传入的 Medicine - - 隐藏一些OCaml Effect的机制，让其语法在精神上更接近delimcc - /2023/06/28/%E9%9A%90%E8%97%8F%E4%B8%80%E4%BA%9BOCaml-Effect%E7%9A%84%E6%9C%BA%E5%88%B6%EF%BC%8C%E8%AE%A9%E5%85%B6%E8%AF%AD%E6%B3%95%E5%9C%A8%E7%B2%BE%E7%A5%9E%E4%B8%8A%E6%9B%B4%E6%8E%A5%E8%BF%91delimcc/ - delimcc_of_fxhandler这个库在OCaml5的effect handlers上实现了一些delimcc原语(shift/reset, control/prompt这些)：

-
let p = new_prompt () in
assert ([] = push_prompt p (fun () ->
               1::2::take_subcont p (fun _k -> [])));
assert ([1;2] = push_prompt p (fun () ->
               1::2::take_subcont p (fun k -> push_subcont k [])));
assert (135 =
  let p1 = new_prompt () in
  let p2 = new_prompt () in
  let p3 = new_prompt () in
  let pushtwice sk =
    sk (fun () ->
      sk (fun () ->
        shift0 p2 (fun sk2 -> sk2 (fun () ->
          sk2 (fun () -> 3))) ()))
   in
   push_prompt p1 (fun () ->
     push_prompt p2 (fun () ->
       push_prompt p3 (fun () -> shift0 p1 pushtwice ()) + 10) + 1) + 100);

print_endline "Success!"
-

另外， avsm这里可以看到一些OCaml的Effect Syntax进展。

-

还有 multi-shot continuations in OCaml，在这个仓库里面还讨论了一些有趣的问题，例如，OCaml 编译器和runtime会做出一些假设从而进行一些优化，这些优化在使用multi-shot continutation时是不可取的（或完全错误的）。编译器优化导致错误的一个例子是堆到栈的转换，例如:

-
(* An illustration of how the heap to stack optimisation is broken.
 * This example is adapted from de Vilhena and Pottier (2021).
 * file: heap2stack.ml
 * compile: ocamlopt -I $(opam var lib)/multicont multicont.cmxa heap2stack.ml
 * run: ./a.out *)

(* We first require a little bit of setup. The following declares an
   operation `Twice' which we use to implement multiple returns. *)
type _ Effect.t += Twice : unit Effect.t

(* The handler `htwice' interprets `Twice' by simply invoking its
   continuation twice. *)
let htwice : (unit, unit) Effect.Deep.handler
  = { retc = (fun x -> x)
    ; exnc = (fun e -> raise e)
    ; effc = (fun (type a) (eff : a Effect.t) ->
      let open Effect.Deep in
      match eff with
      | Twice -> Some (fun (k : (a, _) continuation) ->
         continue (Multicont.Deep.clone_continuation k) ();
         continue k ())
      | _ -> None) }

(* Now for the interesting stuff. In the code below, the compiler will
   perform an escape analysis on the reference `i' and deduce that it
   does not escape the local scope, because it is unaware of the
   semantics of `perform Twice', hence the optimiser will transform
   `i' into an immediate on the stack to save a heap allocation. As a
   consequence, the assertion `(!i = 1)' will succeed twice, whereas
   it should fail after the second return of `perform Twice'. *)
let heap2stack () =
  Effect.Deep.match_with
    (fun () ->
      let i = ref 0 in
      Effect.perform Twice;
      i := !i + 1;
      Printf.printf "i = %d\n%!" !i;
      assert (!i = 1))
    () htwice

(* The following does not trigger an assertion failure. *)
let _ = heap2stack ()

(* To fix this issue, we can wrap reference allocations in an instance
   of `Sys.opaque_identity'. However, this is not really a viable fix
   in general, as we may not have access to the client code that
   allocates the reference! *)
let heap2stack' () =
  Effect.Deep.match_with
    (fun () ->
      let i = Sys.opaque_identity (ref 0) in
      Effect.perform Twice;
      i := !i + 1;
      Printf.printf "i = %d\n%!" !i;
      assert (!i = 1))
    () htwice

(* The following triggers an assertion failure. *)
let _ = heap2stack' ()
-]]> - - Technique - - 领域驱动设计中的“聚合根” /2025/03/13/%E9%A2%86%E5%9F%9F%E9%A9%B1%E5%8A%A8%E8%AE%BE%E8%AE%A1%E4%B8%AD%E7%9A%84%E2%80%9C%E8%81%9A%E5%90%88%E6%A0%B9%E2%80%9D/ -- cgit v1.2.3