thx kuanyui for the advice

[clo] / src / index.js

diff --git a/src/index.js b/src/index.js
index 712af45015c8dbd4747f9df53f1506724ca8effd..23320ac6471bd64cf15a6771802a5234bf85f354 100644 (file)
--- a/src/index.js
+++ b/src/index.js
@@ -1,7 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.thenDo = exports.charToCodepoint = exports.matchRange = exports.match1Char = void 0;
+exports.tokenize = exports.zeroOrOnceDo = exports.notDo = exports.zeroOrMoreDo = exports.orDo = exports.thenDo = exports.charToCodepoint = exports.matchRange = exports.matchAny = exports.match1Char = void 0;
 var fs = require('fs');
+/**
+ * wrap a x in a `Some(T)`
+ * @param x : variable to be wrapped.
+ * @returns wrapped `x`.
+ */
+function toSome(x) {
+    return { _tag: "Some", value: x };
+}
 /**
  * @description
  * it returns a function which test if the first char of the `remained` part of
@@ -12,6 +20,9 @@ var fs = require('fs');
  */
 function match1Char(c) {
     return (m) => {
+        if (m.remained.length == 0) {
+            return { _tag: "None" };
+        }
         const charToBeMatched = m.remained[0];
         if (charToBeMatched === c) {
             return { _tag: "Some", value: {
@@ -26,6 +37,24 @@ function match1Char(c) {
 }
 exports.match1Char = match1Char;
 ;
+/**
+ *
+ * @param m : the `MatcheePair` to be consumed.
+ * @returns if the length of `m.remained` >= 1; consumes the matchee by 1 char and wraps it in `Some`,
+ * otherwise, returns `None`.
+ */
+function matchAny(m) {
+    if (m.remained.length >= 1) {
+        return { _tag: "Some", value: {
+                matched: m.matched + m.remained[0],
+                remained: m.remained.substring(1)
+            } };
+    }
+    else {
+        return { _tag: "None" };
+    }
+}
+exports.matchAny = matchAny;
 /**
  * @description
  * it returns a function which test if the first char of the `remained` part of
@@ -42,6 +71,9 @@ function matchRange(l, u) {
         throw new Error("Error: the codepoint of `" + l + "` is not smaller than `" + u + "`)");
     }
     return (m) => {
+        if (m.remained.length < 1) {
+            return { _tag: "None" };
+        }
         const charToBeMatched = m.remained[0];
         const codePointToBeMatched = charToCodepoint(charToBeMatched);
         if (codePointToBeMatched >= lCodepoint && codePointToBeMatched <= uCodepoint) {
@@ -75,6 +107,10 @@ exports.charToCodepoint = charToCodepoint;
 /**
  *  @description thendo(input, f, ...) like
  * a ==> f
+ * @param input: the wrapped input.
+ * @param f: the function to be applied.
+ *
+ * @returns:the applied wrapped result `MatcheePair`.
  */
 function thenDo(input, f) {
     if (input._tag == "None") {
@@ -86,3 +122,109 @@ function thenDo(input, f) {
     }
 }
 exports.thenDo = thenDo;
+/**
+ * @description "or", like the regex `( f1 | f2 )` .
+ * It returns a function `f` of which the argument is`x`.
+ * if `f1(x)` is None, then `f` returns `f2(x)`. Otherwise,
+ * `F` returns `f1(x)`.
+ * @param f1 : 1st function to be compared
+ * @param f2 : 2nd function to be compared
+ * @returns:the combined function
+ */
+function orDo(f1, f2) {
+    return (x) => {
+        let f1x = (f1(x));
+        {
+            if (f1x._tag == "None") {
+                return f2(x);
+            }
+            else {
+                return f1x;
+            }
+        }
+    };
+}
+exports.orDo = orDo;
+/**
+* @description repeating matching function `f`
+* zero or more times, like the asterisk `*` in regex `f*` .
+* @param f : the function to be repeated 0+ times.
+* @returns:the combined function
+*/
+function zeroOrMoreDo(f) {
+    return (x) => {
+        var wrapped_old_x = { _tag: "Some", value: x };
+        var wrapped_new_x = wrapped_old_x;
+        while (wrapped_new_x._tag != "None") {
+            wrapped_old_x = wrapped_new_x;
+            wrapped_new_x = thenDo(wrapped_old_x, f);
+        }
+        ;
+        return wrapped_old_x;
+    };
+}
+exports.zeroOrMoreDo = zeroOrMoreDo;
+/**
+* @description Not. like the `^` inside regex of [^f].
+* returns a function `F(x)` such that if  `f(x)` is `None`,
+* returns the x consuming a char; if `f(x)` is not None, F(x)
+* returns `None`.
+* @param f: the function forbidden to be matched.
+* @returns: combined function `F`.
+*/
+function notDo(f) {
+    return (x) => {
+        let wrapped_x = {
+            _tag: "Some",
+            value: x
+        };
+        let f_x = thenDo(wrapped_x, f);
+        if (f_x._tag != "None") {
+            return { _tag: "None" };
+        }
+        else {
+            return thenDo(wrapped_x, matchAny);
+        }
+    };
+}
+exports.notDo = notDo;
+/**
+ * if `x` is matched by `f` once, returns `f(x)`. Otherwise,
+ * returns x
+ * similar to `?` in regex `f?`.
+ * @param f : the function to be matched
+ * @returns return wrapped f(x)
+ */
+function zeroOrOnceDo(f) {
+    return (x) => {
+        var wrapped_old_x = { _tag: "Some", value: x };
+        var wrapped_new_x = thenDo(wrapped_old_x, f);
+        if (wrapped_new_x._tag != "None") {
+            return wrapped_new_x;
+        }
+        else {
+            return wrapped_old_x;
+        }
+    };
+}
+exports.zeroOrOnceDo = zeroOrOnceDo;
+function tokenize(input) {
+    var input_matchee_pair = toSome({ matched: "",
+        remained: input });
+    // integer = ([+]|[-])\d\d?
+    let integer = (x) => {
+        let wrapped_x = toSome(x);
+        let plusMinus = orDo(match1Char('+'), match1Char('-')); // ([+]|[-])
+        let d = matchRange('0', '9'); // \d
+        return thenDo(thenDo(thenDo(wrapped_x, zeroOrOnceDo(plusMinus)), d), zeroOrMoreDo(d));
+    };
+    console.log(input + ", result: ");
+    console.log(thenDo(input_matchee_pair, integer));
+    // TODO: id, string, space, basic operator, 3 marks: @, {, }.
+}
+exports.tokenize = tokenize;
+tokenize("+123");
+tokenize("123");
+tokenize("-123");
+tokenize(" 123");
+tokenize("c123");