error: type mismatch: inferred type is Dijkstra.Node<String> but DijN<T> /* = Dijkstra.Node<T> */ was expected

🌚👍 请问 Kotlin 大大：这个 T 是什么玩意；真是连预处理模板都不如

typealias RouteSelectB<T> = MutableMap<DijN<T>, WNode<T> > // Node : Edge-Node
open class Dijkstra<T: Any>
  fun backtrace(rs: RouteSelectB<T>) = fun(end: DijN<T>, start: DijN<T>): List<DijN<T>>

我用的有错吗？为啥 T 就成了 T？难道真的是直接强行标识符名字填进去不加解析？我还以为是不能递归展开重写了一遍也没用 infer 失败一堆不好看

🤔 Typealias ❌ file-level only & no type variable resolution
🤔 Type argument + (* -> *) Kinds (Type argument for type variables) ❌ not supported, <GraphB : Map<DijN<T>, Set< WNode<T> >>> not compatible with Map<DijN<T>, Set< WNode<T> >>
🤔 (inner)Subclass ❌ Cannot inherit from Pair<A, B>: it's final
....
🤪 Expand typealiases by hand and remove the use of type extraction ✅

error: type inference failed. Expected type mismatch: inferred type is Dijkstra.WNode<String> but Dijkstra.WNode<T> was expected

瞬间服气
well done.

男人看了流泪，女人看了沉默... 😭 #Kotlin

没有能力继续写下去了，所谓型变，在实际写代码的时候，怎么能够去想该怎么办啊....

我最后写一个实际上可以用的吧 🤪
不用泛化太多了....

https://github.com/duangsuse-valid-projects/Share/commit/8c6f69f4b929ede7eedd61f2a5dd2921aa06bc66 111 commits!

🤔 duangsuse 为了保证比较好的手感，经常喜欢默写用于初始化项目的模板。

现在，duangsuse 想默写一些模板看看：

+ Docker 的 java Dockerfile (container image) 模板
+ Travis.ci 的 docker 部署模板
+ Maven POM 模板
+ HTML 模板
+ JavaEE JMS 的 Message Queue Activation
+ JavaEE JPA 的 ORM 关系： @OneToMany
+ Kotlin 里不使用大括号调用 git rev-list --count HEAD

1. Docker

FROM openjdk:alpine3.9-jdk8u171 AS builder
ADD . /app
WORKDIR /app
RUN chmod +x gradlew && ./gradlew test
RUN cp build/artifict/*.jar dist.jar

FROM openjdk:alpine3.9-jre8u171 AS runner
COPY --from=builder dist.jar .
ENTRYPOINT ["java","--jar", "dist.jar"]
—
openjdk:alpine3.9-jdk8u171 -> openjdk:8u171-jdk-alpine3.6 亦可 8u181, alpine3.8
build/artifict/*.jar -> build/libs/*.jar
AS runner 后缺少 WORKDIR /app
2. Travis.ci

langauge: minial
services:
- docker
before_install:
- VERSION=$(git rev-parse --verify HEAD | head -c7)
- DOCKER_IMGID = $DOCKER_REGION//$DOCKER_USER
- echo $DOCKER_PASS >dockerpass
install: docker login $DOCKER_REGION -u $DOCKER_USER --password-stdin <dockerpass
script: docker build . -t $DOCKER_IMGID
depoly:
--
origin: script
branch: master
script: docker push $DOCKER_IMGID
on: [tags: true]
—
minial -> minimal [typo]
services -> service

DOCKER_IMGID = "$DOCKER_REGION/$DOCKER_IMGNAME:$VERSION"
depoly:
  - provider: script
    script: docker push $DOCKER_IMGID
    on: [tags: true]

🤔 都忘了.... 但对比一下蠢 duangsuse 被自己的畸形惊艳到了,.,,,（迫真

#life 出去转了一圈，打算接下来说说三个问题
+ 打算给 TeaMeow Editor 用的 Keybinding 辅助加更多键位的支持
+ 再加个 Markdown render
+ 说说 Dijkstra.kt 对图的文本表示的 -> notation 如何变成 infix 的问题
+ 给 NBMAK 画个徽标吧...

#Machl #DIP https://github.com/zhiying8710/geetest_crack

发现了好东西。
= Geetest 是一种「验证不是机器人」(I'm not a robot, captcha)（验证码） 系统，基于「挑战」式检验
基于「生成歪七扭八的数据很容易，让机器恢复它们很难」的「事实？」设计

G2 是移动滑块的验证，用简单卷积识别应该可做
G3 第一部分是纯逻辑（不含「非精确的计算」）验证，直接可做
也可能是 G2 的滑块，通过率都是 99% （OpenCV） #CV
G4 是找七扭八扭又歪的汉字，需要 YOLO3 定位、CNN 识别汉字、CRNN 校验识别正确性
G5 也是一样，加个字典按照「语序」单词顺序就可以了

睡了.... 至于那个 Dij 的 infix 就是可递归可循环的问题，简单的说就是 LnL = LnL LnR... 你看这样注册的时候用的不就是 a -> b 的 b -> c 了么，循环就是 %2 == 0 偶数则换折叠用 lhs，此外就没啥了。 NBMAK 的打算灵魂一手，然后上我之前 SIMD BMP proc 的... 和 Throws 的头像一样操作一遍

#China #Huawei #Haha 🐸 蛤为！「真香！」

🤔 这周的主要问题是完成部分的 BinaryStreamIO，虽然只有一个晚上。

本来，BinaryStreamIO 设计的有 struct 和 nat 包，不得不暂时不写
struct 包依赖 org.duangsuse.condel，是一门独立的嵌入式编程语言，可能不能立刻写

此外，列表的部分如下

1. 谈谈区块链技术的应用方向、实际能力和「巴菲特午餐」
2. Dijkstra：WDAG 的文本表示方法

5元 ->
10元 ->
20元 ->
 整数币 ->
现金 ->
人民币 ->
   货币

(a) 有 N 个集合被称为前驱集合，存在前驱栈里
(b) 在扫描过程中，视前部（初始 MAX_VALUE）空格（缩进）的个数，如果它大于上行则前驱集合所有元素转移为当前行
如果等于则当前行后继元添加到前驱集合
如果小于，则开启新前驱集合
3. 新的强制类型转换 + 泛型类方式封装使用 typealias 的 Dijkstra 算法实现（object Solver + class Dijkstra<T>），同时提供 JavaScript 和 Python 的弱类型版本
4. 迫真猜测 Bellman-Ford — 两种支持负权重的方法：反向平均/重新传递
5. 关于 NBMAK (名字 Arkita_ADNKBot) 的基本交互 — /approve 引入方式和群聊专有的 flags, /lex
6. BinaryStreamIO
7. 🤔??? 这里有一个项目，可是 duangsuse 不想写出
8. 分享三篇文章《预支奖金》《火车盒饭难吃的背后》《知识晒成咸鱼干》
9. 分享一些书（如果没有）《时间深渊》《云养汉》《天贼》
10. #FP Agda：终于基本理解了 rev.rev = id 的归纳法
11. KotlinCN: inline fun <reified T> isz(vararg xs: Any) = xs.all { it is T }
以上是我靠着一个 counted memo 记忆了一个一个星期的东西，可能有遗漏，不过遗漏恰恰说明它不是最重要的东西 🤔

显而易见地（因为它们很费事），BinaryStreamIO 最好的特性 StructIO 是不能完成了，不过还是打算
1. 除了 StructIO 和 Nat numbers 的部分完成
2. 写 CondEL 的 Parser

#Kotlin #Haskell #CS #school #life

#school 本苏国庆放假，没啥计划，就是几个 lib 加上一个数据统计的，本苏写应用最辣鸡了（连 DOM 可调节大小位置的悬浮窗都要想半天，得出 i.width += (pos.x - i.x) / 2 都莫名兴奋）

应用上，我对状态机熟悉一点了，同时也稍微考虑了一下应用常做的动画应该是怎么样子用

// 告诉你们什么叫真正的『形式化设计』
fun trimMarks(input: CharSequence, beg: Char = '<', end: Char = '>'): String {
  val trimstr = StringBuilder()
  var isInTag = false
  for (char in input) {
    // (0) => initial
    // initial <- c = trimstr.append(c)
    // initial <- beg => inTag
    // inTag <- _ = {}
    // inTag <- end => initial
    if (!isInTag) {
     if (char == beg) { isInTag = true }
     else { trimstr.append(char) }
    } else {
     if (char == end) { isInTag = false }
     else {}
    }
  }
  return trimstr.toString()
} 

这里有一点可以注意：每次状态转移不会粘滞，也就是 initial <- beg => inTag 直接转移到了 inTag 状态，而不触发 initial <- c。我使用了一个 if (…) {} else {} 完成这个分支，保证了状态转移的 case 不会和其他 case 碰撞，当然也应该有更好的方法。
当然这个函数也可以写得更像状态机一样。

object TrimMarks {
  const val defaBeg = '<'
  const val defaEnd = '>'
  enum class State { INITIAL, IN_TAG }
  fun process(input: CharSequence, beg: Char = defaBeg, end: Char = defaEnd): String {
    val trimmed = StringBuilder()
    var state = State.INITIAL
    for (char in input) { when (state) {
      State.INITIAL -> if (char == beg) { state = State.IN_TAG } else { trimmed.append(char) }
      State.IN_TAG -> if (char == end) { state = State.INITIAL } else {  }
    }}
    return trimmed.toString()
  }
}

当然，这里 defa* 常量其实可以不写，因为这么抽提无必要
一般应用的话，如果用 Kotlin 的 Coroutine + await/async 自然是最好的，因为非常直观，不需要老设置 callback，只是为了维护一个链条
我是这么想的，当然是空想，可是……

fun showInputAnimated(): Unit {
  val line = CubicBezierLine(0.3, 0.2, 0.5)
  val fadeout = ObjectPropertyAnimation(btnStart, "alpha", line, Pair(1, 0), 2000 /* aka. (2 as kotlin.Int).sec */)
  fadeout.setOnAnimationEndListener { // boilerplates
    val fadein = ObjectPropertyAnimation(btnStart, "alpha", line, Pair(0, 1), 1000)
    fadein.animate()
  }
  fadeout.animate()
}

Kotlin 的 infix fun 和 tailrec fun 也比较有用啊，还有 inline val，data class : *…

说起来，这个人的水平啊，我感觉还真的是越来越难用『代码行数』这种不讲理的东西决定了，反而是最厉害的大佬会去写最傻瓜式的代码，不是因为他们不知道，真的是因为他们已经经历过了、看透了。
傻瓜式的代码真的是一种奇妙的东西啊，只有突破思维定式才能写出简单又优雅的代码，和原来的那种机械重复感觉完全不是一个档次的东西。

我曾经写的『倒序』（那时候我连字节序到底是什么都不知道）
我记得就这程序我当时至少写了 5 分钟，当然现在我优化了自己对 bound 模型的理解力，所以会快很多（不过写错了，Kotlin 也骗我，我以为 a..b 是 (a, b] 区间的意思……Kotlin 变成全开区间了）

def rev(hex); l = hex.length; "#{hex[0..l-(2*3 +1)]}#{hex[l-(2*3 +1)..l-(2*2 +1)]}#{hex[l-(2*2 +1)..l-(2*1 +1)]}#{hex[l-(2*1 +1)..l]}"; end

请问这 TMD 是哪门子代码啊？当时就是这样，规模小一点而已，我都不知道 16 位是啥子，只看 FFFF 这种东西，然后瞎 🐔 写… 类似这种代码，而且我用的还是常量（而不是 2*n+1）
当然我用 for 循环和 mod 取模也一样

def revmod(hexstr)
  reversed = []
  for x, i in hexstr.each_char.with_index
    reversed << x
    if i % 2 !=0; resv = reversed[i-1] # replacement: (i+1)%2 ==0
      reversed[i-1] = reversed[i]
      reversed[i] = resv
    end
  end
  return reversed.join
end

比如别人（也算是个好程序员）写的，可是还差了一点

// 别的程序员怎么写（大意）

int reverseByteOrd(int i) { return ( i&(0xFF << 8*0) )<< 8*3 | ( i&(0xFF << 8*1) )<< 8*2 | ( i&(0xFF << 8*2) )<< 8*1 | ( i&(0xFF << 8*3) )<< 8*0; }

为什么 0x7F_FF_FF_FF 是 Integer.MAX_VALUE 呢？
我们看这个 0x7F，就是 0b0111_FFFF，0b0 的第二个0（第一个是 0b 二进制前缀的『0』）
它这个 0 代表 8(2**3), 之后的依次是 4(2**2), 2(2**1), 1(2**0)，叠加上就可以了
第一位是符号位，每次计算中取两次反就可以得到正确结果，但是为 0 表示正数

reverseByteOrd(0x00_00_00_7F) == 0x7F_00_00_00

//true

这么做是很秀（不过有点坑，& 的优先级没有 << 高，如果括号写漏就炸了），可是还有更好并且更快的方法

后来我看函数式程序员写的 atoi，才觉悟出 i<<1<<1 = i<<2 的道理，而通过这种道理和 Kotlin 的 functional inline 我可以写出性能比一个一个去 bitwise & | 强百倍而且好看百倍的代码，最重要的是它可以做到 Java 7 程序员叹为观止的『极限』代码复用，真的是一行模板都没有

typealias Cnt = Int
const val wbyte = 8

inline fun <T> rotatePrimOrd(   
  crossinline shl: T.(Cnt) -> T, crossinline or: T.(T) -> T, // construct T
  crossinline shr: T.(Cnt) -> T, crossinline and: T.(T) -> T, // destruct T
  bitselect: T, bytew: Cnt): (T) -> T  = closure@{
  var stack = it
  var swapped = it // clone
  for (_t in 1..bytew) {
    val shifted = stack.and(bitselect)
    stack = stack.shr(wbyte) // |00 [FF]<<00 FF|
    swapped = swapped.shl(wbyte).or(shifted) 
  }
  return@closure swapped
} 

fun rotateInt32(i: Int) = rotatePrimOrd(Int::shl, Int::or, Int::shr, Int::and, 0xFF, 4)(i)

然后可以

 const val BYTE_1: Byte = (0x7F or -0x01)

rotateInt32(0x00_00_00_7F) == 0x7F_00_00_00 //true

你看这个数组逆序的，后来如果从输出要符合的『性质』property 来看，有时候突然觉得莫名其妙视野开阔了许多，虽然实现起来还是只知那几种而已

forall i in (0, length xs]. xs[i] = xs[lastIdx - i]
  where lastIdx = (length xs -1)

然后我们发现其实靠交换 (0, length xs `div_ceil` 2] 就可以实现这个目标了：

#include <bits/stdc++.h>

using namespace std;

template <typename T>
void reverse(T *ptr, size_t len) {
  size_t lastIdx = len -1;
  size_t end = (len / 2) +1;
  for (unsigned i = 0; i < end; ++i)
    { swap(ptr[i], ptr[lastIdx-i]); }
}

int main() { 
  char str[7]; const char strorig[] = "abcdefg";
  memcpy(str, strorig, sizeof(strorig));
  reverse(str, 7);
  cout << str << endl;
}

Haskell 里我也还记得两种方法
reverse' xs = foldr (:) [] xs -- 刚才发现我误解了这个思路… 还想 foldl (:) [] 的，可是 foldl 需要 (b -> a -> b)，等等好像的确是可以写，不过要 flip 一下

reverse'' = foldl (++) []
reverse''' = foldl (flip (:)) []

rev'' (x : xs) = (rev'' xs) ++ x
rev'' [] = []
rev''' = rev_rec''' []
  where
    rev_rec''' ac (x : xs) = rev_rec''' (x : ac) xs
    rev_rec''' fin [] = fin

几个 lib(BinaryStreamIO, 后来我改叫 BinaryStream 了，再后来我起了个昵称叫 Doku（日语的『読』）、Duava（Data/Utilities Abstraction for Java）、CondEL) 嘛也比较 excited，（对自己）算是革新…

但是在听老师发成绩的时候，我觉得有必要写个应用程序去做图表，比如用 Qt Charts（可以顺便熟悉下 C++）
可是毕竟我还是不熟悉 C++ 啊（这个应用程序名叫 DataMet）！我又想 (1) 再复习一下 Python 经典分析数据可视化了 Avg, Mid { Pie, Rect }, Scatter2D, Scatter1D (2) 我也可以用 JavaScript + DOM + echarts.js

最近设计点什么东西都莫名其妙想写 Parser 想设计新的 Expression Language 了，这次就是设计也想了一个、打算实现了一个（实现的那个就是迷你版 CondEL，用来从 Set<Tuple<*>> 里 filter 东西用来 plot 的，当然有些 plot 基于的 DataFrame 是 Tuple<Set<I>, Set...>）… 居然还要写 Type checker（而且要支持 currying 还比较头疼要用 vector，如果想支持 optional arguments 就会很 dirty 不可能，不过好处就是没有本地变量，直接用很重的 curried fun…），然后用 C++ 实现，虽然 GC 可以直接忽视掉因为 shared_ptr Refcount 能够解决，晕

不过不管怎么样我都还得先写点教程、观点之类的东西…

今天晚上会先说点闲话，如果说完还有时间就出图表、写 TrieTree…

c=b; b=a; a=c 是一个『swap』程序里常用的逻辑
为什么 不这么看呢（当然和原来的不一样啦） 🤔
c « b « a « c « ...
也就是递归模式（迫真
I = c « b « a « I
突然想到 Fibonacci 序列
a b c
1 1 2
1 2 3
……
b=1, c=1
loop { a=b, b=c; c=a+b; yield c }
a b c
- 1 1
1 1 2
1 2 3
……

有什么区别呢？其实第一个是 c = b; b = a, a = c, 根本不是什么递归，成环了（而 c 也就只能算是 附带给 b 的第二存储）
第二个是 b < a < f c < … 真正的可递归（显然 b,a 依赖上一个 c，c 依赖 b,a）

既然太抽象没啥用，其实 Kotlin 里用 sequence 也很容易写的…… 我不会

def fib():
b, c = 1, 1
while True:
a = b; b = c
c = a+b
yield c