duangsues.is_a? SaltedFish

import java.util.function.Function;
import java.lang.reflect.*; //Proxy, InvocationHandler, Method

class Sam {
<FUNC, T, R> FUNC functor(Class<FUNC> fn_type, Function<T, R> impl) {
  FUNC fn = (FUNC)Proxy.newProxyInstance(getClass().getClassLoader(), new Class[]{fn_type}, new InvocationHandler() {
    @Override public Object invoke(Object o, Method m, Object[] args) { return impl.apply((T)args[0]); } // self(o) ignored, argc&m unchecked
  }); //< or use Proxy.getInvocationHandler(impl) to re-dispatch(require samename)
  return fn;
} 
interface XXCall { int call(int x); } 
static public void main(String... a) { 
  Function<Integer,Integer> f = (x) -> x+1;   
  System.out.println(new Sam().functor(XXCall.class, f).call(1));
}
}

26 viewsedited 07:33

#essay #Java 想了下最近的操作
我是想给 JPlayer1 加上 buffer size 参数，再允许负 size 的 multi-thead Queue 渲染，不必手动 RingBuffer
再写一个最简版的 JPlayer3 ，反映无 queue 的绘制逻辑（草生）
想到 ANSI 命令台控制，又想拿 Java 配合下 JNI 去写贪吃蛇，死性不改…… 连怎么取 winsize(w,h) 都想了，JNI 返回 int[] 麻烦，就接收 int[] ，或者干脆变成 long(bitsize=2*int) 甚至 double, ~~没问题的~~ ；只需要提供 initScr(); printYX(y,x,s); endScr(); 然后封装个 writeLineN(n, s) 即可刷写屏幕（最开始打算让 initScr 返回行列大小，或者搞 yxprintf, mvprintf 什么的，还好我反应块，迫真；甚至还有想利用 OOP 抽象掉这个，去兼容 Android 上刷新字符帧的……可以在手机上玩但不必重写游戏逻辑就是不方便）
（吐嘈：写完坏苹果以后我还会做 buffering 了……什么鬼）

现在我终于明白了命令台 REPL 的 Tab 补全是可以 10 行代码以内实现的，看来杂学对 ParserKt 也有用啊，下次就有经验了，复杂的初始化逻辑都倒大霉。

搞完这些又要把之前耿爽模拟器、傅立叶变换动画重构了
之前我还以为耿爽模拟器多难写，主要就是想 (1..randInt(10,25)).map { quotes.pick().fmt(noun=cfg[0], verb=cfg[1]) }.joinToString("") ，后来发现是主语选错了， quotes.take(randint(10,25)).shuffle { it.fmt(cfg[0],cfg[1]) }.joinToString("") 多简单(提性能可以拒绝临时 shuffled List<String> 创建改 indices + joinToString transform)
刚开始不习惯编程记忆变量关系，老是把 N append iter : 1 [noun,verb] cfg 这种简单逻辑背岔，现在不会了（老智障了草）
主要是当初想“既然能拼接，能不能再写个函数「学习」这些文本数据”，后来才发现其实一个 String.replace 就能搞定，也就是说这个函数没比 replace 高到哪去，还是要 text 以外的参数，不过现在我觉得是可以统计下词频的，但那就要 NLP 了，目前我会用 Py 的 jieba.cut 分词

傅立叶的那个是真大佬，不知道是否驾驭的住，反正我对 js canvas 是绝对不熟练的

搞完了还有 mohu 的控制台 game 要重构，得把 List<Pair<String,String> 和 List<String>> 的文本切分搞出来(前者是选项目对对联的游戏数据，后者是excited的界面翻译随机pick)
C++ 11 的 coding convert 还真是不习惯，看起来 wcout 在 Wine 没有用，只能是 wstring_convert API 了
想着这个按换行、分号切分的 2维文本数组可不可以用 ifstream 去读取，答案当然是不可以，如果不以 '\n', ' ' 切分就读不了啦（而且很可能不支持 unicode ）
还是要走 C 的 malloc +full read 那种吗，当然 bytes->Unicode int 是必须的，有时候真想念 Python 那奇怪的 encode decode 啊，写完了或许能做 WASM 支持

14 views06:05

duangsues.is_a? SaltedFish

#essay #Java 想了下最近队列的代码坑 #js #python

64 views06:06

duangsues.is_a? SaltedFish

15 views04:20

duangsues.is_a? SaltedFish

13 views07:14

duangsues.is_a? SaltedFish

GitHub

GitHub - SimpleMobileTools/Simple-SMS-Messenger: An easy and quick way of managing SMS and MMS messages without ads.

An easy and quick way of managing SMS and MMS messages without ads. - SimpleMobileTools/Simple-SMS-Messenger

11 views16:39

duangsues.is_a? SaltedFish

13 views16:58

duangsues.is_a? SaltedFish

#java #learn

9 views02:17

duangsues.is_a? SaltedFish

https://t.iss.one/Javaer/559131 #java #typing

duangsuse in Java 编程语言

你这就是对函数式有偏见了，首先 JS 目前 declarative 化进程是非常实用的，和 Haskell,Scala 那一档完全出于不同的目的

其次泛型就是泛型，和函数式(大点说定义式编程)有什么关系？自信点吧，别总觉得别人装逼(ー_ー) 只有你去做他们做到了的事，才能理解他们。

对于 C++ stl (stdc++ .hpp) 我还是很欣赏的，尤其是 ptr iterator ，只有懂算法的人才能明白 back(), push_back(), insert() 这些动词组合里的语义优雅性，你没接触过自然觉得…

8 views07:22

duangsues.is_a? SaltedFish

#Java #typing 泛型

140 views00:25

duangsues.is_a? SaltedFish

#Java spring https://t.iss.one/Javaer/559650

Alex Lee in Java 编程语言

12 views09:54

duangsues.is_a? SaltedFish

绿色的都比黄色小红色都比黄色大只要判断黄色和你的数据的关系就能排除掉上面或者下面那一块

duangsuse:
二分查找还是分治嘛，对了它是几个指针来着真的能斜切线吗

大佬: #algorithm #Java #code

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        int lenSize = matrix.length;
        int rowSize = matrix[0].length;
        return search(matrix, 0, lenSize, 0, rowSize, target);
    }
    private boolean search(int[][] matrix, int a1, int b1, int a2, int b2, int target){
        if(a1 == b1 || a2 == b2){
            return false;
        } else {
            int mid1 = (a1 + b1) / 2;
            int mid2 = (a2 + b2) / 2;
            if(matrix[mid1][mid2] == target){
                return true;
            } else if(target > matrix[mid1][mid2]){
                return search(matrix, a1, mid1 + 1, mid2 + 1, b2, target) || search(matrix, mid1 + 1, b1, a2, b2, target);
            } else {
                return search(matrix, mid1, b1, a2, mid2, target) || search(matrix, a1, mid1, a2, b2, target);
            }
        }
    }
}

17 viewsedited 08:11

duangsues.is_a? SaltedFish

#java #android #gui #code https://t.iss.one/AndroidDevCn/186768?single

炙尊 in [CN] Android Dev

18 viewsedited 08:10

duangsues.is_a? SaltedFish

#Java #service

22 views13:05

duangsues.is_a? SaltedFish

Deleted Account

以下是使用反射进行深拷贝的示例代码，支持将 `List`、`HashMap` 和对象的字段（使用 `getFields()` 方法获取）映射为新的值，并可以使用 `unifyEqualsPtrs()` 函数将相同的对象指针映射为相同的新对象： ```java import java.lang.reflect.*; import java.util.*; public class DeepCopyUtil { private static Map<Object, Object> originalToCopy…

在kotlin 用java reflect 写一个深度遍历对象图的 deepSetAs(obj,func) ，它支持将 List.E,Map.V,getFields() 内的值修改为func调用

以此定义 unifyEqualsPtrs(obj, oldToDup=mutMap())=deepSet{ computeIfAbsent }
请用函数式,when 减少缩进

它没有返回值，只原地改写。然后field也要递归，而且不要处理str,enum 等基础类型
柯里化 deepSetAs(func)(it) ，递归改成 see(it)。 unify也要

deepSetAs不要有T, obj作为this, else->外提为 forListyFields(see)； unify可以是val 。缩进2空格
ref:https://t.iss.one/dsuse/18706

也可以加个fn参数,调用0参构造器作为返回，实现deepCopy

好的，我根据你的要求再次修改了一下代码，你看看这样可以吗：
#kt #code

kotlin
fun deepSetAs(func: (Any?) -> Any?): Any?.()->Unit = { ->
  val see = deepSetAs(func)
  when (this) {
    is List<*> -> forEach { see(it) }
    is Map<*, *> -> forEach { see(it.value) }
    else -> this?.forListyFields(see)
  }
}

val cf = mutableMapOf<Class<*>, Array<Field>>()

fun Any.forListyFields(see: (Any?) -> Unit) { cf.getOrPut(this.javaClass) { this.javaClass.declaredFields }.forEach {
    it.isAccessible = true
    val v = it.get(this)
    if (v != null && v !is String && v !is Enum<*>) {
      see(v)
    }
    it.set(this, func(v))
  }
}

val unifyEqualsPtrs = { val dup2Old=mutableMapOf<Any?, Any?>()
  deepSetAs { v -> dup2Old.computeIfAbsent(v) { v } }
  }

解答了 https://t.iss.one/Javaer/922625

duangsuse::Echo

#java #performance 值类型vs引用类型
🤔在内存管理/GC良好的语言里，只读数据的引用就是值
java Byte[]和byte[] 在复用上都互不兼容，当然没有值类型了☺️

>我有一个含极多重复str 的JSON，想减少其内存占用

这就是常量池嘛， javac和aapt都会做
JVM的str不可变，一般都是全局缓存的，strBuild 在完成时是会查询这个吧。

文件上编解码时中间加个Deflate流
也可能是结构有毛病，比如把str而非int当成tag

说起来str.intern…

40 viewsedited 04:38

duangsues.is_a? SaltedFish

#java #FP Loney Chou, [2023/10/5 10:50]
只读集合是对 API 作者的极大福音

duangsuse, [2023/10/5 10:47]
如果只读不是在Type期实现的，就会有很大开销。比JS低就是了
只读还会逼你使用map,filter 等写法，对一些程序员可能……太严谨了
可能有人觉得自己用mutable集合，就能做得更快？

duangsuse, [2023/10/5 10:49]
Java 经典的反人类默认值，随地 public final
只能说是Java自身反人类，导致框架难写吧。

duangsuse, [2023/10/5 11:06]
好像是迭代、数组、元组啥的不好区分

“ 这是整个 API 中最具争议的设计决策。显然，静态（编译时）类型检查是非常可取的，但实现此目标的尝试会导致接口层次结构的大小爆炸
Doug Lea 编写了一个流行的 Java 集合包，该包确实反映了其接口层次结构中的可变性区别，但根据用户对其集合包的体验。用他的话说（来自私人信件）“我很痛苦地说，强静态类型对于 Java 中的集合接口不起作用。”

duangsuse, [2023/10/5 11:07]
Java就是太智障了，你看 Py,Kt 对可变性的实现不就很正常，哪里有那么多特例？

典型的过度工程大佬，已经要被能随意跨界的JS,Py等语言抛在后面了，现在又跟不上明确化类型的新语言
Ruby的元类链都没 MutableXX 那么复杂，Java还觉得不行

学了几句算法觉得自己牛了，但其实那是可以随便替换的，连接口的不标准都有先人犯过

list instanceof Sorted
OOP的正常typetag 组合不会用，反射却挺擅长（
Java当时也就是给数组加个bounds，给指针保存上type ，实在是没必要强到runtime去做Obj.freeze 这么弱的检查

duangsuse, [2023/10/5 11:13]
这就是算法和API的区别啊。运行时凭什么决定设计和编译期的概念呢
编程里就没有一个「有实用价值」的东西是计算机先有，然后设计师才拿出来用的

肯定不能让Java、VB这种垃圾语言，干扰你的思路的

duangsuse, [2023/10/5 11:14]
runtime check 都是外语，FFI 要考虑的事情了……你可以把FFI跨语言的情况，都理解为明确使用了 as cast

你都已经脱离Kotlin编译器了，还想继续使用各种语言和检查特性……(这跟说 private 也不是 private 一样
List和 MList<out T> 都会限制set()的…… (只不过MList不限制reverse)

duangsuse, [2023/10/5 11:38]
你不能说单靠一个类型，去把 list 当作Tuple来用。
单单结构不可变的称为 Array ，但现在大多数人只会用list 。还是Py的正确，tuple正好能对应上dataclass ，有用法的依据

你说的那种，是纯函数的不可变吧…… 不是类型上

意义真的不大，无非是把堆里的变量放栈上改写，或者栈变量换伪递归，那有什么用…… 又麻烦又慢 😓

变量关系式编程(LP)里，函数式的 Memo f()=x+1 可以直接表达为 f(out y,x) 的细粒度重计算，不仅不存在“赋值”，也不需要那些纯函数的过度检查

一些人觉得 React是什么FRP，functional响应式。但其实把可变数据，理解为含Var的不可变，比纠结于List纯不纯好玩的多

类型姑且还是对心智模型的硬化，纯度这些可都是虚无缥缈的风格格调了。有趣的软件未必靠FP来写。某些函数式lib的样板代码不比rs,go的少，代码质量只能是看人，是否憎恨冗余

15 views04:08

duangsues.is_a? SaltedFish

#java #backend #design
>用 jvm bcel 生成 class T{ static int intFn1(char _0) { return 0; }}

int 要扩充到对int,char
Fn1要扩充到 Fn3

kotlin 2空格减少变量名

ClassGen cg = new ClassGen("T", "java.lang.Object", "T.java", Constants.ACC_PUBLIC | Constants.ACC_SUPER, null);
MethodGen mg = new MethodGen(Constants.ACC_PUBLIC | Constants.ACC_STATIC, Type.INT, new Type[] { Type.CHAR }, new String[] { "_0" }, "intFn3", "T", il=new InstructionList(), cg.getConstantPool()); 


il.append(InstructionFactory.createReturn(Type.INT));
mg.setMaxStack();
// 创建一个对应于方法的MethodGen对象
cg.addMethod(mg.getMethod());

cg.getJavaClass().dump("T.class");

🤔 我看生成构造器和方法签名还挺简单的
不过此例也不涉及 this.x=arg0
你试试让AI写becl 它应该能基于getClass()反射生成Builder

主要是感觉jvm 一定要dump bytecode，有点太做作了，因为jvm是有Compiler() API的
明明把源码放 thymeleaf for if 一下，def()参数列表随便换行也能生成吧，这样就0依赖了

这种元编程如果AI也能好好完成，也是只要能用就行，闲下来的时间可以多设计些语法， BECL这些技术好像也不如cglib.Enhancer 的头尾hook流行了

老实说如果Kt有Zig那样的 comptime foreach 和TS的 type dict ，Builder就不是问题。当然这就是 lisp 系的 (unquote '(+ "x" 1)) 宏了

按道理来说JS里不是魔法的Proxy重载 o.xx 运算符，Java也是没什么的，但是Javaer们反射序列化的搞得太复杂了，或者说编译期API的贫瘠导致了「两门语言问题」

Zig的设计当时让我眼前一亮。虽然它不像D支持enum作为dict type ，但Zig的 println! 比 Rust 说的宏还好用

Kt实现默认重载的方法像Ruby一样，没有反射接口，不过把 fun 提升为class 就能知道默认值了（虽然这需要改变框架……

这点.NET的 dnSpy 也能做到，因为bc本质上就是 List<元组enum> 的bytes形式，编辑它最本质的做法就是 mmap() 文件到内存，然后绑定数组增长，0拷贝

不过无论语言，目前都没有能把read-write 统一起来的fmt IO lib ，JDK的R/Wer 流模式都是一式两份的
直接用msgpack管理加载保存二进制，倒是能避免冗余

但，它们都不是二进制格式的绑定框架。其实绑定bytes列表和DOM树所用的模式还是一样的，这点 010 Editor 这个闭源十六进制编辑器，反而清醒得多

Radare2 也是支持编辑javabc格式，所以lib的质量不是看语言，还是要看人、看思想
这么评价也是有点道理的。函数式data构造API ，都是helloworld 很美观很易懂，但对接实际就拉垮了

比如 import struct 的 pack("I", 0xff) 读取导出(u32,) 吧，你parse一个wav 数组的shape很易懂，但仅仅是拼接下乃至改个序列号就要从0写入整个文件流

不就是因为序列化struct的模型本质上和C的 unsized 数组一样，都忽略了重要的文件结构信息吗？
不就是不想独立出 malloc() 对象，想只复制参数到新bytes() ，结果只要修改个变量，代码可读性就炸了，工程难度飙到需要Protobuf 这些DSL玩意
其实只要让read/write 都作用到同一颗对象树，绑定一下，就不需要拿局部变量写什么RW流了

React就是这样被后来者取代的

kristoff.it

What is Zig's Comptime?

Let's take a quick look at what compile-time execution looks like in Zig.

21 viewsedited 13:02

duangsues.is_a? SaltedFish

#java duangsuse, [2024/2/23 01:21]
请使用 kotlin-reflect 和 new Compiler() 来为

data class MPair(var A: Int, var B: Int)

实现


loads<UPair> (mapOf("A" to 1, "B" to 1))

代码的部分可用StringBuilder生成

class Pickle {
  UPair load(UPair o, Map<Str,Any> m) {  for(kv : field) o.$k=m.get($k); }
}

... https://gist.github.com/duangsuse/d022c7ad037bb7fed446f72ec9b38ef7

duangsuse, [2024/2/23 01:23]
我用jshell API 实现了一个ini序列化
大概比直接靠javac 简单点吧，理论上eval的玩意也可以缓存到编译期

duangsuse, [2024/2/23 01:28]
我觉得我的目的已经很清楚了，写在最顶上

如果看不懂就说明不用看，反之测试过
如果不是gpt不会，我很乐意只写开头那1行

duangsuse, [2024/2/23 01:30]
JShell API 虽然比从Compiler() 加载短的多，但 js.eval() 那个默认返回String我不喜欢……
或许是为了兼容RPC吧，但LocalExecutor 应该就不需要序列化啊

感觉用jsh模拟eval 比ByteBuddy规范得多

duangsuse, [2024/2/23 01:34]
所以说py真的太解压了.. setattr() 就算动静态隔离，typehint还能做格式验证
js稍微乱点

java 连个规范的元编程方法都没有，一群魔法师
我是觉得一个老古董语言就不要和jspy 比面向event和类型反射

duangsuse, [2024/2/23 01:42]
不会啊，或许Lombok有

Factory类似Provider的简化版，在需要用subtypes 实现接口时可以用来简化创建

duangsuse, [2024/2/23 01:47]
写java,C++ 这些的时候有种错觉
public 是🔘列表符号
分号和各种不执行的标注也完全喧宾夺主了

duangsuse, [2024/2/23 01:49]
Compiler 和 JShell API 就是tools.jar里的，做不到比 CLI更强的功能，就是调用快点

JS("") 和runtime其实是完全隔离的，它的classpath 相当于是编译期的，你可以把生成的代码按行号缓存下来，不需要defineClass

duangsuse, [2024/2/23 01:51]
没错，第一次在runtime 做static foreach 留缓存，第二次可以直接走预处理器
这样也可以使用不常规的常量传播的结果，但主要是实现setattr()

duangsuse, [2024/2/23 01:53]
准确的说是在运行时，把eval()的东西缓存下来，那就叫编译嘛
JIT

Gist

dumps(Pair::class) (Pair(0,0), mutableMapOf("first" to 3))

dumps(Pair::class) (Pair(0,0), mutableMapOf("first" to 3)) - reflect_jsh.kt

33 views04:50

duangsues.is_a? SaltedFish

#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

螺莉莉的黑板报

跟我说函数参数太多，但我不太知道该怎么修……

17 views15:07

duangsues.is_a? SaltedFish

Forwarded from dnaugsuz

https://t.iss.one/dsuse/19184 这个内存对象范式叫行列算数(Rowcol typis)，认为类型的本质是电子表格里 column set 间的混合， fn? 标记的表格可自由扩充新的列。

只要函数要求的列的Set能被变数或常数满足，调用就合法
赋值、 if for 只是普通调用，但含编译期计算
( - plus(An:Int, k:Int)Int 则是方法)

自带对序列化器（类型单实例的接口）的支持，例如 typeof<Column2<Int,Str>>(JSON).loads()

好吧，有了一些小修改，主要是modifiers上的自动化
但大体上是把新class解释为对 Object这种的扩展，类似于 Haskell data C2=(A,B) 但是能够被外部扩展

duangsuse::Echo

#design #java 🥰 我的编程范式，目前由2类的重载重写构成

# 行列式多态 tabular polymorphism
class,dict,struct 等类型的本质是“电子表格”，而方法只是有特殊前缀的全局函数

因此，类型就是行和列(=定长字典和键)

?? Animal
- name Str //<> 列方向共有的，叫接口
Cat(name)
Dog(name, owner:Str) //^v 行方向新增的，叫构造器

其形式为 C=A+B :

?? C A
- b1…

15 views09:09

About

Blog

Apps

Platform