Forwarded from dnaugsuz
要是我的 GalScript 反向模式匹配真的可以写出来，就可以这么写了
不过这是不可能的，因为我还没打算支持方法调用参数的反向模式匹配...
match [*'®'.repeat(rc), *'©'.repeat(cc)] = "®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®©©©©©©©©©©©©©©©©©©©©©©©©"
println("(R): ", rc) println("(C):", cc) 不过这是不可能的，因为我还没打算支持方法调用参数的反向模式匹配...
Forwarded from dnaugsuz
目前只能反向模式匹配 self，不能反向参数，所以只能
而且也没有重复 repeat pattern，只有 ES6 的 expand operator
match [*rc.timesStr('®'), *cc.timesStr('©')] = "®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®©©©©©©©©©©©©©©©©©©©©©©©©" 而且也没有重复 repeat pattern，只有 ES6 的 expand operator
Forwarded from dnaugsuz
就像这样：
//! StrictLanguage
def fizzBuzz(rng: Range = 1...100)
for n in rng match n
1: _ |*| 3 + 0 => cout << "Fizz " << n
2: _ |*| 5 + 0 => cout << "Buzz " << n
1: & 2: => print "FizzBuzz " << n
Forwarded from dnaugsuz
我这周打算给 GeekApk 未来的脚本系统设计的一门多范式编程语言，支持编译到 Java/ES5/ES6 和利用 GalVM 虚拟机解释
Forwarded from dnaugsuz
而且这货还支持 implicit、cross inlined definition（不过 implicit 参数只能查找调用的一层作用域和
语言总体主要是面向对象和函数式（此外也有点过程式和描述式的感觉），支持
不太支持参数化类型（没有用户自定义的），但有函数类型、Map 类型什么的
object instance ）语言总体主要是面向对象和函数式（此外也有点过程式和描述式的感觉），支持
rewrite 尾递归重写、渐进类型支持 type patterns（多态），此外它还支持反向模式匹配（match n+1 = 2 这种）不太支持参数化类型（没有用户自定义的），但有函数类型、Map 类型什么的
Forwarded from dnaugsuz
实现的难点在学校里已经考虑过了，我觉得是时间问题
难点一方面在解析器上，它是 2D syntax，支持缩进语义所以非常灵活
一方面是在新的 reverse pattern matching 上面，我下了好大功夫设计，而且还很难实现（但是一些基础的 reverse pattern 不难实现）
譬如上面那个
此时解释实现需构造一个 MixPattern 对象
另外一个实现问题就是 reverse method call pattern 可以从参数和返回值推导回 self，可是 self 的类型是什么？如果把实现调用接口的类型一个一个排除就太 inefficient 了
这就必须使用 1. 显示类型标记声明了但是没有定义的变量 2.
可是这就意味着 reverse pattern matching 的某些组合需要参考它子项目的属性，而且必须是有传递性的（因为不能保证永远是
这个我还没想好....
目前需要这个功能的好像还只有 reverse method call pattern 一个，我觉得大概可以在解析类型推导的时候解决
GalScript 里有函数和方法的区分，但是目前不打算支持函数的反向模式匹配... 因为函数没有隐式的 self 参数，就必须可以这么干了
... 算了，我还是不支持 first-class pattern 的 custom match operator，然后支持 implicit 参数的 match operator fn 的推导算了...
就像这样：
难点一方面在解析器上，它是 2D syntax，支持缩进语义所以非常灵活
一方面是在新的 reverse pattern matching 上面，我下了好大功夫设计，而且还很难实现（但是一些基础的 reverse pattern 不难实现）
譬如上面那个
match x + 1 = n 这个，n=1此时解释实现需构造一个 MixPattern 对象
MixPattern(+1, Unknown("x")) 就可以了，它接受一个输入，然后把输入 -1 交给 Unknown("x") 匹配，就可以得到一个副作用，执行完就有了未知数 x 的值另外一个实现问题就是 reverse method call pattern 可以从参数和返回值推导回 self，可是 self 的类型是什么？如果把实现调用接口的类型一个一个排除就太 inefficient 了
这就必须使用 1. 显示类型标记声明了但是没有定义的变量 2.
is pattern，这个 pattern 断言了未知数一定是某个类型，就可以确定反向计算的接受者(receiver) 类型了（从而可以拿到对应 match 方法的实现进行反向计算）match s.repace("aaa", "bbb") = "xbbb"
// Inefficientmatch (s is Str).repace("aaa", "bbb") = "xbbb"
// OKval s: Str// OK
match s.repace("aaa", "bbb") = "xbbb"
可是这就意味着 reverse pattern matching 的某些组合需要参考它子项目的属性，而且必须是有传递性的（因为不能保证永远是
(s is Str), (s is Str + 'a') 也是一样...）这个我还没想好....
目前需要这个功能的好像还只有 reverse method call pattern 一个，我觉得大概可以在解析类型推导的时候解决
GalScript 里有函数和方法的区分，但是目前不打算支持函数的反向模式匹配... 因为函数没有隐式的 self 参数，就必须可以这么干了
let add(x, 1) = 2可是这很麻烦（特别是对应的
let sub(x, -2) = 1
match operator fn 实现起来... 它得知道啥是未知啥是已知。我有办法（implicit & match fn）可是我觉得很鸡肋 ），而且 GalScript 又不是确切的逻辑式语言，支持部分反向计算本意是作为 Pattern matching 的扩充，这样的话对 GalScript 不好... 算了，我还是不支持 first-class pattern 的 custom match operator，然后支持 implicit 参数的 match operator fn 的推导算了...
就像这样：
class Str kind [char]
match operator fn repeat where
(implicit self, n: Nat)(it: Str) { self = it.take(n)[0..findSeqLength] } // 注意这不是 scala 的 currying 表示，()() 只是分割不同类型参数的语法糖....
(self, implicit n: Nat)(it: Str) { n = it.substrTakeWhile(self::startsWith).size }
fn findSeqLength(implicit it: Str) {...}
GalScript 的 cross 和 implicit、prefix operators、decorators 可以编写 async/await 关键字
+ def co 是什么？GalScript 有类似 ES6/Python 的 Generator 函数，它是自己包含状态可以挂起的状态机
+ ctx, cont 都可以拥有 implicit 的类型 def %async(...)(Fn ... -> ... -> ...) implicit x is Int, y is Int ....
+ await, away 是 prefix operator def，也可以拥有隐式的参数 implicit ctx: Cont, implicit cont: Fn
+ fail 该怎么实现（返回一个 error）？await 的 yield 该怎么办？有 cross inline，就可以办到了。所以他们都是 cross def
%async def co jsonRpc(ctx, cont, url)+ async 是什么？它是一个 decorator，就是高阶函数调用的简记法，它给内部的函数提供 coroutine context 和（传递下去，Thunk 函数的 callback）
val resp = await http.GET(url)
if match resp is Error => fail
val json = await json.parse(resp.body)
if match json is Error => fail
away json
+ def co 是什么？GalScript 有类似 ES6/Python 的 Generator 函数，它是自己包含状态可以挂起的状态机
+ ctx, cont 都可以拥有 implicit 的类型 def %async(...)(Fn ... -> ... -> ...) implicit x is Int, y is Int ....
+ await, away 是 prefix operator def，也可以拥有隐式的参数 implicit ctx: Cont, implicit cont: Fn
+ fail 该怎么实现（返回一个 error）？await 的 yield 该怎么办？有 cross inline，就可以办到了。所以他们都是 cross def
cross def fail(implicit Error as e) { return e }
dnaugsuz
实现的难点在学校里已经考虑过了，我觉得是时间问题 难点一方面在解析器上，它是 2D syntax，支持缩进语义所以非常灵活 一方面是在新的 reverse pattern matching 上面，我下了好大功夫设计，而且还很难实现（但是一些基础的 reverse pattern 不难实现） 譬如上面那个 match x + 1 = n 这个，n=1 此时解释实现需构造一个 MixPattern 对象 MixPattern(+1, Unknown("x")) 就可以了，它接受一个输入，然后把输入 -1 交给…
GalScript 还有一个特性，就是 Kotlin 也支持的 first-class delegates，它可以制造引用、惰性求值（虽然 GalScript 本身就支持）什么的
有意思的是 GalScript 的
class Box(val x: Any)就可以把一个右值(rhs value) 变成一重引用左值(lhs value) 了，除了可以再次赋值外，和原来的东西无异
operator as val = x
operator set val { x = it }
有意思的是 GalScript 的
set 关键字其实是用来定义 "enumeration" 的set TrafficLight { RED, GREEN, BLUE }本频道也对 editor duangsuse 的失败感到可惜（不过接下来
FROM openjdk:8u181-jdk-alpine3.8 AS builder//
ADD . /app
WORKDIR /app
RUN chmod +x gradlew \\
&& ./gradlew shadowJar \\
&& mv build/libs/server-*.jar server.jar
FROM openjdk:8u181-jre-alpine3.8 AS runner
WORKDIR /app
COPY --from=builder /app/server.jar .
ENTRYPOINT ["java","-jar", "server.jar"]
language: minimal
service:
- docker
script: docker build -t $IMGID .
install: docker login $DOCKER_REGISTRY -u $DOCKER_USER <dockp --password-stdin
deploy:
- provider: script
script: docker push $IMGID
on: [tags: true]
before_install:
- REV=$(git rev-list --count HEAD)
- IMGID="$DOCKER_REGISTRY/$DOCKER_IMAGE:$REV"
- echo $DOCKER_PASS >dockpForwarded from duangsuse::Echo (duangsuse /'dʊɔːŋ sjuːz/ | [⃪PLD, FPλ])
很不幸的是，我最终因为拖延症没能完成，我决定剩下的时间，完成一点文字工作。祝好。
很荣幸能在看完《浮生物语 III（上）》之后，完善我的文字 （啊，我表达一点自己的理想还老是和 drakeet 过不去）
这简直是... 很无聊 但是我得做啊
真不是有意跟 drakeet 过不去，可是这些文字除了这里我不知该放哪了... 好方便啊，以后都加这里吧...
这简直是... 很无聊 但是我得做啊
真不是有意跟 drakeet 过不去，可是这些文字除了这里我不知该放哪了... 好方便啊，以后都加这里吧...
GitHub
duangsuse-valid-projects/Share
🐕 duangsuse's shared files(e.g. productive software projects, documents) - duangsuse-valid-projects/Share
Forwarded from Deleted Account
🌝 将此帐号踢出群聊并且屏蔽的 admin 请出来说明一下
如果贵群是自由法制的话，请在踢出前进行说明或者公示，禁言比直接删人+block 强。
如果不法制的话『民主』又怎么样呢？自由是什么？管理员无理由不通知设置屏蔽的自由？大陆就是最好的例子
希望贵群聊所说的自由不是带引号的自由，群规不是共产式法制的群规。
https://t.me/dsuset/6339
谢谢。
如果贵群是自由法制的话，请在踢出前进行说明或者公示，禁言比直接删人+block 强。
如果不法制的话『民主』又怎么样呢？自由是什么？管理员无理由不通知设置屏蔽的自由？大陆就是最好的例子
希望贵群聊所说的自由不是带引号的自由，群规不是共产式法制的群规。
https://t.me/dsuset/6339
谢谢。
Telegram
duangsuse Throws
若是真的有违群规，禁言是可以理解的。
删贴、踢人，没有任何的解释，和小粉红那边又有什么区别？
单纯的过滤，和 GFW 是一样的，不过更加致命，因为人是比规则更善变的。
反对『极权』主义，自己却成了不敢正面回复的暴君。
不要做自己所看不起的事情。
删贴、踢人，没有任何的解释，和小粉红那边又有什么区别？
单纯的过滤，和 GFW 是一样的，不过更加致命，因为人是比规则更善变的。
反对『极权』主义，自己却成了不敢正面回复的暴君。
不要做自己所看不起的事情。
#Python #code
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Oct 2 17:41:10 2019
@author: DuangSUSE
"""
import pandas as pd
import matplotlib as mp
from matplotlib import pyplot as plt
from math import *
import random
xs = range(50, 100)
sins = [sin(x) for x in xs]
coss = [cos(x) for x in xs]
tans = [tan(x) for x in xs]
df = pd.DataFrame()
df['sin'] = sins
df['cos'] = coss
df['tan'] = tans
print(df.plot(title='Triangle waves'))
scat_x = [ random.randint(0,m) for m in range(0, 100) ]
scat_y = [ random.randint(0,m) for m in range(0, 100) ]
print(plt.scatter(scat_x, scat_y))
#Python #code
#!/usr/bin/env python3
f = open('sao.txt', 'r')
txt = f.read()
lns = txt.split('\n')
d = {}
for c in txt:
if c not in d.keys(): d[c] = 0
d[c] = d[c] + 1
wrds = [(k, d[k]) for k in d.keys()]
swd = sorted(wrds, key=lambda p: p[1], reverse=True)
print(''.join([x[0] for x in swd ]))
import jieba
dd['words'] = words = [list(jieba.tokenize(l)) for l in lns] dd['word_len'] = [len(w) for w in words]
dd['word_len_avg'] = [sum(len(c[0]) for c in w) / max(1, len(w)) for w in words]
wr = [ [t[0] for t in ln] for ln in words] sws = []
for xs in wr:
for x in xs:
sws.append(x)
wordc = {}
for (i, w) in enumerate(sws):
if not w in wordc: wordc[w] = ([i], 0)
orig = wordc[w]
orig[0].append(i)
wordc[w] = (orig[0], orig[1]+1) count = sorted([(k, wordc[k][1]) for k in wordc], key=lambda t: t[1], reverse=True)
print(''.join([t[0] for t in count]))