没有顺序执行（难道我之前用的是假的haskell）

evalBin :: (Eval a) => (a -> a -> a) -> Ast -> Ast -> a

就像这种语法，理解不能

(x :: a) 是 val x: A 的意思
a -> b -> c是 (A) => ((B) => C) 的意思
我真是累了，懒得和那群中文都不会说的大佬继续学那些一大堆名词的概念
现在在学实际点的可复用编程以及编译原理

一年前你还可以找 @ice1000 抄作业，现在人家把自己四五年的中文老博客删了（

总之不要学这些大佬，还是继续做应用比较实际

a -> b -> c是 (A) => ((B) => C) 的意思
这种描述和haskell文档里的一模一样
原来是这样啊，我知道了

往编译原理—解析器上， (->) 是中缀(infix)操作(或言运算)符，它是“右结合(right associative)”的，所以并排 a->b->c 是 a->(b->c) 的意思
JS 里 1**3**2 == 1*9

https://lab.xecades.xyz/ 大佬写过一个“图形编程语言Piet”（指代码是位图）的随机代码生成器 😂

"heLLo" == "hello" 神奇自反性(自身相等性)...

嗯…… 没试过
{-# LANGUAGE RankNTypes #-} --"forall"
f x :: forall x. x -> x
f x = x
看起来好像没有这个问题吧
:: 只是定义了类型约束，那个 x 全叫 a 写 forall a. (a -> a) 也可以

是的，这个是算法大佬，同时也是前端会CSS/HTML
昨天还在想他的一个DEMO要实现的一些细节

Java 和 C++ 的主要区别： #Java #Learn #cplusplus

Java 有 GC 没指针和&reference，所以编程时不需要考虑存储分配位置在调用栈(stack)还是堆(heap)，也没有 delete 算符(且 Java 没有 operator 语法也没 template<>)
有不推荐的 Object.finalize() 方法覆盖，实现了 ~T() 析构器的功能但不推荐使用
Java 采用 类名 Capitalized , 其字段名/方法名 camelCased, 参数及局部变量名 snake_cased, 类型参数名全大写 T,U,K,V 这种命名风格(泛型不用模板实现，函数级的类型参数 <T/*extends T_Parent*/> void operate(T x); 这样写)
没有 #include , 只能 import package_name 的 .Item 或 .* ， main 函数类型签名是 static void main(String.../*String[]*/ args)
许多语言相关的包(package)在 java.lang ，算法及数据结构的在 java.util ，I/O 的在 java.io，可用 javap (-cp class_path1:2) 命令查询接口
没有 size_t/bool，只能 int/boolean
Java 的字符串原生支持 Unicode UTF-16 ，当然兼容 UTF-8 ，从标准输入(System.in)读可以用 util.Scanner 和 InputStreamReader.read()->int
Java 支持 java.lang.reflect ，可以动态获得类/成员的元数据及强行访问/调用，也可以通过 ClassLoader 寻找并加载类字节码(defineClass)，许多大型web/db框架都用了动态字节码生成(往往用到可存于语法树上的 annotation 即 @interface ，属于反射 API) 。
util 包有 Collection<E> 子类: List, Set ，有 LinkedList, ArrayList 和 HashSet ；也有 HashMap<K,V> 和线程安全的 Hashtable
集合类皆没有 C++ stl(即std) 式的 back() iterator 等迭代指针也没有 push_back (用 add/contains/remove/clear)；foreach 语法 for (T item : (java.lang.Iterable)items) 与 C++11 语法无二
新版本可 (List<Integer>)List.of(1,2,3) 即用，旧版本是 util.Arrays.asList(1,2,3)
java.lang.Object 是顶类型(所有类型的超类)，其 wait(), notify() 等方法已被 java.util.concurrent 的相应工具替换， Java 里判断非『原生类型(int,long)』的全等性用 (a==b) 而相等性用 a.equals(b) （这点易混）

语法上：
面向对象OOP 结构(构造器/字段和属性/方法)和语法与 C++ 类似但没有多继承和 Mixin(混入非public成员)
Java 的 public/private/protected (保护性或可访问性)修饰符是每个成员一份而非 public: 标签式，默认值没人学过，可能是其定义类的保护性
Java 没有 struct 和 union 但有不能指定起始号的 enum (见 java.lang.Enum 的 int ordinal)
可以用 Lombok Annotation Processor 编译器插件自动生成类字段的 getter/setter ，插件更支持 Java 12(的record特性) 才有的数据类
请用 class V{} class A/B extends V{} 再 if (v instanceof A) 替换不严谨的 union

Java 里 final class 不能被继承(extends)，此外支持 inner class 即可访问超类成员的 class ，它们不可以在外部直接引用，在 class {} 内定义类时用 static class 可以规避这一点。
Java 没有 T a(); 局部变量，构造器也没 T(T value): field1(value) {} 这种简写
Java 的继承是 extends ParentT 单继承，此外有仅支持 abstract(即virtual) 方法的 interface ，子类继承自(实现)接口要 class A implements Intrf {}
Java 支持 new T() {} 的匿名内部类(anonymous subclass)，它可以包住局部变量，但这个量不能被重赋值(effective final)。
覆写成员一般要加 @Override
Java 的 SEH(try-catch-finally) 没有 noexcept 但要抛出(非 extends RuntimeException 的)异常的函数必写 throws T_EXC1,T_EXC2，版本8 支持 try (File f=new File("a.txt")) 的这种语法(try-with-resource)
Java 的 break/continue 支持随机跳转至循环(头/末)位置： out:while(false) { break out; }
if/else/switch/case/default/return 与 C++ 没啥区别，除了 switch 支持 case String:

interface 可以理解为无构造器的 class，常被用于存储(如 static final String) 的常量，其上方法如果加 default 关键字也可以带 {} 函数体。
其实，static 成员本质上是一个与类 1:1 数量关系对应的对象实例上的成员，用 kotlinlang.org 你就会明白这一点
@FunctionalInterface , 又称 SAM(single abstract method) 标记的接口可以用 Intrf inst = () -> { return; }; 的函数式语法创建。
还有一大堆都很简单(或者涉及并发编程了)，可以慢慢学

面向对象语法和常用类需要花时间过一遍，比如常用集合，异常处理，文件存取，网络收发，线程和锁，加密解密，这些都过一遍之后就对 Java 有了一个比较全面的观感了。

对应的包及常见类是 (java.) util(List,Map),无,io(File,(Data) (Input/Output) Stream),net(URL),util.concurrent(.locks.ReentrantLock, .atomic.AtomicInteger),security(MessageDigest,KeyPair)
可以在 docs.oracle.com/javase/8/docs/api 在线查看（草
RegExp 用 java.util.regex.Pattern#matcher matches() 后也可以看 MatchResult.group(int) 的

a _a_ b

补充提取代码的 #Python #code ：

replacecode.py:

@regress("len(it)","+","a")
def headerSize(fp): pass
from sys import argv; fps = argv[1:]
  
with open(argv[0], "r") as f: headerSize(f.read(), argv[0])
for fp in argv[1:]:
  with open(fp, "r") as f: s = f.read(); code = s[headerSize(s)+1:]
  with open(fp, "w") as f: f.write(code)

其中 #Python #code

def regress(*code_parts):
  code = "".join(code_parts)
  def solve(d, x,y): #不懂算法就写死点二元仅(+)啦
    vL = eval(code_parts[0], None, d)
    for k in d: d[k] = (y - vL)
  def excVar(ex): s = ex.args[0]; return s[len("name "):s.rfind("'")]
  def wrap(whatever): #我也拽下洋文（迫真
    syms = {} #已回归表
    def call(x, y=None):
      syms["it"] = x
      if y != None:
        try: eval(code) if len(syms)==0 else None
        except NameError as ex: syms[excVar(ex)] = None
        solve(syms, x, y)
      return eval(code, None, syms)
    return call
  return wrap

这个做完发现第一项需要 fpath 就没用了 QAQ
def forFstAndTails(op0, op, xs):
xz = iter(xs)
try:
op0(next(xz))
while True: op(next(xz))
except StopIteration: pass