add extra len result value

Author: kbkpbot

Diff for: branch.v

@@ -4,10 +4,10 @@ module vom
 
 // Tests a list of `parsers` one by one until one succeeds.
 pub fn alt(parsers []Fn) Fn {
-	return fn [parsers] (input string) !(string, string) {
+	return fn [parsers] (input string) !(string, string, int) {
 		for parser in parsers {
-			temp, output := parser(input) or { continue }
-			return temp, output
+			temp, output, len := parser(input) or { continue }
+			return temp, output, len
 		}
 		return error('`alt` failed on input `${input}` with `${parsers.len}` parsers')
 	}
@@ -16,7 +16,7 @@ pub fn alt(parsers []Fn) Fn {
 // Applies a list of `parsers` in any order.
 // Permutation will succeed if all of the child `parsers` succeeded. It takes as argument a tuple of `parsers`, and returns a tuple of the parser results.
 pub fn permutation(parsers []Fn) FnMany {
-	return fn [parsers] (input string) !(string, []string) {
+	return fn [parsers] (input string) !(string, []string, int) {
 		for perm in quick_perm(parsers.len) {
 			mut functions := []Fn{}
 			for i in perm {
@@ -25,8 +25,8 @@ pub fn permutation(parsers []Fn) FnMany {
 			parser := tuple(functions)
 			// the code above should just work as below, bug for now:
 			// parser := tuple(...perm.map(parsers[index]))
-			temp, output := parser(input) or { continue }
-			return temp, output
+			temp, output, len := parser(input) or { continue }
+			return temp, output, len
 		}
 		return error('`permutation` failed on `${input}` because no permutations were found')
 	}

Diff for: branch_test.v

@@ -2,14 +2,16 @@ module vom
 
 fn test_alt() ! {
 	parser := alt([tag('llo'), take(9), tag('hi'), take(5)])
-	rest, output := parser('hello...')!
+	rest, output, len := parser('hello...')!
 	assert output == 'hello'
 	assert rest == '...'
+	assert len == 5
 }
 
 fn test_permutation() ! {
 	parser := permutation([tag('123'), tag('abc')])
-	rest, output := parser('abc123123abc...')!
+	rest, output, len := parser('abc123123abc...')!
 	assert output == ['abc', '123']
 	assert rest == '123abc...'
+	assert len == 6
 }

Diff for: bytes.v

@@ -8,26 +8,26 @@ module vom
 // The third argument matches the escaped characters
 
 pub fn escaped(normal Fn, control_char rune, escapable Fn) Fn {
-	return fn [normal, control_char, escapable] (input string) !(string, string) {
+	return fn [normal, control_char, escapable] (input string) !(string, string, int) {
 		check_control_char := tag(control_char.str())
-		a, b := normal(input) or { input, '' }
-		c, d := check_control_char(a) or { a, '' }
-		e, f := escapable(c) or { c, '' }
-		g, h := normal(e) or { e, '' }
+		a, b, len1 := normal(input) or { input, '', 0 }
+		c, d, len2 := check_control_char(a) or { a, '', 0 }
+		e, f, len3 := escapable(c) or { c, '', 0 }
+		g, h, len4 := normal(e) or { e, '', 0 }
 
 		if input == g {
 			return error('`escaped` fail')
 		}
-		return g, b + d + f + h
+		return g, b + d + f + h, len1 + len2 + len3 + len4
 	}
 }
 
 // Returns the longest slice that matches any character in the `pattern`.
 pub fn is_a(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		for i, c in input {
 			if !pattern.bytes().any(it == c) {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`is_a` failed with pattern `${pattern}` on input `${input}`')
@@ -36,10 +36,10 @@ pub fn is_a(pattern string) Fn {
 
 // Parse till certain characters are met.
 pub fn is_not(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		for i, c in input {
 			if pattern.bytes().any(it == c) {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`is_not` failed with pattern `${pattern}` on input `${input}`')
@@ -48,12 +48,12 @@ pub fn is_not(pattern string) Fn {
 
 // Recognizes a `pattern`.
 pub fn tag(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		if input.len < pattern.len {
 			return error('`tag` failed because input `${input}` is shorter than pattern `${pattern}`')
 		}
 		if input[..pattern.len] == pattern {
-			return input[pattern.len..], input[..pattern.len]
+			return input[pattern.len..], input[..pattern.len], pattern.len
 		} else {
 			return error('`tag` failed because `${input}[..${pattern.len}]` is not equal to pattern `${pattern}`')
 		}
@@ -62,12 +62,12 @@ pub fn tag(pattern string) Fn {
 
 // Recognizes a case insensitive `pattern`.
 pub fn tag_no_case(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		if input.len < pattern.len {
 			return error('`tag_no_case` failed because input `${input}` is shorter than pattern `${pattern}`')
 		}
 		if input[..pattern.len].to_lower() == pattern.to_lower() {
-			return input[pattern.len..], input[..pattern.len]
+			return input[pattern.len..], input[..pattern.len], pattern.len
 		} else {
 			return error('`tag_no_case` failed because `${input}[..${pattern.len}].to_lower()` is not equal to pattern `${pattern}`')
 		}
@@ -76,21 +76,21 @@ pub fn tag_no_case(pattern string) Fn {
 
 // Returns an input slice containing the first `n` input elements (Input[..`n`]).
 pub fn take(n int) Fn {
-	return fn [n] (input string) !(string, string) {
+	return fn [n] (input string) !(string, string, int) {
 		if input.len < n {
 			return error('`take` failed with count `${n}` on input `${input}`')
 		} else {
-			return input[n..], input[..n]
+			return input[n..], input[..n], n
 		}
 	}
 }
 
 // Returns the longest input slice (if any) till a predicate `condition` is met.
 pub fn take_till(condition fn (byte) bool) Fn {
-	return fn [condition] (input string) !(string, string) {
+	return fn [condition] (input string) !(string, string, int) {
 		for i, c in input.bytes() {
 			if condition(c) {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`take_till` failed on input `${input}`')
@@ -99,10 +99,10 @@ pub fn take_till(condition fn (byte) bool) Fn {
 
 // Returns the longest (at least 1) input slice till a predicate `condition` is met.
 pub fn take_till1(condition fn (byte) bool) Fn {
-	return fn [condition] (input string) !(string, string) {
+	return fn [condition] (input string) !(string, string, int) {
 		for i, c in input.bytes() {
 			if condition(c) && i > 0 {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`take_till1` failed on input `${input}`')
@@ -111,10 +111,10 @@ pub fn take_till1(condition fn (byte) bool) Fn {
 
 // Returns the input slice up to the first occurrence of the `pattern`.
 pub fn take_until(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		for i := 0; i + pattern.len <= input.len; i++ {
 			if input[i..i + pattern.len] == pattern {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`take_until` failed on input `${input}` with pattern `${pattern}`')
@@ -123,10 +123,10 @@ pub fn take_until(pattern string) Fn {
 
 // Returns the non empty input slice up to the first occurrence of the `pattern`.
 pub fn take_until1(pattern string) Fn {
-	return fn [pattern] (input string) !(string, string) {
+	return fn [pattern] (input string) !(string, string, int) {
 		for i := 1; i + pattern.len <= input.len; i++ {
 			if input[i..i + pattern.len] == pattern {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
 		return error('`take_until1` failed on input `${input}` with pattern `${pattern}`')
@@ -135,34 +135,34 @@ pub fn take_until1(pattern string) Fn {
 
 // Returns the longest input slice (if any) that matches the predicate `condition`.
 pub fn take_while(condition fn (byte) bool) Fn {
-	return fn [condition] (input string) !(string, string) {
+	return fn [condition] (input string) !(string, string, int) {
 		for i, c in input.bytes() {
 			if !condition(c) {
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
-		return '', input
+		return '', input, input.len
 	}
 }
 
 // Returns the longest (at least 1) input slice that matches the predicate `condition`.
 pub fn take_while1(condition fn (byte) bool) Fn {
-	return fn [condition] (input string) !(string, string) {
+	return fn [condition] (input string) !(string, string, int) {
 		for i, c in input.bytes() {
 			if !condition(c) {
 				if i == 0 {
 					return error('`take_while` failed on input `${input}` because it returned empty')
 				}
-				return input[i..], input[..i]
+				return input[i..], input[..i], i
 			}
 		}
-		return '', input
+		return '', input, input.len
 	}
 }
 
 // Returns the longest (m <= len <= n) input slice that matches the predicate `condition`.
 pub fn take_while_m_n(m int, n int, condition fn (byte) bool) Fn {
-	return fn [m, n, condition] (input string) !(string, string) {
+	return fn [m, n, condition] (input string) !(string, string, int) {
 		mut longest := -1
 		for i, c in input.bytes() {
 			len := i + 1
@@ -174,7 +174,7 @@ pub fn take_while_m_n(m int, n int, condition fn (byte) bool) Fn {
 			}
 		}
 		if longest != -1 {
-			return input[longest..], input[..longest]
+			return input[longest..], input[..longest], longest
 		} else {
 			return error('`take_while_m_n` failed on input `${input}` with m `${m}` and n `${n}`')
 		}