啊，我的智商果然变高了，现在接口的名字都记下来了，不需要想太多直觉也有了

#Java ... 其实这是属于差点资料就能找到的，我本来想讲一些有趣的东西，自己太拖、时间太离散...

#life #school #dev #task 今天的最后，发一下任务列表

很可惜我什么都没有讲、什么也都没有做。

+ （无线电通讯，电信）FDMA, TDMA, CDMA, GPRS, EDGE, LTE... 等知识
+ Engima encoding 写一个加密程序出来
+ ML，Python 的 Pandas 和 Mathplotlib 的使用
+ Jsonist Java JSON 解析和序列化库
+ 不同风格的 Lexer control flow: 怎么写程序更好看：if/switch
+ Para Kotlin Parser Combinator（后置了）
+ DFS 1004.C 修改建议
+ RandomPicture 从头至尾彻底重写
+ BluetoothUtils 默写: 我记忆力是真的变好了... 啊
+ e2immutable 默写: NDKBuild 不好记又怎么样，照样记得住 LOCAL_SRC_FILES 什么的
+ #FP Functional DFS 重写: 比 16 年的冰封还菜... 有时差啊
+ CheerIO Spider: 重构，因为已经记住了主要的库函数方法，而且它真的比较长...
+ #PL Dynamic scoping vs. lexical scoping
+ CMake 如何编写 基于 xxx-config 的 findPackage 函数: 重写 FindLibClang.cmake
+ Hannoi 塔问题、数学和逻辑

点名批评 duangsuse 瞧不起数学和数学老师，结果自己被大脸，其实你又有几时真正理解过递归？又有几时分清了啥是递归啥是计算机科学里的递归子程序？

+ kotlin.Intrinsics 和 -assumenosideeffects, 我之前居然不知道它到底是什么？

+ 树状数组离散化（下个星期的）

数状数组，就是有 void add(path, int); int sum(path); 的数组，然后时间复杂度空间复杂度我不知道
然后离散化和逆序对这可不是简单的题目啊... 以我的辣鸡数学水平
然后我现在连 Gauss-Jordan 算法都不会，怎么入机器学习线性规划啊，怎么入计算机图形学啊，怎么入系统编程啊....

+ C++ 的 template 实现 Nullable<typename T>，注意这个是工程下乡，我不应该被喷太菜（如果只是因为我讲它的话）

+ 编写 Java 的解析组合子框架；当然也是一个解释器、语言工具框架
+ 编写 Java 的 TypeBlackmagic Annotation Processor

— 这个库给 Java (8, 因为至少得有 Type annotation) 提供了:
类上的 @sealed 和 @inner 断言
类泛型参数和方法泛型参数上的 @reifed 内联（实际 Class<T> 提供给某个 instance field 或者 local variable）
@kind 传递内联将 raw type 作为 type constructor 传递（或许有点天真？）

是因为必须得写这种代码：

abstract class Functor<T, A, B> {
abstract Function<? super T<A>, ? extends T<B>> fmap(Function<? super A, ? extends B> morphism);
}

但这代码真的有效吗？T 明明是泛型参数，可以正常解析吗？如果是 Kotlin 的话，可以加限制，不知道 Java 可不可以有

@in 和 @out 声明处型变
@override 小写版本 Override

@readonly @property 自动生成访问器

@properType 自动实际类型 Class<T> 注入

因为我想有一个 abstract class DynamicCheckedSealed<@reified T> {

  abstract Class<T> reifiedT;
  @properType abstract static Class<T> REAL_TYPE;
  static { checkSealedInstance(REAL_TYPE, klass); }
}

之前还有 C, Crystal Fibers 的并发 du 程序和 kotlin 的 Numeric 类自动运行时类型提升的

明天要讲的东西，现在已经写在我的草稿本上了，主要是 Java 的泛型和 Type wildcard

晚安喽.... 只要可能，明天我会先讲完某些芝士点.... 然后写一个好用的 Java 8 解析组合子，虽然可能不能好好的函数式编程

虽然我知道不仅不可能写任何一个字的解析组合子，连讲是否讲得完都会成为问题

准备开始写了啊，准备彻底了解 Java 的同学可以期待一下

#web https://vertx.io/docs/vertx-service-proxy/java/

给人的感觉就是 Vertx 可以利用 Event bus 集成外部服务，然后 Proxy 可以消除 boilerplate code

// 下面是 C++ alike 语法

const String vActionHandlerArg0 = "action";
fun DeliverOptions.addActionHandler(name: String) = this.addHandler(vActionHandlerArg0, name)

const String vDbServiceID = "database-service";
auto sendToDb = vertx.eventBus()::send.curried(vDbServiceID);

Json message();

message["collection"] = "users";
message["document"] = jsonObject("name".to("tim"));

DeliverOptions deliveryopts = new DeliverOptions()
.addActionHandler("save");

sendToDb(message, deliveryopts, [](result) {
if (!result.succeed()) { ...; return; }
// else
});

这里 deliverOptions 的 actionHandler 假设了某个 receiver（面向对象术语，但这里是说消息队列的监听者）有这个 handler
并且要求这些 Handler 去 handler 这个 message；这里 save Handler 会存储信息到数据库

你也可以理解为一个动态派发的 Java 方法；当然 Ruby 元编程里的 method_missing 和 define_method 更好理解一些

Json newlover = jsonObject("name" to "Jack", "lover" to "Rose");

DeliveryOptions methodSave = new DeliveryOptions().addActionHandler("save");
vertx.eventBus()::send.curried

—

("databaseService") . (methodSave) (jsonMap("collection" to "lovers", "document" to newlover))   

databaseService . save (collection = "lovers", document = newlover);

不过区别在于它是通过 Vertx 的 Message 队列派发的；不是通过反射也不是能直接 invokevirtual 的对象

有的时候就想；能不能把这种 call service (using vertx messageque) 的东西做成『抽象类』的形式（面向侧面编程；AOP）
因为不断定义操作；感觉很垃圾

我们想想，如果不使用 Annotation Processor 这种搞基一点的技巧（实际上已经不算是技巧了，因为很多人连 Visitor Pattern 都懒得写...）
Reflect API + Annotated Element 会怎么样呢？

abstract class VertxServiceInterface {
  abstract VertxServiceInterface(EventBus bus, String address);
}

@ServiceInterface
abstract class DatabaseService extends VertxServiceInterface {
...
}

然后数据库服务会有一个 action: save

public AsyncResult save(String collection, Json document);

想想是『弄一个 Function<AsyncResult> 参数好呢，还是直接返回 AsyncResult 好呢』
我觉得还是直接返回好，怎么看和 GC 性能什么的也没有关系；何况这种优化都做得你怎么不去用 C++

然后实际使用的时候就直接

static DatabaseService DB = new DatabaseService(vertx.eventBus(), "postgres-database-service");
...
val saveToUsers = DB::save.curried("users")
DB.saveToUsers(jsonOf("name" to "duangsuse", "feat" to "funny"));

函数式风格写多了抽提控制不住了

— 那实际上呢？

Vertx-service-proxy 是这么弄的（我给翻译成 Kotlin 了，要不然很长感觉很垃圾）

interface SomeDatabaseServiceFactory {

fun create(Vertx vertx): SomeDatabaseService = SomeDatabaseServiceImpl(vertx)
fun createProxy(Vertx vertx, String address): SomeDatabaseService = SomeDatabaseServiceVertxEBProxy(vertx, address)


}

@ProxyGen interface SomeDatabaseService {
// 俩创建自己（constructor）和 Proxy 的接口

companion object: SomeDatabaseServiceFactory

fun save(String collection, JsonObject document, Handler<AsyncResult<Void>> resultHandler)
}

这让我想起了 Perl，<> m!! ~= //....

自以为理解了递归，可是发现其实我连计算机科学里的子程序递归都没有彻底分析过，我无法允许有隐式的知识存在。
前几天才被数学老师打了脸，我之前幼稚地以为『数学老师讲的都不好，所以他们不如我擅长『当老师』』
谁知人家弄了个 PPT 动画图示出来... 我发现和我的直觉正好相反（我的思路正确，但是操作，递归顺序弄反了）

... 不得不说，Hannoi 塔问题我之前自己尝试解过，很可惜，到昨天我才结束了对递归不理解的尴尬情况..

#web #dev #Kotlin 插播一条消息

内存区域限制技能 get ✅

#Algorithrm https://sourceforge.net/p/jedit/svn/HEAD/tree/jEdit/trunk/org/gjt/sp/jedit/textarea/TextArea.java

https://ice1000.org/2018/04/27/CodeEditor/ #blog #fix

看完查找资料后，修复了我对一个单词的误解：

efficient 不是『足够』的意思，是『有效率』的意思
effective 是有效的意思

Trumeet/FlarumSDK 1+ 理解

快速阅览：

这是一个使用 Gson / OkHttp 的 Flarum JsonAPI 客户端程序

+ 它有一些客户端实例状态

Flarum API base URL

Task Executor, OkHttp Client, Gson 实例
身份验证 Token: interface TokenGetter { String getToken(); }


+ RequestBuilder 按照 base url, method, body, authentation, filters, page(*20 item/perpage) 和 json converter 生成 OkHttp 的 Request
+ internal.parser.jsonapi.Parser 将 Raw JSON Response 作为 JsonAPI 返回对象解析，返回 APIJSONObject 将被各种对象解析器 internal.parser.ObjectParser.JsonConverter<T> 读取到 Java 对象
+ Result<T> 给 T 结果附加了 OkHttp 的 raw response 和 raw api json object 以及 ID（目前为 0）
+ internal.parser.ObjectParser 定义了将 JSON 对象解析为 Java 对象的接口和辅助函数
+ internal.parser.converter. 定义了一些辅助这种转换器编写的基类
+ internal.parser.ContentParser 是空的 fallback JsonDeserializer<Content> (也是空的) 实现，如果不能作为 Api Json 解析，结果就是无意义的值
+ internal.parser.OkHttpUtils 是放错地方的 OkHttp Client API Call 请求封装，它支持同步使用 execute(request, apiManager, converters) 和异步使用 enqueue(request, apiManager, converters)

逻辑就是给原处理程序加上先判断 HTTP Status 成功、JSONAPIObject 解析成功且访问不包含错误、再转换为目标 Result<T> 的过程

+ internal.platform.Platform 是从 Square Inc 复制修改的逻辑，实际上就是弄一个 Executor... 本来目的是给 OkHttp 异步请求分配合适的执行者，可实际上它只能找到有 android.os.Build 的 Android 平台和创建利用 android.os.Looper 和 android.os.Handler Executor 的(post 到 mainloop 去执行)，否则默认就是新建 Thread 去执行，而且处理的地方也不在这里，在它的 Caller 那里...
这个类要是弄的好一点要使用 enum with constructor calls、java.util.Function、java.util.concurrent.Executors、java.util.concurrent.ForkJoinPool