duangsuse, [2024/3/29 20:45]
搞成 useNew { XInputStream() } 呗，既然拿实例就能报错

duangsuse, [2024/3/29 20:46]
我到是觉得use() 本来就该vararg ，类似Promise.all

duangsuse, [2024/3/29 21:01]
其实@autoclosure 也是好看的，

use(::FileInputStream, "a.txt") {}

更统一些

resScope{ ins1.use(); ins2.use(); } 更标准些

但关键问题是构造器异常这种，太莫名其妙
为什么不提供open()

Jason5Lee, [2024/3/31 15:00]
我倒是想过最佳的 GC 语言 mutation 控制机制

Jason5Lee, [2024/3/31 15:01]
Kotlin 目前的干法是，Mutable 接口继承非 Mutable 接口，所以非 Mutable 接口的对象理论上是可能 Mutable 的，但是大家约定俗成一旦对象被当初非 Mutable 接口就不能变了。

Jason5Lee, [2024/3/31 15:03]
kotlinx.immutable 的问题是会有很多转换。Kotlin 当前设计实际上考虑了 Java 一个接收 List 接口但实际上不会修改的这个情况，牺牲保证换转换方便。

duangsuse, [2024/4/3 09:46]
就是一个curry化啊
吧语法重载下延迟执行，泛型<R>呗

duangsuse, [2024/4/3 09:49]
我是说
Lit(Int): T<Int>
Add(A,B): T<Int>
toStr(this:T<*>): T<Str> 就够了

duangsuse, [2024/4/3 09:51]
总之这种 #haskell 上也有
https://okmij.org/ftp/tagless-final/index.html#:~:text=class%20Symantics

称为GADT https://stackoverflow.com/questions/33928608/typed-abstract-syntax-and-dsl-design-in-haskell

duangsuse, [2024/4/24 09:31]
没有啊，
@deco
def f():
也就是 f=deco(fBody)
可以在调用处用

duangsuse, [2024/4/24 09:32]
end='' 属于幼儿园知识吧

duangsuse, [2024/4/24 12:22]
我也很无奈啊，怎么这么基础的 logpoint功能py都没自带呢？到处print真难写

duangsuse, [2024/4/24 12:23]
用着函数式的GC，连组合函数都不会用，还手动print

duangsuse, [2024/4/24 12:24]
明明是可以 from traceback_with_variables import activate_by_import

duangsuse, [2024/4/24 12:30]
logging应该是 systemd 的同款功能吧，这个是debug

duangsuse, [2024/4/24 12:32]
就看到一个 @logger.catch
我觉得还不如直接整个globals()自动应用好了

duangsuse, [2024/4/24 12:33]
https://loguru.readthedocs.io/en/stable/overview.html#exceptions-catching-within-threads-or-main

duangsuse, [2024/4/24 12:35]
logging就应该搞个绝对化，一概不要，让 journalctl来做
这么简单的事情还分编程语言

Show HN: I built a non-linear UI for ChatGPT
Teranoptia – 一个奇特的「生物组合体」开源字体

https://jesse-zhou.com
这首页做得好帅啊
https://www.kubota.com/futurecube/
https://retrage.github.io/lkl-js/boot.html

#ai #web spider
code snippets for web scraping using Scrapy, Puppeteer, and Apify with 2-space indentation and using let (for JavaScript variables):
python
import scrapy

class MySpider(scrapy.Spider):
name = 'example'
start_urls = ['https://quotes.toscrape.com/']

def parse(self, response):
for quote in response.css('div.quote'):
text = quote.css('span.text::text').get()
author = quote.css('span small.author::text').get()
yield {
'quote': text,
'author': author,
}



javascript
const puppeteer = require('puppeteer');

(async () => {
const browser = await puppeteer.launch();
const page = await browser.newPage();
await page.goto('https://quotes.toscrape.com/');

const quotes = await page.evaluate(() => {
return Array.from(document.querySelectorAll('div.quote')).map(quote => {
let text = quote.querySelector('span.text').textContent.trim();
let author = quote.querySelector('span small.author').textContent.trim();
return {
text,
author,
};
});
});

console.log(quotes);

await browser.close();
})();


javascript
const Apify = require('apify');

Apify.main(async () => {
const input = {
startUrls: [
'https://quotes.toscrape.com/'
]
};

const crawler = new Apify.CheerioCrawler({
startUrls: input.startUrls,
handlePageFunction: async ({ request, $ }) => {
const quotes = [];
$('div.quote').each((index, el) => {
let text = $(el).find('span.text').text().trim();
let author = $(el).find('span small.author').text().trim();
quotes.push({
text,
author
});
});
console.log(quotes);
}
});

await crawler.run();
});

These updated snippets use 2-space indentation and let for JavaScript variable declarations in the Scrapy, Puppeteer, and Apify examples..

duangsuse:
go,c#定义
kt表达式
c数据类型
java main函数，这个是最逆天的
开倒车

pipeline这种稍微用过kt都应该拿.let(fn)换掉
什么落伍的伪函数式，oop不能函数式吗？

然后Token list宏是最绷不住的，不就是不会干扰到字面str的replace吗
怎么不用这玩意做个SWIG的功能试试？还不如html模板。

学学ruby的define_method吧，或者至少装个b用rust的ast版正则婊答式也好

extend T with I{} 可以用adaper实现，反正都要判定多态，本质上是编译期的糖
绿线程这个lua都有，不过cj比较好的是使用go风格spawn{}.get并发，没有kt 结构化scope的理解门槛

不如P/Invoke啦，这种特性都没必要教，import cffi 都是直接include.h
https://blog.csdn.net/dreamdonghui/article/details/76343671

最可气的是它仍然在到处pub private
java里这种凑字数行为
然后mut this与copy this也有待商榷。
cj的list是值类型吗，如果不是rust那样准确的区分是否可变，mut引用就是文字游戏

struct不支持子类型是标准操作， https://crystal-lang.org/ 和cpp是这样的

kt里mutlist自己就是可变的，mut func与否都可变，go里取决于append()

不如这样，module和class都可以有init和main()，后者是operator() 🌚

搞特殊哪有这么冠冕堂皇的

奇怪，libc_start_main好像都没这么特殊对待
属实是脚本化入脑入心入魂了

至少C标准里.so可以同时有init
一个.c编译单元就是一个object{}

这种事情c就干过， -Wimplict-int
c的设计者kent还聪明些，比cj这个泛用的多，然而时间证明了他的错误

好吧，static inner class本来就该被淘汰了
inner class本质上是class+构造器fun而已

本身就是oop拿来凑数的，其实把它视作可override和extend的fun才对

duangsuse:
感觉有点……一言难尽
到处 private const return 很标准，我无话可说，这是ES6本身凑字数的毛病。
但作为程序员就不要比标准库聪明了，DataView递归下降挺合适的，能逐byte，大小端slice功能完备，读流简单 import re 都有写

洋洋洒洒几百行，一问只能load,函数名全掐死为readXX()，dump或in-place修改那是不可能的。js 语意化的优势在哪里呢？cpp是能做到这两点的。
其实并不是js差，而是脚本用完就扔 懒得总结经验复用吧。
JSON挺复杂，PCRE也只要20行。难道一个2d数组比这还复杂吗 https://regex101.com/r/vyUdBa/1
https://github.com/Web-Media-Foundation/infrastructure/blob/master/packages/ogg-polyfill/src/

readUint{2..6}
readUint{8,16,24,32} 写时手真的不会抖吗，这么多余的常量转函数名 定义时不累 调用方不觉得多余吗？
凭什么只能read呢？ fitUint(nBit, obj,key){if o[k]undef or isF5:read else write} 不行吗

TS好像是支持类型体操的，这种fun在for()里定义亦非不可能，虽然我无法理解procedural到这个地步是想干什么。OOP也不是这么玩的

我是说，至少可以少写点js循环
你的代码很规范，非常业界化，这不容置喙，但它显然不是足够通用的代码

https://readhacker.news/s/6a97H

注：火柴盒图的柱子标记minMax，众数和平均数

B-Trees Require Fewer Comparisons Than Balanced Binary Search Trees (Score: 150+ in 1 day)

Link: https://readhacker.news/s/6aa9u
The First Animal Ever Found That Doesn't Need Oxygen to Survive (Score: 150+ in 23 hours)

Link: https://readhacker.news/s/6a9qp

https://github.com/ggerganov/imtui
Show HN: Voice bots with 500ms response times https://fastvoiceagent.cerebrium.ai/
https://github.com/ButTaiwan/evilsung

邪恶宋体！
前几天还在群里开玩笑说我们需要ChatGPTcc来替代手工编写汇编优化，没想到……

https://x.com/AIatMeta/status/1806361623831171318

#java #py
duangsuse:
https://t.iss.one/im_RORIRI/17511
卧槽
把前缀相同的param.给struct化啊，还有，f64不支持NaN么

栈上分配超过6个参数是不可接受的，x86有几个传参寄存器来着? daniel'si dress costs r89

完全不能拆成多个fn或者用列表处理吗
感觉这个程序是属于numpy的

如果你wrap成tuple bmp_chroma{} 就可以用 x.0~x.11表示参数

float类型ieee自己就有规定夸语言的null值，套一层属于自讨没趣

duangsuse:
xml在ast方面确实更好，但它被linus喷了
我只是举个例子

函数如同查询，是完全可以符号化数据化的

举个例子， NUM+a+b+1
[".0.1 NUM a b", 0,1,2, .+, '.1', .+ .+]
就可以是json的等效表达
0是全局变量, 1 2是参数， .+是调用

.0.1 代表这个数组保存了有0个变量，1个绑定，剩下2个参数的节点图，或者说“函数”

自古以来脚本语言是最好理解的，因此“静态声明”必须被解读为编译期项的添加，而不止是一种不运行的语法

这样才方便编写预处理、方便理解类型检查，这样无论编译还是运行时，使用的数据模型都统一为“不纯”的
程序员才不会自以为数据绑定是魔法框架的专利，然后整出一大堆脚本里不存在的设计模式

总之，现在的语言只有Zig在编译期计算上是合格的，其他通通笼罩在魔法师的阴影下

我在找一种类似 import cffi 的 kotlin inline c jni code 的元编程库

发现一个纯cpp写jvm lib的方法 https://github.com/google/jni-bind?tab=readme-ov-file#methods

🌚有点像C#的il2cpp ，不过我最理想的方法是，kt代码直译为cpp external fum

Kotlin/Native does not support compiling Java bytecode to native code, which would be necessary to use the kotlin-jvm stdlib.
Calling all JVM APIs through JNI is definitely going to be much, much, much slower

SWIG和JNA大概也是类似的，不过没有我理想的那种多语言无缝衔接

https://github.com/LanderlYoung/Jenny 可能比JNA好 https://github.com/java-native-access/jna/blob/master/www/GettingStarted.md

python社区的元编程功力实在是太棒了，或许是因为没有第二门语言的语法和反射如此简洁

py除了自带ffi，还有cython,mojo,numba,taichi一大堆子语言，根本不会像java这样要配置什么编译链接，一切都是框架主动生成

duangsuse:
奇怪，你是要支持 http:#hash 吗，为什么要多此一举匹配path呢，toUrl又不能直接拿来请求

而就这个例子，应该用resp.ContentType 是否为application/gzip
或 Content-Encoding: gzip https://developer.mozilla.org/zh-CN/docs/Web/HTTP/Headers/Content-Encoding

你可以断言url没有#hash直接对str判定

确实，text和octect是最常见的错误MIME

duangsuse:
typealias啊，支持运行时验证和扩展fun

🌚大胆的想法
final class是extfun的另一种写法，不需要运行时的虚表支持
如果jvm能搞这个。。

🌚把Visitor和序列化读/写统一后，现在回看encoder模式感觉好复杂啊
这一大堆和上面那条FitPrimSeer的区别，仅仅是后者不支持验证可选字段，加个bitset就结了

这不会是官方实现吧
buildSerialDescriptor ，确实是
又要提供Descriptors又强制手写encode就感觉莫名其妙
也没看出是用非反射方法赋值啊

https://github.com/iseki0/kotlinx-serialization-bencoding/blob/master/src/commonMain/kotlin/space/iseki/bencoding/internal/BencodeEncoder0.kt#L112
🌚好吧，确实是……非常，独立于语言本身的类型系统
之前学的IO语法，想手写json rw时就得重新发明了

在Android中实现无障碍访问（Accessibility）时，可以使用 AccessibilityNodeInfo 类来操作 UI 元素。虽然在 JavaScript 中 ev.isTrusted 用于检查事件是否是由用户直接触发的，Android 的无障碍服务没有直接对应的机制，但可以通过其他方式实现类似的功能。

下面是一个简单的 Kotlin 示例，展示如何使用无障碍服务来模拟用户与界面的交互。

### Kotlin 示例代码

import android.accessibilityservice.AccessibilityService
import android.view.accessibility.AccessibilityNodeInfo
import android.accessibilityservice.AccessibilityServiceInfo
import android.view.accessibility.AccessibilityEvent

class MyAccessibilityService : AccessibilityService() {

    override fun onAccessibilityEvent(event: AccessibilityEvent?) {
        // 处理无障碍事件
    }

    override fun onInterrupt() {
        // 服务被中断时的操作
    }

    private fun performAction() {
        // 获取当前窗口的根视图
        val nodeInfo = rootInActiveWindow
        nodeInfo?.let {
            // 查找特定的 UI 元素，例如按钮
            val button: List<AccessibilityNodeInfo> = it.findAccessibilityNodeInfosByText("Button Text")
            if (button.isNotEmpty()) {
                // 模拟点击
                button[0].performAction(AccessibilityNodeInfo.ACTION_CLICK)
            }
        }
    }

    override fun onServiceConnected() {
        // 配置无障碍服务
        super.onServiceConnected()
        val info = AccessibilityServiceInfo().apply {
            eventTypes = AccessibilityEvent.TYPE_VIEW_CLICKED
            packageNames = null // 监听所有应用
            feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC
            flags = AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS
        }
        serviceInfo = info
    }
}

### 说明

- **onAccessibilityEvent**: 用于处理无障碍事件。
- **performAction**: 定义了一个模拟点击的操作。
- **onServiceConnected**: 服务连接时配置所需的无障碍服务信息。

### 注意

- 确保在设置中启用了你的无障碍服务。
- 权限和配置需要在 AndroidManifest.xml 中定义。

<service
    android:name=".MyAccessibilityService"
    android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE">
    <intent-filter>
        <action android:name="android.accessibilityservice.AccessibilityService" />
    </intent-filter>
    <meta-data
        android:name="android.accessibilityservice"
        android:resource="@xml/accessibility_service_config" />
</service>

上述代码为基本示例，具体需求可能需要进一步调整和扩展。希望这对你有帮助！🚀

在 Android 中，虽然没有直接对应于 JavaScript 的 ev.isTrusted 属性，但你可以使用一些方法来判断事件是否由用户直接触发。在无障碍服务中，通常可以根据事件的来源来判断。

以下是一个基本的 Kotlin 示例，展示了如何在无障碍服务中检查点击事件是否来源于用户：

import android.accessibilityservice.AccessibilityService
import android.view.accessibility.AccessibilityEvent

class MyAccessibilityService : AccessibilityService() {

    override fun onAccessibilityEvent(event: AccessibilityEvent?) {
        event?.let {
            when (event.eventType) {
                AccessibilityEvent.TYPE_VIEW_CLICKED -> {
                    // 检查事件的源
                    val source = event.source
                    if (source != null && source.isFocusable) {
                        // 这里可以进行更多的检查
                        // 例如判断是否为用户操作
                        logEvent("用户点击事件: ${event.text}")
                    } else {
                        logEvent("非用户操作的点击事件")
                    }
                }
            }
        }
    }

    override fun onInterrupt() {
        // 处理服务中断
    }

    private fun logEvent(message: String) {
        // 自定义日志处理
        println(message)
    }
}

### 解释：
1. **AccessibilityService**: 继承此类来创建无障碍服务。
2. **onAccessibilityEvent**: 重写此方法来处理收到的事件。
3. **类型检查**: 检查事件类型以识别用户点击。
4. **焦点检查**: 利用 source.isFocusable 检查事件是否与可聚焦视图相关联，帮助判断是否为用户直接操作。

虽然无法完全模拟 isTrusted 的行为，但通过这些方法可以近似实现用户交互的识别。希望能帮助你！😊

当然可以！这里是 Haskell 和 Python 的最短实现最长公共子序列（LCS）算法。

### Haskell 实现

lcs :: Eq a => [a] -> [a] -> [a]
lcs xs [] = []
lcs [] ys = []
lcs (x:xs) (y:ys)
  | x == y   = x : lcs xs ys
  | otherwise = max (lcs xs (y:ys)) (lcs (x:xs) ys)

-- 示例
main :: IO ()
main = print $ lcs "AGGTAB" "GXTXAYB"

### Python 实现

def lcs(x, y):
    if not x or not y:
        return ""
    if x[0] == y[0]:
        return x[0] + lcs(x[1:], y[1:])
    return max(lcs(x[1:], y), lcs(x, y[1:]), key=len)

# 示例
print(lcs("AGGTAB", "GXTXAYB"))

这两段代码都实现了基础的递归 LCS 算法，当然对于长字符串来说，效率较低，可以进一步优化。希望对你有帮助！😊

要在 Android 项目的 build.gradle.kts 文件中配置 .kts 源码的编译和引用，可以按照以下步骤操作：

1. **确保项目结构**：将你的 .kts 文件放在项目的 src/main/kotlin 目录下（或你希望的位置），例如 src/main/kotlin/com/example/myfile.kts。

2. **修改 build.gradle.kts 文件**：在你的 build.gradle.kts 文件中，添加如下配置：

   import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

   plugins {
       id("com.android.application")
       kotlin("android")
   }

   android {
       compileSdk = 33 // 或你希望的 SDK 版本

       defaultConfig {
           applicationId = "com.example.app"
           minSdk = 21
           targetSdk = 33
           versionCode = 1
           versionName = "1.0"
       }

       buildFeatures {
           compose = true // 如果使用 Compose，设置为 true
       }

       compileOptions {
           sourceCompatibility = JavaVersion.VERSION_1_8
           targetCompatibility = JavaVersion.VERSION_1_8
       }

       kotlinOptions {
           jvmTarget = "1.8"
       }
   }

   dependencies {
       implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk7:1.8.10") // Kotlin 依赖
       // 添加其他依赖
   }

   tasks.withType<KotlinCompile> {
       kotlinOptions {
           freeCompilerArgs += "-Xscript" // 添加编译选项以支持 .kts 文件
       }
   }
   

3. **在 Main 中引用**：在主活动或任何 Kotlin 文件中，你可以这样引用 .kts 文件：

   // 示例: 引用 myfile.kts
   val result = eval("src/main/kotlin/com/example/myfile.kts")
   

确保在运行时可以找到并执行该 .kts 脚本。如果有任何问题，可以查看运行日志，以确保一切配置无误 😊。

按照这些步骤，你就能够在 Android 项目中成功使用 .kts 文件了！如果你有任何具体问题或错误，请随时告诉我！🚀

要在 Kotlin 中编译 .kts 文件并将其生成为 fun，你可以使用 Kotlin Scripting API。以下是一个基本示例，展示如何实现这个过程：

### 步骤 1: 创建一个 .kts 文件

首先，创建一个 .kts 文件，例如 script.kts，内容如下：

fun greet(name: String): String {
    return "Hello, $name!"
}

### 步骤 2: 使用 Kotlin Scripting API

接下来，在你的 Kotlin 应用中，使用 Kotlin Scripting API 来加载和执行这个脚本。示例代码如下：

import kotlin.script.experimental.api.*
import kotlin.script.experimental.host.*
import kotlin.script.experimental.jvm.*
import kotlin.script.experimental.kotlin.*

fun main() {
    val scriptFile = File("script.kts")
    
    val compilationConfiguration = ScriptCompilationConfiguration {
        jvm {
            dependencies("path/to/kotlin-stdlib.jar") // 添加必需的依赖
        }
    }

    val evaluationConfiguration = ScriptEvaluationConfiguration {
        // 可以在此处配置和添加额外的环境
    }

    val script = KotlinScriptEngine().eval(scriptFile, compilationConfiguration, evaluationConfiguration)

    // 调用脚本中的方法
    val greetFunc = script.scriptInstance::class.members.find { it.name == "greet" }
    val greeting = greetFunc?.call(script.scriptInstance, "World") // 调用 greet 函数
    println(greeting) // 输出: Hello, World!
}

### 步骤 3: 运行代码

确保你的环境中配置好 Kotlin 和所需的库。运行这段代码，它将读取 script.kts 文件并调用 greet 函数。

### 小结

通过这种方式，你可以在 Kotlin 中动态加载和调用 .kts 文件中的函数！🎉 如果有任何问题或者需要进一步的帮助，请告诉我！😊