我总算不怕面向对象设计了, JavaEE 果然是大佬的平台, 什么 Representation, Resource links(rel/href/type, LinkableRepresentation), Adapter, 方法限定子类, Utils, 函数指针式子类实现已经是小 case 了
都在玩 CDI, Singleton Bean, Stateless Bean, SessionScoped/RequestScoped/Current, @Startup Bean, Interceptor, Stereotype, CDI Observer, NDI, DevOps, ShrinkWrap 部署 Archive 文件系统 DSL, 灰盒测试, XML 配置, Graph databases, 数据网格, JPA/JTA, BeanManager 了

到处隐式对象依赖 @Observes @interface @XXXScoped @Produces @Starup @PostConstruct @Resource 到处组件化、元编程、事务性、测试、abstract class 和 type parameters 看起来才像是 JavaEE 啊

亏它还说是『接地气』的指南，果然只是指南而已，这根本不是 Java 入门级别开发者能 handle 的复杂度啊！

就是那个 SMTPMailService （还是封装了 JavaEE 本身的 javax.mail API）恐怕初学者不写个一两天也是弄不出来的（涉及上下文依赖注入、JNDI 服务查找、javax.mail.* API、JMX Queue、MessageDriven Bean、XML、java.util.concurrent.CyclicBarrier 同步工具类、Subetha SMTP Server、测试部署过程、...）

然鹅，对很多人来说，他们对『“服务端”发送一封邮件』的直觉是：

abstract fun sendMail(toAddr: String, subject: String, body: String)

或者

abstract fun sendMail(toAddr: String, subject: String, body: String, mime: MimeType)

或者

abstract fun sendMail(toAddr: String, subject: String, body: String, mime: MimeType): Future<MailSendResult>

...

可是你却要教他们用 java.io.Serializable 去用 Builder pattern 去生成什么“可变”“不可变” “线程安全传输” 的 MailMessage 对象

@Inject MailService mailer;

//...
MailMessage smg = new MailMessage.Builder()
  .from("duangsuse@example.org")
  .addTo("cxk@example.org")
  .subject("Re: 🏀 挑战")
  .body("😧").type(MimeType.TEXT_PLAIN)
  .build();

mailer.queueForDelivery(smg);

而且后面还有一大堆被模块化松耦合的逻辑... 寻找 javax.mail.Session 资源啊、拿到注入 smtpQueue 啊、拿到 Java JMX 的 ConnectionFactory 啊、发送到消息队列啊（之间又要用到数个 API，比如 ObjectMessage、Session、(Message)Producer，到了队列的 MessageDriven Bean 里又要 Check cast 两次确保运行时类型安全，而且这还需要一个 sendMail(final MailMessage) 的辅助，这个函数的逻辑还仅仅只是把 MailMessage 翻译成 MimeMessage 然后 Transport.send 而且它也是一个 Bean @EJB... 还有 MessageDriven Bean 还要填写个 annoatation 元数据、这个 annotation 里面还需要仨 annotation(acknowledgeMode, destination, destinationType) 才能工作（Java Connector Architect），这仨还是 Java 经典令人头疼的 property(Map<String,Object>) 模式）...

Java 面向对象本来是为了降低门槛，可是 JavaEE 却是在背道而驰，因为它要通过提升编程难度、记忆模式数量的方式使得软件更容易维护更新测试.... 这样看起来才像是“企业级”软件

#JavaEE #Java #web #backend #statement #dev

在我们完全无视软件需求的情况下，Java EE 看起来就像是无端制造复杂度[1]，从这一点上看起来，我觉得《Python 机器学习快速入门》这本书的作者对 OO 的观点是有点道理的。

（大意）

有人说“面向对象”最大的好处就是方便把人脑子搅乱。

Linux, Windows, UNIX, Mac OSX 的内核都是 C 语言、汇编写的，可唯独有一个操作系统不一样，就是 Nokia 的塞班系统，是用面向对象编程语言 C++ 写的内核，据说这个内核的代码量比 Windows XP 还大，连他们自己的程序员都维护不了，最后当然就死掉了。

简而言之，面向对象的代码风格：一个字『繁』、两个字『繁繁』、三个字『繁繁繁』

把 Python 视为非“面向对象”编程语言并非大逆不道，事实上，也有许多人认为 Python 是一种类似 LISP 的“函数”编程语言

笔者从事编程十余年

（敲黑板！）

，从未用过面向对象的编程模式写一行“class”（类对象）代码，依然可以应对各种编程工作

“面向对象”的鼻祖 C++11 标准，到 2015 年依然处于推广阶段，而且争议纷纷。

“面向对象”过于复杂，与“人生苦短，我用 Python”的优雅风格天生不合

可是我也这么想：虽然有时候我们希望 Quick hack，做我们想做的事情，写点小东西自娱自乐（有时候不一定非常辣鸡，也可能只是比较精巧而已）或者写点『复杂的堆砌』（就是规模大一点的小程序）出来，
但是，实际上世界是极其丰富多彩（̶e̶g̶.̶ ̶与̶你̶无̶瓜̶、̶蓝̶瘦̶香̶菇̶、̶鸡̶你̶太̶美̶、̶图̶样̶图̶森̶破̶）̶的，有自己 自娱自乐♂ 的需求也自然有 搞♂大新闻 的需求

Intermediate Representation : Literate Agda => 形式验证、依赖类型与动态类型 [博文]

程序员们常常对『动态类型和静态类型哪个更好』这一话题产生激烈的讨论。 这其实是一个完全没有意义的讨论，因为这首先是一个罗卜白菜的问题——两者都有能称得上是『优点』的地方；
其次不同的人对程序有不同的追求，有人想写出健壮可扩展的程序，有人只是想快速交付收钱； 再其次同一个人也有不同的需求，有时只是想批量处理一些文件，有时需要构建长期维护的大型项目。

同样，Continuous EnterpriseDevelopment in Java [GitHub] 这本书的作者也说：

If you are only interested in quick hacks, you will hate Java EE, applications servers andprobably this book alltogether.

Packaging, deployment, monitoring and management sounds like bloat and is bloat, if you are only focusing on development.

However the “DevOps” movement also considers operations and development as asingle unit. Who needs beautiful code which cannot be properly installed in a predefinedenvironment? DevOps is nothing groundbreaking; rather it’s a “back to the roots”movement.

是这样就证明“面向对象编程万恶复杂”是错误的观点？不，但是我觉得，对任何事物都不要盲目武断其性质，对任何领域的任何事情也都应该以这种原则判断

duangsuse 曾经在冰封哥 @ice1000 和 friends 当管理的某 Q群里发了诸如“我觉得 Haskell 的 HM 类型系统很垃圾，无端制造复杂性”[2]这种弱智级的言论（黑历史啊，我都是抖着手打出来的，后面半句是大致的意思）

为什么觉得奇怪、莫名其妙？很大的情况下可能是因为自己根本不理解，正如我开始写一点 Haskell 以后对我上面这种话的评论：

听不到音乐的人觉得跳舞的人都疯了！

参见 Dunning-Kruger 效应，为什么刚入门的小白居然有那个胆量去挑战他们所谓的“权威”？为什么一个普通院校的高中生居然敢以不到一页 A4 纸的篇幅证明几百年（敲黑板）来没人破解的哥巴赫猜想？因为他们真的已经弱到连自己的弱、别人的 dalao 都感受不到了。

所以有时候，看到『存在即合理』这句话，不要忘记它还有一个深层含义：

如果你一看到某件东西就觉得它很莫名其妙，很弱智，那就不要立刻去喷它，因为

存在即合理

。
如果你依然坚持自己的看法，为什么不思考一下，每天有无数人和你持一样的想法，为什么没有人做出点什么证明它真的没有道理？
是因为它后台很硬，还是看不到它合理性的你们 — 都太菜了？

—
[1]: 制造的复杂度大部分就是少量模板的代码，以及对某些逻辑做对象化抽象后过度的拆分，比如 @ApplicationScoped @Singleton @LocalBean @TransationAttribute(...) public class XXX {...} 这种，以及把消息队列的使用给拆成『连接器、会话、生产者』和『消息队列』两部分这种情况
我觉得这句话和“在我们完全无视 Haskell 是一门引用透明且惰性求值语言的情况下，Monadic IO 看起来就像是无端制造复杂度”听起来怎么就那么像🌚
[2]: 我当时真的不止是没有写过一行 Haskell，我是压根一行 Haskell 代码都没有看过。
HM 这个名词是我从王某人的博客上看到的

#blog #recommended http://www.yinwang.org/blog-cn/2019/01/30/machine-learning

弄了半天我才知道啥叫逻辑式(descriptive)编程... 虽然之前某学姐的语录给了我帮助（神经网络是有未知参数的程序！）

miniKaren 里：

(run*(x)
  (exists (x)
    (== (+ x 2) 5))) ; 偷了点懒，我直接用了示例程序

当然我不可能懒到只给示例程序

(∃x∈ℚ. x + 2 = 5) ⇒ x

其中：
⇒ 不是逻辑里蕴含的意思，而是『给定某些条件，推出某式子的值』的意思 (run*)
∃x∈ℚ. x + 2 = 5 是一个命题，也就是条件

但是我之前知道所谓的『测试驱动编程』（Test-Driven programming）
但是我之前只是知道 Prolog, Coq 是 “逻辑式编程语言” 而已，我不知道所谓“逻辑式”是要以“某种给定条件成立”为编程的方法，甚至把 Agda 当成了逻辑式（有点像了，但还不是）

当然，Agda 是一个 Proof Assistent，不过看起来，如果 Agda 也能像 Z3 一样全自动完成定理证明那也是“逻辑式”语言了

我还是继续写我的 Jawa you dont know

#recommended #tech #floating http://wiki.c2.com/?BankersRounding

_emscripten_asm_const_i
_emscripten_asm_const_ii

两条 WASM 支持 library function 实现的问题，导致使用

var ASM_CONSTS = [
(function () {
var err = new Error;
print('Stacktrace: \n');
print(err.stack)
})
, ...];

年度最佳 👍+1
只要是生成代码里有 code=0 的情况，就会 print 🌚

1/(0-1+Int32.Parse("1")); 这种表达式不会有问题
Math.Round(0.1, MidpointRounding.AwayFromZero); 就会有问题

然后你看看（M$ 服务器编译后在你的浏览器上 WASM 运行时运行的）
有问题的函数打上断点

JSON 解析两次请求执行的函数，可以拿到一个请求结果代码对象

（当然也可以直接 POST compile?hostOrigin=... 拿目标 IL ，可在 HTTP 请求处查询）
DLL IL 反汇编后是这样：

dotnet tool install -g dotnet-ildasm

.method public hidebysig static void Main() cil managed
ldc.r8 0.1
ldc.i4.1
call double [netstandard]System.Math::Round(double, [netstandard]System.MidpointRounding)
pop
ret

可是

var _mono_wasm_invoke_method = Module['_mono_wasm_invoke_method'] = (function () {
return Module['asm']['_mono_wasm_invoke_method'].apply(null, arguments)

});

然后我们就啥都不知道了...(这是 Instrinic 函数，而且很明显，它的定义压根就是递归的，运行时没人 trap 它根本它就会一直等着直到栈溢出)

https://github.com/WebAssembly/design/issues/769

emscripten_asm_const_[signature]

EM_ASM_INT

 (emscripten_asm_const_int)

这才知道这是某个 Round(AwayFromZero) 实现往啥地方放了 constant int？

https://github.com/mono/mono/blob/master/netcore/System.Private.CoreLib/shared/System/Math.cs#L802
https://github.com/mono/mono/blob/affb833a6d87ce00b6084fd81f1a9a6fd3abd8f0/netcore/System.Private.CoreLib/shared/System/MathF.cs

但是很麻烦啊，不过还好，我的 Firefox 最终成功启用了 WASM 调试，可以动态阅读 WASM 反汇编

(import "env" "_emscripten_asm_const_i" (func $import24 (param i32) (result i32)))

...
(func $func5951 (param $var0 i32) (param $var1 i32) (param $var2 i32) (param $var3 i32) (param $var4 i32)
...
if
i32.const 0
call $import24
drop

问题就在这里！它调用了有问题的 _emscripten_asm_const_i, 这个函数的行为只有在为 1 时才正常（EM_ASM 的正常功能 eval 代码）

这个函数本身是 『调用一个没有参数的函数指针』

运行时它被 ASM_CONSTS 实现, code 代表什么鬼

可是这个函数叫什么名字呢

机制地根据 Math.cs 的魔数找到了一点对应的逻辑

找到一个！

MathTest.cs#L179 对应 mono.wasm@C8E6B

Firefox （划重点）完全支持 WebAssembly 调试（除了不能随意跳转而已...）

我终于觉悟了！原来我看了半天常量，其实我在调试的部分根本不在 System.Math 类里！
它是一个已经准备好进行终止的程序！

(import "env" "_emscripten_asm_const_i" (func $import24 (param i32) (result i32)))
(import "env" "_abort" (func $import0))

get_local $var3
if
i32.const 0
call $import24
drop
get_local $var2
get_local $var2
call $func221
call $func713
drop
call $import0

弄了半天其实是说

if (arg4)
_ = _emscripten_asm_const_i(0)

_ = func713(func221(45966456), 45966456)
abort()
!!!
我的方向都错了！

$func762 是个递归函数，叠了好多层了

然后我换了一个策略，不搜索魔数了，搜索方法签名都打上断点

(param $var0 f64) (param $var1 f64) (result f64)

https://github.com/migueldeicaza/mono-wasm-mono/blob/8eb6ac3a88b9e6ca5127dce5a3d3c075bf1586a4/mcs/class/referencesource/mscorlib/system/math.cs#L86

(param $var0 f64) (param $var1 i32) 签名部分是

你们这样暴力尝试是不行的！批判一番，下次不要再白费功夫！ 🐸

三个小时打水漂的惨痛教训

#huawei #China #Low 质疑：你还要注册什么商标，自从某事件后你说了那么多，可华为这么多年了，所谓一直自己后面有支持，为什么连一个自己的 ISA 架构标准都没有？华为海思主要还是半导体和无线通讯公司，对所谓的（高端）芯片（微处理器）的研究还是不完全自主的，对真正完全断供如果只有能力啃老本也只能苟且一两年可能就会被市场甩掉？为什么你说什么“鸿蒙”操作系统，可是却不告诉用户有些诸如平台生态的问题你们会怎么解决？为什么你们的“方舟”开发平台介绍有误导开发者的嫌疑？为什么对 Android 图形架构的优化也被混在这个“编译器”里面了？为什么现在才开始研究编译器一类的东西？为什么『IO/计算密集分析』这种实现起来完全可能没有多少复杂性的优化算法都会被拿来当成大成果公布？为什么以上提到的“鸿蒙”“方舟”“优化”现在还没点面向工程界公开动态？

听说华为注册了“玄武”的商标。如果最终能注册下来就很有趣了。

因为我们也注册过，当时商标局的反馈是：这是宗教相关词汇，不允许注册。 ​​​​

——tombkeeper

#China 不过中国的确是不太缺人，我就知道现在肯定有十几个能干这类事情的大佬，可是不知道华为里有几个[^2]

平均质量技术水平不够怎么办？人口拿来凑！人口基数在那里啊，何况中国又不缺高等教育。

其中有一个大佬自己研究了一两年的 GCC（知名自由软件跨目标平台跨语言优化编译系统）写了一本，还为国产的 PAAG[^1] 并行阵列处理架构（西安邮电大学自主设计的，并且绝对可以自主设计）进行了 GCC 的移植[2]

其中有一个大佬（嵌入式 PLD 设计的，比方说开发门禁系统、数码相机都需要这类人才）在华为海思工作过，参与了跳频 OFDM[4]（正交频分多址）无线通讯系统（4G 世代）的设计
可是那个大佬不是专门做所谓“芯片”（微处理器）方面的人才，不过现在创建了明德扬教育可以去看看

—
[^1] PAAG: polymorphic array architecture for graphics and image processing. 见 [1]
[^2] 华为里也有一些（参考这篇论文[3]，卖五毛...），不过技术水平在那一群里也比较平凡

[1] 李涛,肖灵芝.面向图形和图像处理的轻核阵列机结构[J].西安邮电学院学报,2012,17(03):41-47.
[2] 张薇薇,王亚刚.基于PAAG系统的编译器移植技术设计与实现[J].计算机工程与设计,2015,36(03):664-668.
[3] 宋奇.运行速度大突破 华为《方舟编译器》详解[J].计算机与网络,2019,45(09):32.
2019年4月11日,华为春季发布会上,除了P30系列,另外一个词也在程序员届火了一把——"华为方舟编译器"。据介绍,华为《方舟编译器》可以让安卓性能突飞猛进。近日,华为王成录博士对《方舟编译器》的原理进行了讲解,表示华为从2009年就创建编译组,期间推出自研编译器HCC、编程语言CM等,一直到如今推出了《方舟编译器》。什么是编译器编译器是连接人类世界与机器世界之间的一座桥梁, ⋯

^我就不吐槽上面那个错字了，还有 HCC 听起来像 C 编译器吧[^3]，编译器依据使用的技术、实现的源语言抽象程度范式和版本，实现难度有区别并且也是分好坏的，一门不知什么范式、有啥语法结构特性的 CM 语言，一个不知道多高水平的 C 编译器能证明什么？现在中国学编译原理的学生，随手抓一个都能写 C 编译器出来，但是编程风格还行、会函数式编程、完全理解静态分析程序变换的精英又有多少？C 编译器是“PL/0”级别都可能弄的，只会这一个不能说是能上实际工业的工程师，更不配当华为“编译组”的技术标准，自己都吹是 10 年经验了，那怎么不弄个 Go 或者 Rust 出来？何况一个方舟吹上天，实际上背后 EMUI 做的视图渲染缓存优化还出力不少，然后对外宣称是编译器这种“高大上”玩意和 GPU Turbo 都有的大功劳，听起来这像是中国第一电子通讯企业的作风？
[4] 曾菊玲,金力军.OFDM跳频通信系统设计[J].移动通信,2004(S2):155-158.
[^3] 但是 GCC 是 GNU Compiler Collection，然后 HCC 这个关键词在知网 cnki.net 上找不到任何发表的论文，这能拿来吹，真的很服气，就是“内部”也应该发点文章出来吧？

说起来看这些引文西安邮电大学和中国科学技术大学真的是人才辈出

#DB 同意。如果王垠真的是那么说的，那么我觉得他错了，他的理解太偏向结构化编程范式了，无视了数据库的确只是为应用提供数据持久化、查询等操作的服务，不是什么结构体(C Struct)、数据项目实例和一大堆函数接口，那就把数据库当成 GC 堆了。

“就是C的struct， 就是指针, 为什么不能RPC” 这句话... 不是很容易理解，我的理解是：为什么关系型数据库的『记录』上的操作不能直接被拿来当成远端过程调用去实现而非得 SQL，那显然就混淆了操作界面（接口）和实现，在面向侧面编程（AOP）甚至模块化里这是大忌，管你的理论学的再好，也永远有你没有学到的理论。

数据库系统也是信息技术应用的重要组成部分，虽然学 PLT （程序设计语言理论）的人一般看什么都会开明一些，但有时候还真是会有些许误解。

王垠开篇便开始详尽叙述数据结构和数据库的相同之处，如何“一个表本质上是一个数组”等等。

... 这不用我说肯定是不对的吧？关系表的本质并不是数组，而是抽象『元组』的集合

可以说，“只告诉它 What，而不是告诉它 How”，只是一个不切实际的妄想，而且它并不是 SQL 首创的想法

怎么可能呢？有的时候书上的东西也只是误会了而已，比如说所谓的 4GL（第四代计算机语言），其实这个概念根本不应该存在，
因为自存储程序型计算机开始，我们只是一直在提升抽象层次而已，从机器代码到它的助记符汇编（这里注意汇编不是一个特指，比如它不一定得是 x86 汇编），
到 Fortran, Basic, C, C++, 、上面的 Lua, Java, Python, Haskell、Agda, Coq, Prolog 什么的，甚至各种 DSL，甚至可以说 TensorFlow, PyTorch, Theano 都是编程语言，因为他们是描述计算的方式，而计算和描述方式可以有很多种，这怎么可能是空想呢？它当然不是 SQL 首创，因为 1920 年组合子逻辑（被证明和 Lambda 演算等价）就已经是一个例子了。这是 PLT 领域一直在变为现实的事情。
回答者对这个的观点我举双手赞成。

Prolog （miniKanren）的性能问题在 SQL 里面得到了部分的缓解，这是因为 SQL 对于基本的数据结构进行了“索引”

作者只回答了后半句，我对逻辑那边的东西也不是多熟悉，毕竟我工程得先过了再说。
然后这个索引我也不知道是怎么回事... 大概就是 SQL PRIMRY KEY 吧，考虑一下 hash table，我们可以通过先利用 int hashcode 的方式进行第一次剪枝排除，有冲突才需要 O(n) 再线性或者二分（如果冲突表是 Ordered, 有序的）查找

然而 SQL 的表达力也受到比 Prolog 更大的限制。很多 Prolog 可以表达的问题，SQL 没法表示。所以后来你就发现，SQL 其实只能用于非常简单的，适合会计等人员使用的查询操作。一旦遇到程序员需要的，稍微复杂一点的数据结构，它就会引起诸多的性能问题。

那 Agda 可以表达的类型问题

data forall {i l} {l : Nat} (a : Type i) Vec a l : Type i where
  nil : Vec a

0
_cat_ : a -> Vec a l' -> Vec a (suc l'')

啊写的好难看，而且我这里没有 Agda，那就照抄原文算了

data Vec {i} (A : Type i): Nat -> Type i where
  [] : Vec A 0
  _cat_ : forall {n} -> A -> Vec A n -> Vec A (S n)

那 Haskell 的 fold operator 和一些应用

foldr :: (a -> b -> b) -> b -> (a -> b)
foldr f v [] = v
foldr f v (x:xs) = f x (foldr f v xs)

递归的基线条件是 arg2 为 nil []；每层递归等待直到基线条件，回溯时第二个分支的最后一层先被 (f x v) :: b 调用，之前的结果被归纳直到彻底完成。

应用比如

product xs = foldr (*) 1 xs
sum = (foldr (+) 0) :: [Int] -> Int
filter p xs = foldr (\x rec -> if p x then x:xs else xs) [] xs


dropWhile p [] = []
dropWhile p (x:xs) = if p x then dropWhile p xs else x:xs

dropWhile' p xs = let (res, _) = foldr (\x (rec, sav) -> (if p x then rec else x:sav, x:sav)) ([], []) xs in res

这个就不那么 trivial 一点，然后我自己也想了很久，从这里扒的。

那就简单说，(\x -> lessThan 2 x) 这个

dropWhile' (<2) [9,0,1,2,3,4]

实际上递归
4 -> ([4], [4])
3 -> ([3, 4], [3, 4]) 👆 (cons sav, cons)
2 -> ([2, 3, 4], [2, 3, 4]) 👆 (cons sav, cons)
1 -> ([2, 3, 4], [1, 2, 3, 4]) 👆 (id, cons)
0 -> ([2, 3, 4], [0, 1, 2, 3, 4]) 👆 (id, cons)
9 -> ([9, 0, 1, 2, 3, 4], [0, 1, 2, 3, 4]) 👆 (cons sav, cons)
... -> （依此类推）

是不是我 SQL 不能表达就是我贫瘠 🌚???

更要命的是，这种性能问题的来源是根本性的，不可解决的，而不只是因为某些数据库的 SQL 编译器不够“智能”。很多人不理解这一点，总是辩论说“我们为何需要 Java 而不是写汇编，也就是我们为何需要 SQL。”然而，把 Java 编译成高效的汇编，和把 SQL 编译成高效的汇编，是两种本质上不同的问题。前者可以比较容易的解决，而后者是不可能的（除了非常个别的情况）。

首先：SQL 不一定需要编译器，它只需要实现查询操作并且给出结果就可以了。

“我们为何需要 Java 而不是写汇编，也就是我们为何需要 SQL。”

然而这个言论明显就是正常的，因为它把 SQL 当成了好用的工具，而 SQL 本身作为工具就很好用。
当然 SQL 也不一定得编译成汇编，其次，这里用“机器代码”更为合适吧，再其次，『为了自己能开心地去游乐园玩一趟而费重金弄一架私人飞机』这种事也不太实际吧，为什么我非得为实现查询语义来刻意去编译 SQL 本身？即使 SQL 可以根据数据库管理系统的信息被翻译成等价的查询程序？

我只举一个例子来说明这个问题。如果你需要迅速地在地图上找到一个点附近的城市，SQL 无法自动在平面点集上建造像 KD-tree 那样的数据结构。这是很显然的，因为 SQL 根本就不知道你的数据所表示的是平面上的点集，也不理解平面几何的公理和定理。跟 B-tree 类似，知道什么时候需要这种特殊的索引结构，需要非常多的潜在数学知识（比如高等平面几何），所以你肯定需要手动的建立这种数据结构

这是当然的啊，你不告诉 GHC dropWhile 的定义，只给类型人家自然也没办法弄出个你要的实现出来，数据可能有很多种，人家怎么能通过有限的数据和计算能力猜测你想要什么。

type Point2D = (Float, Float)

那即便不使用 kD-Tree 算法也是可以简单判断 filter 一下 floating point range 就可以得到 Rect 范围内的城市了... 但是要再优化为什么不写 C 扩展？这是它的错吗？

你发现了吗，你其实已经失去了所谓的“描述性”语言带来的好处

没有啊，而且你说的(描述性语言⇔逻辑式语言)
从某种意义上 SQL 还真的可以算是“逻辑式”，不过是 1 级的逻辑式（它不能组合操作成非线性
而且很多人并不认为它是逻辑式语言，只是觉得它是 "4GL" 而已