miloignis/kraken
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gonna checkpoint here - got basic fungll working, did a mod to allow strings as terminals, working on getting recursion working.

Browse Source
This commit is contained in:
Nathan Braswell
2021-08-05 00:07:44 -04:00
parent 5a61d5f90c
commit c8c876e1bc
5 changed files with 136 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
fungll.kp
View File

@@ -38,8 +38,9 @@
altStart (lambda (t s k c) id)
altOp (lambda (p q) (lambda (t s k c) (lcompose (p t s k c) (q t s [] k c))))
term_parser (lambda (t [X b i] l k c) (lambda (sigma)
(if (= (idx b (- i 1)) (idx t k)) ((c [[X b i] l (+ 1 k)]) sigma)
sigma)))
(let (this_term (idx b (- i 1)))
(if (= this_term (slice t k (+ k (len this_term)))) ((c [[X b i] l (+ (len this_term) k)]) sigma)
sigma))))
term (lambda (s) [ s term_parser ])
continue (lambda (BSR_element c) (lambda ([U G P Y])

48
fungll_test.kp
View File

@@ -1,6 +1,48 @@
(with_import "./fungll.kp"
(let (
just_a_parser (parse (nterm 'A (altOp altStart (seqOp seqStart (term (idx "a" 0))))))
parse_result (just_a_parser "a")
_ (println "parse result " parse_result)
_ (println "The a parser")
just_a_parser (parse (nterm 'A (altOp altStart (seqOp seqStart (term "a")))))
_ (println "parse result for a " (just_a_parser "a"))
_ (println "parse result for b " (just_a_parser "b"))
_ (println "parse result for aa " (just_a_parser "aa"))
_ (println "parse result for ba " (just_a_parser "ba"))
_ (println "parse result for ab " (just_a_parser "ab"))
_ (println "The aa parser")
just_aa_parser (parse (nterm 'A (altOp altStart (seqOp seqStart (term "aa")))))
_ (println "parse result for a " (just_aa_parser "a"))
_ (println "parse result for b " (just_aa_parser "b"))
_ (println "parse result for aa " (just_aa_parser "aa"))
_ (println "parse result for ba " (just_aa_parser "ba"))
_ (println "parse result for ab " (just_aa_parser "ab"))
_ (println "The a.a parser")
just_aa_parser (parse (nterm 'A (altOp altStart (seqOp (seqOp seqStart (term "a")) (term "a")))))
_ (println "parse result for a " (just_aa_parser "a"))
_ (println "parse result for b " (just_aa_parser "b"))
_ (println "parse result for aa " (just_aa_parser "aa"))
_ (println "parse result for ba " (just_aa_parser "ba"))
_ (println "parse result for ab " (just_aa_parser "ab"))
_ (println "The b|a.a parser")
just_aa_parser (parse (nterm 'A (altOp (altOp altStart (seqOp seqStart (term "b"))) (seqOp (seqOp seqStart (term "a")) (term "a")))))
_ (println "parse result for a " (just_aa_parser "a"))
_ (println "parse result for b " (just_aa_parser "b"))
_ (println "parse result for aa " (just_aa_parser "aa"))
_ (println "parse result for ba " (just_aa_parser "ba"))
_ (println "parse result for ab " (just_aa_parser "ab"))
_ (println "The a|a,A parser")
just_aa_parser (let-rec (
As (nterm 'A (altOp (altOp altStart (seqOp seqStart (term "a"))) (seqOp (seqOp seqStart (term ",")) As)))
) (parse As))
_ (println "parse result for a " (just_aa_parser "a"))
_ (println "parse result for b " (just_aa_parser "b"))
_ (println "parse result for aa " (just_aa_parser "aa"))
_ (println "parse result for ba " (just_aa_parser "ba"))
_ (println "parse result for ab " (just_aa_parser "ab"))
_ (println "parse result for a,a " (just_aa_parser "a,a"))
_ (println "parse result for a,a,a " (just_aa_parser "a,a,a"))
) nil))

93
k_prime.krak
View File

@@ -46,6 +46,15 @@ obj KPEnv (Object) {
destruct()
copy_construct(&other)
}
fun operator<(other: ref KPEnv):bool {
if data.keys < other.data.keys || data.values < other.data.values {
return true;
}
if (outer != null<KPEnv>()) && ((other.outer == null<KPEnv>()) || (*outer < *other.outer)) {
return true;
}
return false;
}
fun set(key: str, val: KPValue) {
data.set(key, val)
}
@@ -117,6 +126,9 @@ obj KPBuiltinCombiner (Object) {
fun operator==(other: ref KPBuiltinCombiner):bool {
return name == other.name
}
fun operator<(other: ref KPBuiltinCombiner):bool {
return name < other.name
}
fun call(params: vec<KPValue>, dynamic_env: KPValue): pair<*KPEnv, KPResult> {
if !dynamic_env.is_env() {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(pr_str(dynamic_env, true) + " is not an env")))
@@ -178,6 +190,10 @@ obj KPCombiner (Object) {
// not sure about env
return env == other.env && dynamic_env_name == other.dynamic_env_name && wrap_level == other.wrap_level && parameters == other.parameters && is_variadic == other.is_variadic && body->equals(*other.body)
}
fun operator<(other: ref KPCombiner):bool {
// not sure about env
return *env < *other.env || dynamic_env_name < other.dynamic_env_name || wrap_level < other.wrap_level || parameters < other.parameters || is_variadic < other.is_variadic || body->lt(*other.body)
}
// no call b/c need to do in EVAL for TCO
fun prep_call(params: ref vec<KPValue>, dynamic_env: KPValue): pair<*KPEnv, KPResult> {
for (var l = 0; l < wrap_level; l++;) {
@@ -268,6 +284,45 @@ obj KPValue (Object) {
}
return false
}
fun variant(): int {
match (internal) {
KPValue_int::Array(d) { return 0; }
KPValue_int::String(d) { return 1; }
KPValue_int::Int(d) { return 2; }
KPValue_int::Symbol(d) { return 3; }
KPValue_int::Combiner(d) { return 4; }
KPValue_int::BuiltinCombiner(d) { return 5; }
KPValue_int::Env(e) { return 6; }
KPValue_int::True() { return 7; }
KPValue_int::False() { return 8; }
KPValue_int::Nil() { return 9; }
}
}
fun operator<(other: ref KPValue):bool {
return this->lt(other)
}
fun lt(other: ref KPValue): bool {
var our_variant = variant()
var their_variant = other.variant()
if our_variant < their_variant {
return true;
} else if our_variant > their_variant {
return false;
}
match (internal) {
KPValue_int::Array(d) { match (other.internal) { KPValue_int::Array(db) { return d.get() < db.get(); } } }
KPValue_int::String(d) { match (other.internal) { KPValue_int::String(db) { return d < db; } } }
KPValue_int::Int(d) { match (other.internal) { KPValue_int::Int(db) { return d < db; } } }
KPValue_int::Symbol(d) { match (other.internal) { KPValue_int::Symbol(db) { return d < db; } } }
KPValue_int::Combiner(d){ match (other.internal) { KPValue_int::Combiner(db) { return d < db; } } }
KPValue_int::BuiltinCombiner(d) { match (other.internal) { KPValue_int::BuiltinCombiner(db) { return d < db; } } }
KPValue_int::Env(e) { match (other.internal) { KPValue_int::Env(eb) { return e < eb; } } }
KPValue_int::True() { match (other.internal) { KPValue_int::True() { return false; } } }
KPValue_int::False() { match (other.internal) { KPValue_int::False() { return false; } } }
KPValue_int::Nil() { match (other.internal) { KPValue_int::Nil() { return false; } } }
}
return false
}
fun deep_clone(): KPValue {
match (internal) {
KPValue_int::Array(v) {
@@ -1100,25 +1155,33 @@ fun main(argc: int, argv: **char): int {
}));
env->set(str("="), make_builtin_combiner(str("="), 1, false, fun(params: vec<KPValue>, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> {
if params.size != 2 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 params to ="))))
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to ="))))
}
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(params[0].equals(params[1]))))
for (var i = 0; i < params.size - 1; i++;) {
if !(params[i].equals(params[i+1])) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(true)))
}));
env->set(str("!="), make_builtin_combiner(str("!="), 1, false, fun(params: vec<KPValue>, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> {
if params.size != 2 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 params to !="))))
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to !="))))
}
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(!params[0].equals(params[1]))))
for (var i = 0; i < params.size - 1; i++;) {
if (params[i].equals(params[i+1])) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(true)))
}));
env->set(str("<"), make_builtin_combiner(str("<"), 1, false, fun(params: vec<KPValue>, dynamic_env: *KPEnv): pair<*KPEnv, KPResult> {
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to <"))))
}
if !params[0].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called < with first not an int ") + pr_str(params[0], true) + "\nenv was\n" + dynamic_env->to_string()))); }
for (var i = 0; i < params.size - 1; i++;) {
if !params[i+1].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called < with param ") + (i+1) + " not an int " + pr_str(params[i+1], true)))); }
if !(params[i].get_int() < params[i+1].get_int()) {
if !(params[i].lt(params[i+1])) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}
@@ -1128,10 +1191,8 @@ fun main(argc: int, argv: **char): int {
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to <="))))
}
if !params[0].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called <= with first not an int")))); }
for (var i = 0; i < params.size - 1; i++;) {
if !params[i+1].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called <= with not an int")))); }
if !(params[i].get_int() <= params[i+1].get_int()) {
if !(params[i].lt(params[i+1])) && !(params[i].equals(params[i+1])) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}
@@ -1141,10 +1202,8 @@ fun main(argc: int, argv: **char): int {
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to >"))))
}
if !params[0].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called > with first not an int")))); }
for (var i = 0; i < params.size - 1; i++;) {
if !params[i+1].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called > with param ") + (i+1) + " not an int " + pr_str(params[i+1], true)))); }
if !(params[i].get_int() > params[i+1].get_int()) {
if params[i].lt(params[i+1]) || params[i].equals(params[i+1]) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}
@@ -1154,10 +1213,8 @@ fun main(argc: int, argv: **char): int {
if params.size <= 1 {
return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("Need 2 or more params to >="))))
}
if !params[0].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called >= with first not an int")))); }
for (var i = 0; i < params.size - 1; i++;) {
if !params[i+1].is_int() { return make_pair(null<KPEnv>(), KPResult::Err(kpString(str("called >= with not an int")))); }
if !(params[i].get_int() >= params[i+1].get_int()) {
if params[i].lt(params[i+1]) {
return make_pair(null<KPEnv>(), KPResult::Ok(kpBool(false)))
}
}

3
stdlib/str.krak
View File

@@ -223,6 +223,9 @@ obj str (Object, Serializable, Hashable) {
r++
}
}
fun operator<(other: ref str): bool {
return *this <= other && *this != other
}
fun operator*(n: int): str {
var to_ret.construct(): str

10
stdlib/vec.krak
View File

@@ -207,6 +207,16 @@ obj vec<T> (Object, Serializable) {
return false
return true
}
fun operator< <U>(other: ref vec<U>):bool {
if (size < other.size)
return true
if (size > other.size)
return false
for (var i = 0; i < size; i++;)
if (data[i] < other.data[i]) // it's !(==) because we want equality if our members are equal, and overloading etc
return true
return false
}
fun set(index: int, dataIn: ref T): void {
if (index < 0 || index >= size)