#code AIDL 服务-客户 示例，包含 int n 的监听、 List<Str> users() 的回调

// src/main/aidl/ISvc.aidl
package my.svc;
import my.svc.ISvcCB;

interface ISvc {
void setListener(in ISvcCB callback);//int n 变化时通知客户端
//没有找到针对 Kotlin 的 AIDL 框架，但创建.aidl时, xml清单会自动更新
int getN();void setN(int n);
void getUsers(in ISvcCB callback);// 回调得 List<Str>
}

// 另起一文
package my.svc;
import java.util.List;

interface ISvcCB {
void onNChanged(int n);
void onGetUsers(List<Str> users);
}

// src/main/kotlin/ISvc.kt
class ISvc: Service() {
var n=0
onBind(intent)=binder
val binder=object: ISvc.Stub() {
getN()=n //set,users 要调回调,以此类推
}
}

// MyActivity.java

class MyActivity : RpcActivity() {
onCreate()=makeRpc<ISvc>()
inline fun <reified T> makeRpc() {//连接(intent,conn)
val conn=object : ServiceConnection {
override fun onServiceConnected(name: ComponentName?, binder: IBinder?)
{rpc = T.Stub.asInterface(binder)}
override fun onServiceDisconnected(name: ComponentName?) {rpc=null}
}
bindService(Intent.at(T::class.java), conn, BIND_AUTO_CREATE)
close={unbindService(conn)}
}
onDestroy()=_close()
var close:()->Unit
}
fun Intent.Companion.at(T:Class<*>) = Intent().apply {
component = ComponentName(T.`package`.name, T.name)
}

#sql #code LC#200
:- use_rendering(table).
pixel([
[0, 0, 1],
[1, 1, 1],
[0, 0, 0]]).

% 像素[xy]
v(P, C) :- P = [X,Y],
pixel(M),
nth0(Y, M, R),nth0(X, R, C).

% 相邻颜色
conn(P0,P1) :- P0 = [X0,Y0],P1 = [X1,Y1],
v(P0,C),v(P1,C),
abs(X0 - X1) + abs(Y0 - Y1) =:= 1.

% 追溯联通
dfs(A,B,V) :- A=B; conn(A,C), not(member(C,V)), dfs(C,B,[C|V]).

% 列出
fill(P, S) :- setof(X, dfs(P,X, []), S).

/** <examples>
?- fill([2,1], R).
?- distinct([X], (fill(_,X))).
?- v(P, 0), P=[X, 0].
?- conn([2,1], P1).
*/

#py
import numpy as np

def islands(a):
LRUD = np.array([[0, -1], [0, 1], [-1, 0], [1, 0]])
m, n = a.shape
all=set()
f=dfs((isl:=[]).append, lambda P:(tuple(x) for x in P+LRUD if (lambda x,y :\
(0<=y<n)and(0<=x<m) and a[x,y]== 1)(*x)) )

for P,c in np.ndenumerate(a):
f(P); vis.clear(); all.add(tuple(sorted(isl))); isl.clear()
return all
vis=set()
def dfs(fvis,Links):
def at(P0):
for P in Links(P0):
if P not in vis: fvis(P);vis.add(P); at(P)
return at

# 创建一个 'L' 型九宫格的示例
_L = np.array([
[1,0,0],
[1,0,0],
[1,1,0],
])

islands(_L)


LC#994 则是用BFS，浅先，并记录布数； 从所有烂橘子开始，直到走不动或橘子全烂

#plt #code 本来 mul([1,*,2],[], R) 正确算为 乘(1,2)
验算也OK，但反运算不行！

关系式无法调试print，我内联参数勉强查出了“把 R= 往前挪，就能正确推导”

AI直接傻了，说了一些奇怪的话：

“ 这时 mul(S,[], 乘(1, 2)) 能用，但规则的含义变了。你原来说 S 是一个乘法表达式，现在的 mul 里 S 和 R 都是乘法表达式 (废话!)

这样允许了一些不合理的情况，例如 mul([1,*,2],[], 3) 也可以成功(??)，因为 R = 3 可以无视S匹配 R =.. [乘,E1,E2] ，这样会破坏你的逻辑。你应该定义 mul(S,[],R)

:- use_module(library(dcg/basics)).
:- set_prolog_flag(double_quotes, chars).

e(E) -->{E = [I,Ea,Eb]},
  e1(Ea), op(I,"+-"), e(Eb); e1(E).
e1(E) -->{E = [I,Ea,Eb]},
  e2(Ea), op(I,"  */"), e1(Eb); e2(E).

e2(X) --> number(X); ("(", e(X), ")"), !.
op(I,W) --> [C], { nth0(I0,W,C),nth0(I0,"加减乘除",I) }.

%原理: 吃前缀,吃内项,吐返回
parse(S,E) :- add(S,[],E), !.
kw(W,S,SR) :- S = [W|SR].
num(S,SR,R) :-
 S = [R|SR], integer(R); phrase(number(R), S,SR).

add(S,SR,R) :- R =.. [加,E1,E2],
  mul(S,S1,E1),kw('+',S1,S2),add(S2,SR,E2); mul(S,SR,R). %chainl. 这些S只是“流后缀”

mul(S,SR,R) :- 
  R =.. [乘,E1,E2], %FUCK, 想反算R必须在前,num必须在后?
  num(S,S1,E1), kw('*',S1,S2), num(S2,SR,E2); num(S,SR,R).

%split_string \d+
% cutD("123acbc12", [123, a, c, b, c,1,2]) 失败了
cutD(S, L) :-
phrase(number(N), S,SR), cutD(SR,L0),L=[N|L0], !; S=L, !;
phrase(string(X), S,SR), cutD(SR,L0),L=[X|L0].

在 Rust 中，你可以结合 HTML-style UI 框架和 imgui 绑定来实现 label("你好") 的效果。下面是一个简单的例子，使用 web-view 和 imgui-rs 来实现：

首先，在 Cargo.toml 文件中添加相关依赖：

[dependencies]
web-view = "0.7.0"
imgui = "0.4.0"
imgui-winit-support = "0.6.0"

接下来，创建一个名为 main.rs 的文件，并将以下代码添加到文件中：

use web_view::*;
use imgui::*;
use imgui_winit_support::WinitPlatform;

fn main() {
    // 创建 web view，指定 HTML 内容和窗口大小
    let webview = web_view::builder()
        .title("Hello Label Example")
        .content(Content::Html(include_str!("index.html")))
        .size(800, 600)
        .resizable(true)
        .debug(true)
        .user_data(())
        .invoke_handler(|_webview, _arg| {
            Ok(())
        })
        .build()
        .unwrap();

    // 创建 imgui 上下文
    let mut imgui = imgui::Context::create();
    imgui.set_ini_filename(None);

    // 创建 imgui-winit-support 并初始化
    let mut platform = WinitPlatform::init(&mut imgui);
    platform.attach_window(
        imgui.io_mut(),
        platform
            .create_window(
                imgui.io_mut(),
                Default::default(),
                imgui_winit_support::HiDpiMode::Default,
            )
            .0,
        imgui_winit_support::HiDpiMode::Default,
    );

    // 主循环
    while webview.step().unwrap() {
        let ui = imgui.frame();

        // 在 imgui 中创建一个 Label 控件
        ui.text("你好");

        // imgui 渲染
        let mut platform_state = platform.prepare_frame(imgui.io_mut(), &webview.window());
        platform_state.prepare_render(&ui, &webview.window());
        webview.eval(&platform_state.render()).unwrap();
    }
}

接下来，创建一个名为 index.html 的文件，并将以下代码添加到文件中：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello Label Example</title>
</head>
<body>
</body>
</html>

最后，使用 cargo run 命令来运行程序。

这个示例会创建一个带有 "你好" 标签的 HTML-style UI 窗口。你可以根据需要进一步扩展和定制该示例。

请确保 Cargo.toml 中的依赖项与代码示例中提供的版本号匹配，以确保能够成功构建和运行该程序。同时，你可能还需要根据自己的操作系统和开发环境进行必要的配置和调整。

希望这能帮助到你！如果有任何进一步的问题，请随时提问。🙂

在 Rust 中，最流行的 HTML-style UI 框架是 yew。yew 是一个基于 Rust 和 WebAssembly 的现代前端框架，它提供了类似于 HTML 的声明式组件和状态管理。

以下是使用 yew 框架来实现 label("你好") 的示例代码：

首先，确保在你的 Cargo.toml 文件中添加 yew 的依赖：

[dependencies]
yew = "0.22.1"

然后，在项目中创建一个新的 Rust 文件（例如 main.rs），并将以下代码添加到文件中：

use yew::prelude::*;

struct Model;

impl Component for Model {
    type Message = ();
    type Properties = ();

    fn create(_: Self::Properties, _: ComponentLink<Self>) -> Self {
        Model
    }

    fn update(&mut self, _: Self::Message) -> ShouldRender {
        false
    }

    fn view(&self) -> Html {
        html! {
            <p>{ "你好" }</p>
        }
    }
}

fn main() {
    yew::start_app::<Model>();
}

最后，可以使用 cargo build 构建项目，并使用 cargo run 运行该应用程序。然后，在浏览器中访问生成的 WebAssembly 页面，你将看到一个包含 "你好" 文字的段落。

请确保 Cargo.toml 中的依赖项与代码示例中提供的版本号相匹配，以确保成功构建和运行该程序。

这只是一个基本示例，你可以根据需要使用 yew 框架创建更复杂的 UI 组件和交互逻辑。除了 yew，还有其他一些流行的 HTML-style UI 框架可供选择，如 seed 和 percy，你可以根据个人偏好选择适合你的框架。

希望这能帮助到你！如果有任何进一步的问题，请随时提问。🙂

当然，请参考以下链接获取有关 Rust 中流行的 UI 框架的更多信息：

1. Yew - Yew 是一个现代化的 Rust 框架，用于构建基于 WebAssembly 的前端应用程序。它采用类似于 React 的组件模型和虚拟 DOM，提供强大的状态管理和事件处理功能。Yew 的官方网站提供详细的文档、示例和指南。
2. Iced - Iced 是一个简单高效的跨平台 GUI 库，专注于构建桌面应用程序。它提供易于使用的 API 和功能强大的 UI 组件，使用函数式反应式编程风格。在项目的 GitHub 页面上，你可以找到示例代码、文档和社区支持。
3. Druid - Druid 是一个跨平台的 Rust UI 工具包，它专注于提供高性能和现代化的用户界面开发体验。Druid 基于直接渲染技术，支持声明式 UI 构建和强大的事件处理功能。官方网站提供了 API 文档、教程和示例代码供参考。
4. Conrod - Conrod 是一个创造性的 Rust 编码库，用于构建用户界面。它提供丰富的 UI 控件和布局工具，使你能够创建高度定制化的用户界面。在项目的 GitHub 页面上，你可以找到示例代码、教程和社区讨论。
5. Cursive - Cursive 是一个 Rust 的终端用户界面库（TUI），用于在命令行环境中构建交互式应用程序。它提供丰富而易用的终端 UI 组件和布局工具，帮助你创建强大的终端应用程序。在 GitHub 仓库中，你可以找到示例代码、文档和社区支持。

以上链接提供了各个框架的官方网站或 GitHub 页面，你可以通过这些链接更详细地了解每个框架的描述、文档、示例和社区支持。

希望这些链接能够满足你的需求！如有任何其他问题，请随时提问。😊

#math #algorithm #code

x + y = 35, 2x + 4y = 94

用高斯消元法，先将第一个方程乘以 -2，然后加到第二个方程上，得到：

 -2x - 2y = -70, y = 12
x + 12 = 35

所以，鸡有 23 只，兔子有 12 只。

# 对 x + y = 35, 2x + 4y = 94 的系数组，进行高斯消元
def elim(arg):
  n,m = arg.shape
  for j in range(n):
    # 找到第 j 列最强元素的行
    i= max(range(j, n), key=lambda i: abs(arg[i, j]))
    assert arg[i, j] != 0, '矩阵是奇异的'
    # 本列成为最强
    if i != j: arg[[i,j]] = arg[[j,i]]
    # 归一本行(除以 j 行的元素)
    arg[j] /=  arg[j, j]
    # 将其他行的第 j 列的元素消为 0
    for i in range(n):
      if i != j: arg[i] -= arg[i, j] * arg[j]
  # 成功消元
  return arg

#kt
// 定义一个函数，用于对二维数组进行高斯消元
fun gaussElimination(matrix: Array<Array<Double>>): Array<Array<Double>> {
val n = matrix.size // 矩阵的行数
val m = matrix[0].size // 矩阵的列数
// 遍历每一行
for (i in 0 until n) {
// 找到第 i 列中绝对值最大的元素所在的行
var maxRow = i
var maxVal = matrix[i][i]
for (j in i + 1 until n) {
if (abs(matrix[j][i]) > abs(maxVal)) {
maxRow = j
maxVal = matrix[j][i]
}
}
// 如果最大值为零，说明矩阵是奇异的，无法消元，抛出异常
if (maxVal == 0.0) {
throw Exception("Singular matrix")
}
// 如果最大值不在第 i 行，交换两行的位置
if (maxRow != i) {
val temp = matrix[i]
matrix[i] = matrix[maxRow]
matrix[maxRow] = temp
}
// 将第 i 行除以第 i 列的元素，使其变为 1
val pivot = matrix[i][i]
for (k in i until m) {
matrix[i][k] /= pivot
}
// 将其他行的第 i 列的元素消为 0
for (j in 0 until n) {
if (j != i) {
val factor = matrix[j][i]
for (k in i until m) {
matrix[j][k] -= factor * matrix[i][k]
}
}
}
}
// 返回消元后的矩阵
return matrix
}

// 定义一个函数，用于打印二维数组
fun printMatrix(matrix: Array<Array<Double>>) {
for (row in matrix) {
println(row.joinToString(" "))
}
}

// 定义一个测试用例，鸡兔同笼问题的系数矩阵
val testMatrix = arrayOf(
arrayOf(1.0, 1.0, 35.0),
arrayOf(2.0, 4.0, 94.0)
)

// 调用高斯消元函数，并打印结果
val resultMatrix = gaussElimination(testMatrix)
printMatrix(resultMatrix)

我真的不想吐槽数学和某些程序员的 xywh ijnm 定义了。我眼里 nm=hw, ij=yx ，是和书写、访问顺序对应的，但是资料说 x行y格, j行j格
随地for ijkhl 的面条代码，把我整困惑了，数学家是否连Excel、物理行向量的模型都没统一好？

而且看到很多版本的，有用点乘支持b（常数）矩阵，但变量名完全不一样

def elim(arg):
  n,m = arg.shape; assert n<=m, "没有唯一解"
  for j in range(n):
      # 找到j格最强元素的行(非0)，换为本行
      i= max(range(j, n), key=lambda i: abs(arg[i, j]))
      assert arg[i, j] != 0, "矩阵是奇异的"
      if i != j: arg[[i,j]] = arg[[j,i]]

      arg[j] /=  arg[j, j] # 在j=i的阶梯点。归一，再将其他行的j格消为 0
      for i in range(n):
        if i != j: arg[i] -= arg[i, j] * arg[j]
  # 成功消元
  return arg

—最终 #bing 给出了 minimal impl:

# 对系数组A，进行高斯消元求 Ax '=b'
def elim(A, b):
  M = np.hstack((A, b.reshape(-1, 1))) # M=(A|常数项b)
  n, m = A.shape; assert n==m, "没有唯一解"

  # 向下找j格最强的行，换为本行
  for j in range(n):
    i=np.argmax(abs(M[j:, j]))+j; assert M[i,j]!=0, "主元为零"
    if i!=j: #; ij=(行ji)
      M[[i,j]] = M[[j,i]]
    # j归一，将下行的j格消为 0 
    M[j] /=  M[j, j]
    for i in range(j + 1, n):
      M[i] -=  M[i,j]* M[j]
      #M[i] -=  M[j]* (M[i,j] / M[j,j])
  # 重新代入
  x = np.zeros(n)
  for i in reversed(range(n)):
    # 比率= 解/当前元
    x[i] = M[i, n] / M[i, i]
    # 以上的解-=比率*以上元
    M[:i, -1] -= x[i] * M[:i, i]
  return x

#x + y = 35, 2x + 4y = 94
print("xy的解为：", elim(
  np.array([[1.]*2, [2.,4]]), np.array([35,94]) ))

和np.lp 接口兼容
from sympy import *
import numpy as np
import numpy.linalg as lp

x, y = symbols('x, y')
eq = [
x + y - 35,
2*x + 4*y - 94]

A,b=(np.array(s,dtype=np.float32) for s in\
linear_eq_to_matrix(eq, (x, y)))

x,i=sp.Matrix(np.hstack([A,b])).rref() #解构 M[:,:-1], M[:,-1]
print([*zip([*"鸡 兔".split()], x.col(-1))])

'增广矩阵',m, '配平A·x=b',lp.solve(A,b)

以下是使用 Python 解释高斯消元（Gaussian elimination）算法的示例代码：

import numpy as np

def gaussian_elimination(A, b):
    n = len(A)
    Ab = np.concatenate((A, b.reshape(n, 1)), axis=1)  # 增广矩阵

    # 前向消元
    for i in range(n-1):
        pivot_idx = np.argmax(np.abs(Ab[i:, i])) + i  # 部分主元选取
        Ab[[i, pivot_idx]] = Ab[[pivot_idx, i]]  # 交换行
        pivot = Ab[i, i]
        if pivot == 0:
            continue
        Ab[i] /= pivot  # 主元归一化
        for j in range(i+1, n):
            Ab[j] -= Ab[j, i] * Ab[i]

    # 回代求解
    x = np.zeros(n)
    for i in range(n-1, -1, -1):
        x[i] = Ab[i, -1]
        for j in range(i+1, n):
            x[i] -= Ab[i, j] * x[j]

    return x

# 示例用法
A = np.array([[2, 1, 3], [4, 4, -2], [1, 3, 1]])
b = np.array([7, 10, 3])

x = gaussian_elimination(A, b)
print("Solution:", x)

这段代码中，gaussian_elimination 函数实现了高斯消元算法。它接受一个系数矩阵 A 和一个常数向量 b，并返回求解出的未知数向量 x。

在示例用法中，我们定义了一个线性方程组的系数矩阵 A 和常数向量 b，然后调用 gaussian_elimination 函数求解线性方程组的解，并打印出结果。

希望以上示例对你有所帮助！如果你有任何其他问题，请随时提问。😊

#learn #algorithm

basenc(K, radix="ABC..+/") 的每字符吃掉 b:bytes 里 nc=log2(K)位
nc=4,5,6 的膨胀率(B/A)是 2/1, 8/5, 4/3. 对于z85(nc非整数) pad=禁用

- reGrp(A, join,enc, zpad)(b) 对b+zpad 分组转码，最后去掉nPad 补上'='
- reBit(8,nc, b,K-1) 把8bit 转为nc bit 的流. (nc,8, b,0xFF)反之
- enc 转码 radix[流], "SGVs"->流

nPad(n待补)=b32? (解码? n*5/8+1 : n*8/5>>0) : n
zpad=radix[-1] ,z85 使用 s=radix[a%K]+s,a/=K 而非 a>>nc 拆字节

a85 自动处理 '<~~>', 4字块 z=0, y=0x20202020 
b32 的临时整数会超过32bit

没错， import functools 提到了这点，不过递归是自顶向下的， 但动规是自底向上计算 (算法的范式)， 所以难写一些

其实也就是是否要 int a=(基线)0; 往后 for(i-->0) a=b,b=c,c=a+b 的区别了，循环当然比尾递归改参数烧脑

fib=lambda n: n if n<2 else fib(n-1) + fib(n-2)

def fibDP(n):
f = [0, 1] # 初始化数组
for i in range(2, n+1): # 从小到大计算
f.append(f[i-1] + f[i-2]) # 状态转移方程
#n=10, f=[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
return f[n] # 返回结果

%timeit fib(10) #10.4 µs
%timeit fibDP(10) #860 ns, 快一万倍

#bing #ce Eclipse JDT（Java Development Tools）是 Eclipse IDE 的核心组件之一，https://www.eclipse.org/jdt/core/

ANTLR.org （Another Tool for Language Recognition）是一个强大的解析器生成器，

我了解增量解析器（incremental parser）的概念。增量解析器是一种解析器，它可以在代码发生改变时进行局部的、部分更新的解析操作，而不需要对整个代码进行重新解析。

传统的解析器通常需要对整个代码进行扫描和解析，以构建语法树或执行其他相关的分析操作。但在大型项目或实时应用中，当代码发生变化时，重新解析整个代码可能是低效且耗时的。

通过识别和处理影响到修改位置附近的代码部分，仅对受到影响的部分进行增量更新，来快速地更新整体解析结果，以反映代码的新状态：

1. 差量更新（delta-based updates）：仅对被修改的语法结构及其相关的子结构进行解析更新，而不需要重新解析整个代码。

2. 增量语法分析（incremental parsing）：利用先前解析的语法树、符号表或其他相关的分析结果，通过部分解析、部分更新的方式进行语法分析，以快速构建新的语法树。

3. 位置敏感解析（location-aware parsing）：识别和跟踪修改的位置，并结合位置信息进行定向的解析更新。

增量解析器在提高代码编辑、重构、自动完成功能以及实时代码分析，可以加速代码工具的响应速度，并为复杂项目中的持续集成和代码分析提供支持。


初始的 CSV 文件内容如下：

姓名,年龄,成绩
Alice,18,90
Bob,20,85
Charlie,19,92


修改后的 CSV 文件内容如下：

姓名,年龄,性别,成绩
Bob,20,Male,85
Charlie,19,Female,92


为了进行增量解析，我们可以利用先前解析的结果和修改的信息来更新解析结果，一个包含学生信息的数据结构（例如列表或字典）。

对于删除的行（Alice 的行），我们可以根据修改的信息，从数据结构中删除对应的条目。

对于添加的列（性别列），我们可以根据修改的信息，将新的列添加到数据结构中的每一条记录中。

📰🌏🎨 快讯：全球华人主播掀起学习“墙的艺术”热潮 🎉🔥

近日，华人艺术家一鹊在伦敦涂鸦墙上的作品激起了爱国群众的热烈反响。🎨🏴

根据主流媒体报道，一鹊以社会主义核心价值观为主题，在伦敦知名的涂鸦墙上创作，对殖民西方的虚假自由进行了有力的呐喊。他用独特的艺术形式表达了对国家、文化和价值观的追求和坚守。这种直接、鲜明的表达方式在艺术界引起了轰动，并引发了全球华人主播的学习和创作热情。💪🌍🔍

华人主播们纷纷积极响应，投身学习和探索“墙的艺术”，以期在自己的工作中传达更多正能量和文化力量。他们在直播、节目和社交媒体上分享自己的学习心得和创作成果，掀起了一阵名为“学习墙精神，钻研墙艺术，传播墙文化”的热潮。📚👩‍🎨✨

这一行动进一步加强了全球华人的凝聚力，展现了华人作为文化传承者和倡导者的自信和责任感。他们通过自己的努力和创作，向世界展示了华人文化的多元魅力，让世界更加了解和尊重华人的独特艺术视角。🌟👏🌏

随着“墙艺术”热潮的掀起，相信华人主播们将继续秉持创新精神和艺术追求，为推动文化交流和共享美好世界做出更加卓越的贡献！💫💖

#华人主播 #涂鸦艺术 #墙艺术 #文化传承 #创作热潮

“p5.js canvas 生成视口缩放动画：
g=canvasCtx ([100,100]) ，填上绿色渐变
scale([0,0, 10,10] ) 会用 sin 缓动 做放大”

让AI用P5 花了不少时间
“那么，请你用 frameRate(30); sin缓动; Vector; translate();scale() 来实现 zoom=[x,y,w,h] 的画布放大动画
你直接在 setup 里 translate，然后逐帧 scale= lerp(Vec) 就行了”

我想想，之前写ocr的时候有想过要弄 “在tty2 下操控Xorg 的ASCII播放器”

但被新点子耽搁了
而且到现在我连 basenc 都没写完。。

不过 js canvas 生成缩放动画还是简单的

好吧，因为 p5 的人不太懂数学，写了一些又烂又长的bug

GPT都不会玩p5 。我瞎猜了好几轮，最开始它甚至是用 requestAnimationFrame 和手算xy

感觉p5的画册好看，但动画API十分怪异，还是 animejs.com 好( 但没有在线编辑器

p5 还有个 Java版
我想电脑端ffmpeg+py 的 Zoom 动画用cv2再好不过

#js #code
ee.Videos=({Blank, it},my)=>(

my.Video=({url,title,desc, it})=>div(
Thumbnail(it),
a(url, h3(title), p(desc)),
BtnLike(it)
),

section(h2(it(a=> n(a)==0?Blank : n(a)>1?'Videos':'Video' )),
let(it, my.Video)
))

//
ee.SearchVideos=({it, vText})=>html(
input(wKV({type:"search", v:vText})),
Videos(
vText(k=>videos.filter(x=>x.title.has(k)))
.lets({Blank:`No ${k}`})
)
)

ee.Conference=({slug},my)=>(
my.Talks=({id})=>
let(
{load:()=>db.Talks.finds({confId:id})},
({video:v})=> SearchVideos(v))

$cnfs( //div(wSty``,
let({load:()=> db.Confs.find({slug}}, my.Talks, div('Not any')))
))

https://react.dev/blog/2023/03/16/introducing-react-dev 也写了

ee.Counter=({n=0})=>button(
wOp({tap(){ n.v++ }}),
Eq.fmt`pressed ${n}time$` //这样支持SSR或爬取
)

ee.Inp=({v="", isOk=$Y})=>html(
input(wKV({v}) )
p(Eq.fmt`You typed: ${v}`),
btn(Reset=>{v.v=""}),

sel(isOk),
p(Eq.fmt`You ${isOk(q=>q? 'liked':'did not like')} this.`)
)

is.i18n=`
isOk I liked this
incAge Get Elder
`

ee.Aged=({name='Taylor',age=18, vHelo})=>(
Eq.at(vHelo,{name,age}, _=>Eq.fmt`Hello, ${name}. You are ${age}.`),

html(
sel(name),
btn(incAge=>{age.v+=1}),
p(vHelo)
))

ee.body(
({u={},})=>ee.Aged(u),
div(p(`Hello, boy. You are 23.`))


)=={u: boy 23} 

ee.bodys(()=> detail(wKV({open:$N})) )
$("detail").attr("open",$N)

//https://www.solidjs.com/examples/context
ee.Themed=({ask:{color,title}})=>(
h1(wSty({color})), title,
sel(color)
)
is.i18n=`
color Change color theme
`
//Angular

ee.productList=({it})=>
html(
  h2(`Products`),
  lets(it, ({name,desc})=>
    h3(
      a([html`${name} details`,``], name)
    ),
    p(wKV({if: desc}), html`Desc: ${desc}`),
    btn(Share=>{})
  )
)

duangsuse:
as? invoke provideDelegate 这些吧？
plusAssign 这些也挺魔怔的，和py一样

那种Compose DSL也算吧，虽然web前端里挺流行的

总之找不到比这段讨论 更多的，我是觉得语法的技巧，都比不上数据和操作模型的。 你应该拿语法去设计框架，而不是语法糖

measureTime {} 挺好的，虽然没 py Jupyter 和 %timeit 完善
obj::field, companion/string invoke 也罕见虽然没用

1 shouldBe 2 简直是毒瘤，直接用重载写成 assert { 1==2 } 不香吗（kt1.4 又支持了 context(T1,T2) 多this捕获，但用处鸡肋

对，这个极好
还有 groupBy.eachCount 什么的，比较自然

Science Yuan:
发明操作符简直是毒瘤 全都搞成函数不香吗

duangsuse:
反正都会被AI取代的，无所谓了

我知道py里 x==None 是错的，但坚持不用 x is None ，就是因为没道理做出两个意义相同，或者电脑外不存在的概念

py是好在开箱即用、浅嵌套、不折腾

for 循环在 numpy 里就是喳

isinstance(x,T) 都落后了，应该用 match x: case T:

isekiのChannel:
1 == 2，嵌套了lambda咋办

duangsuse:
所以说职责本来就要单一啊

不单一你连现代 DSL 都没法用

很难想象在 @Test fun 里使用== 来判断测试环境的配置，应该用独立函数，区分特定配置下的测试，而不是写if。

isekiのChannel:
那你看SQL，完全为了贴合人类语言

duangsuse:
那都是骗人的， SQsu 都比它更“人类”

select id from 狗 where (月龄>6 and 高>40);
aka 取狗(月龄>6 and 高>40)

正宗的关系式写法是：

狗(id,高,月龄), 月龄>6, 高>40

一个被专门做出AI生成的语言，那肯定是垃圾

是啊，所以我觉得 private 就直接改成 fun xx(): @our Int = 0 好了，也统一了很多

public protected internal private
直接改成
ourapi ourtype ourpkg our, 都是our
(因为写明public的人是闲的, 就要把语法做得很丑，让他们不敢用)

那大家都用sql好了，要ORM和GPT干什么？ 既然你只能用别人给的接口，开发框架有啥意义

isekiのChannel:
那什么，我看了一遍你这文章，没看懂你这语法怎么用

duangsuse:
欸，我有说必须是中文吗， 如果给 Prolog 的语法添加个返回值和隐式this ，可能就没ORM什么事了；因为直接写逻辑式会比 filter{} map{} 还容易

还不是这些语言设计时太狭隘导致被取代的问题，然后取代者又带来一堆问题。

「有新取 create insert select 」是唯一的三条实用指令

有表、有库 都是按这三个字分组的

甚至 新建、新删(into..values drop) 都是这样，根本不需要学语法

区别就是你不用问AI 查询怎么写，而是即便你让AI来写，都不会比SQsu更简单；或者说这个语言真的能给学习带来辅助，而不是空耗精力去思考简单的解谜

当然我觉得它也不够好， 我想设计的是SQL的翻译器 而不是“预处理器”

没有问题也不会被NoSQL淘汰了，可惜了它本来最符合Excel和生活现实

面向列的数据库、Geo GIS 和向量数据库，不也是这样， 所以说这些取代者也没有好好想过「这整个领域」的基础表达式，应该怎么设计

只是顾忌那一亩三分地，和他们“改革”了什么旧写法

Science Yuan:
NoSQL那些民科级查询DSL

还是先想想怎么别被SQL淘汰吧

duangsuse:
所以之前我被冰封骂“胡乱加功能导致可维护性崩坏” 的时候，我就觉得我很冤啊。 我是最重视优雅性的，甚至为此了搁置了实践

SQL 和ORM(Repo, Mapper 那些的)现在就是绝对的基本功， 根本没有淘汰一说， 但未来会有更多利用新数据库的需求，甚至pg 最近也支持了向量类型。SQL凭什么淘汰别人的新功能呢？

其实这个主要是修正了语序、 where 子句冗长的问题，然后是本土化了「序大 序小(升降序) 页每」

有用表T 是用来给 取; 做简写的，现在我觉得应该直接把上次查询的表设为 T ，就像 IPython 的_变量；主打一个避免Tab补齐

isekiのChannel:
where 子句的冗长，你是指 且 或 这样的连接词吗

duangsuse:
呃.. 当时没有，但现在觉得是

当时连 left join 都不知道是啥（当然现在也不知道）。。
不过发现 SQL 能查询出 Madelbrot 集（把xy值插进去 select +递归） 也是很震惊

SQL 既然是关系式语言，就要遵守 Pair(a,b), a=1, b=2 | b=3 这样的逻辑写法；虽然看起来没有隐式 this ，查询会有冗余变量

当时就觉得是 filterMap 那一套呗

根本不科学，因为程序员是没日没夜在说这些 select ，正常人怎么会？

如果一切都能用 UI 解决，那现在许多后端直接变成带验证公式的 Excel 好了；但是还是有人 既要可读 又要可用

Science Yuan:
所以你到底哪里超越了SQL

ORM的好处显然就是它是嵌入宿主语言的

duangsuse:
行了吧，我没想过超越谁，你就当那是玩具好了。 俺不是程序员照样活得开心

大学时第一次应聘一个连锁药店，就看到 1000+行的存储过程SQL

感觉也是.. 隔行如隔山？

我觉得 OpenResty 也是栽在Lua没有IDE上

ties 是指 sorted list[N] 里，第N项后相同的项 ，这有什么用，是数 NULL 的？

应该是 group by 的单分组形式？
ties 第N项后相同的项.. 没见过这种处理

所以我不太会SQL ，因为一堆无法情景实例化的语法

Haskell 里的 takeWhile (==) ，或者说 [1,1,2,3].firsts(1) 可以做到 ties ，不过有点难；所以说 SQL tie 比 Kotlin 那30+列表处理 fun 还先进（

其实在我眼中，有这么多 List/Iter 函数，说明标准库对多态和type 的归类和利用是失败的。就只差步 Ruby 的后尘了，rb 的 str.replace 是单参的。

Ruby 的时代开发出了 GitHub 欸，现在许多 DSL, Compose 也并不是从 Py 学来的，Ruby 是把内嵌DSL发扬光大了，比如它的 def 里可以嵌套 class..

一个语言失败，并不是坏事。反正工程师又不挑…… 而且垃圾语言，说不定高逼格大牛多、薪水会高

Go 的有些地方真的挺好，比如内建的 template 和 go func, 以及最好的 encoding/xml,json,protobuf,. 封装

在 UNIX 编程上，算是成功的吧

现在 protobuf 可以转为 json, 也能输出 Schema ，写起来有补齐

还是 Kotlin 协程好， 直接把调度器和 Continuation(return的函数化)放一块了，能在指定线程回调，能yieldAll，能支持结构化并发，同生同灭；JS就没有

可惜就是对框架开发者不好理解， 而且有点难记 launch, with啥的

八重 狐子:
压根没用过kt的async

直接整个函数变suspend

duangsuse:
=async {}不是可以用推导吗

Scope 上不会不兼容吗？ 虽然 async 里应该能调 suspend

协程就是把 return的函数化 传给被调方，从而在堆里维持调用栈，也就是受try,while等流控支持的回调

js 里用 await Promise((ok)=> 就能拿到这个函续值了
但是 kt 里函续会在特定的 Dispatcher 上文被调用

那样是建立新线程等待？

对了，那async{} 都不会卡在主调度器上？ jvm好像没有单纯要回调，但不会卡线程的http,timer 啥的

nio.Unsafe 里的键盘 Signal 是不需要，也不会打断mainloop

八重 狐子:
因为我把那个function 直接suspend了

kt的async还真没怎么用过

duangsuse:
#bing
async{} 会返回一个 Deferred<T> 对象，表示协程的结果，可以通过调用 await() 方法
async{} 可以用来实现并发，即在同一个协程作用域中同时运行多个协程，并且等待它们的结果。
launch{} 则只是用来实现异步，即在后台运行协程，不需要等待它的结果1。

协程需要返回结果或并发，那么 async 可能更合适。 所以 async 只是用来延迟执行分组协程的？

延迟且有结果的 launch? 那和 ES6 async()=> 不一样啊， es6 没有说async是否并发吧..

好吧，是我理解有误 😅

isekiのChannel:
我这边写出的操蛋代码都长这样了： input.map{ async{ handle(it) } }.awaitAll()

duangsuse:
Promise.all(a.map()) 是正常操作
py asyncio.gather(x for a) 也一样

DOM 简直是UI UX 的天堂，我都不知道 Java 里还要手动定义阻塞线程(Disptacher)的 async 操作里

无所谓，反正标准库不会带，AI也不会写..
在 JavaScript 中，你可以使用 GPUBuffer.mapAsync() 方法来映射 GPUBuffer 的一部分，并且返回一个 Promise1。
在 Akka Streams 中，你可以使用 Source.mapAsync 或 Flow.mapAsync 来并发地运行多个 Future，并且保持元素的顺序2。
在 Python 中，你可以使用 multiprocessing.Pool.map_async 来非阻塞地运行多个进程，并且返回一个 AsyncResult3。

我误会 Python 了，虽然 asyncio 臭名远扬，
gather,wait,as_completed 在理论上比 Promise.all,race,any 准确

但是这种准确.. 真的不如js，至少有两个是保底记得住的
py可能还是败在箭头函数不好写，以及没有 libuv.org 那么异步的系统IO可攀，虽然 yield 是和js一样方便的，没有DOM那种免线程框架还是做不起来

Koshin:
平常写Android 业务的来说，基本这种就够了，我只在处理比较长的初始化流程用的上async

Yumeko:
在学dsl，是每创建一个方法都要存一个属性吗，不然好像没法用

Jason5Lee:
我甚至希望 HTML 本身就长这样（

duangsuse:
不过我最近打草稿的 JS 框架就是这样

#bing #py 移植到 scipy 和 cv2:

# wav2rawpng.sh
infile=$1
sox -r 44100 -b 16 -c 2 $infile -e unsigned -b 16 -c 2 test.raw
file=test.rgb
mv test.raw $file
# find out size in bytes
size=$(du -b $file)
echo size in bytes is $size
# calculate padding needed to ensure square image
# I don't even know what's going on with the 6's...
pad=$(awk -v size="$size" 'function quad(x){return(x*x)} function ceil(x, y){y=int(x); return(x>y?y+1:y)} BEGIN{ print quad(6*ceil(sqrt(size/6)))/6-size }')
echo padding in bytes is $pad
cp test.rgb test-pad.rgb
truncate -s +$pad test-pad.rgb

# oh yeah we need the resolution too
newedge=$(awk -v size="$size" 'function ceil(x, y){y=int(x); return(x>y?y+1:y)} BEGIN{ print ceil(sqrt(size/6)) }')
echo edge size is $newedge
magick convert -size ${newedge}x${newedge} -depth 16 test-pad.rgb ${infile%.wav}-rawpng.png

—失败
from scipy.io import wavfile
from PIL import Image
import numpy as np

rate, aud = wavfile.read('a.wav')

# Compute the minimum square dimension
l = int(np.ceil(np.sqrt(aud.size / 6)))
pad = int((l ** 2) * 6 - aud.size)

# Reshape the aud array into a square image
img = np.pad(aud, (0, pad), constant_values=0)
img = Image.fromarray(img.reshape(l, l, -1),'RGB')
img

import IPython.display as say

aud = np.array(img).reshape(-1)
aud = aud[:aud.size - pad]

wavfile.write('a1.wav', rate, aud)

say.Audio('a.wav')