CHANGE: using Gregg Irwin's split updates

Taken from: https://gist.github.com/greggirwin/66d7c6892fc310097cd91ab354189542

Author: Oldes

src/mezz/mezz-series.reb

@@ -486,28 +486,55 @@ printf: func [
 	print format :fmt :val
 ]
 
-split: func [
+split: function [
 	"Split a series into pieces; fixed or variable size, fixed number, or at delimiters"
-	series	[series!] "The series to split"
-	dlm		[block! integer! char! bitset! any-string!] "Split size, delimiter(s), or rule(s)."
-	/skip	"If dlm is an integer, split into n pieces, rather than pieces of length n."
-	/local size piece-size count mk1 mk2 res fill-val add-fill-val
+	series [series!] "The series to split"
+	;!! If we support /at, dlm could be any-value.
+	dlm    ;[block! integer! char! bitset! any-string! any-function!] "Split size, delimiter(s), predicate, or rule(s)." 
+	/parts "If dlm is an integer, split into n pieces, rather than pieces of length n."
+	/at "Split into 2, at the index position if an integer or the first occurrence of the dlm"
 ][
-	either all [block? dlm  parse dlm [some integer!]] [
+	if any-function? :dlm [
+		res: reduce [ copy [] copy [] ]
+		foreach value series [
+			append/only pick res make logic! dlm :value :value
+		]
+		return res
+	]
+	if at [
+		return reduce either integer? dlm [
+			[
+				copy/part series dlm
+				copy lib/at series dlm + 1
+			]
+		][
+			;-- Without adding a /tail refinement, we don't know if they want
+			;	to split at the head or tail of the delimiter, so we'll exclude
+			;	the delimiter from the result entirely. They know what the dlm
+			;	was that they passed in, so they can add it back to either side
+			;	of the result if they want to.
+			[
+				copy/part series find series :dlm
+				copy find/tail series :dlm
+			]
+		]
+	]
+	;print ['split 'parts? parts mold series mold dlm]
+	either all [block? dlm  parse dlm [some integer!]][
 		map-each len dlm [
 			either positive? len [
 				copy/part series series: skip series len
-			] [
+			][
 				series: skip series negate len
-				; return unset so that nothing is added to output
-				()
+				()	;-- return unset so that nothing is added to output
 			]
 		]
 	][
-		size: dlm   ; alias for readability
+		size: dlm	;-- alias for readability
 		res: collect [
-			parse/all series case [
-				all [integer? size  skip] [
+			;print ['split 'parts? parts mold series mold dlm newline]
+			parse series case [
+				all [integer? dlm  parts][
 					if size < 1 [cause-error 'Script 'invalid-arg size]
 					count: size - 1
 					piece-size: to integer! round/down divide length? series size
@@ -521,36 +548,38 @@ split: func [
 					if size < 1 [cause-error 'Script 'invalid-arg size]
 					[any [copy series 1 size skip (keep/only series)]]
 				]
-				'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]
+				'else [	;-- = any [bitset? dlm  any-string? dlm  char? dlm]
 					[any [mk1: some [mk2: dlm break | skip] (keep/only copy/part mk1 mk2)]]
 				]
 			]
 		]
-		;-- Special processing, to handle cases where the spec'd more items in
-		;   /skip than the series contains (so we want to append empty items),
+		;-- Special processing, to handle cases where they spec'd more items in
+		;   /parts than the series contains (so we want to append empty items),
 		;   or where the dlm was a char/string/charset and it was the last char
 		;   (so we want to append an empty field that the above rule misses).
-		fill-val: does [copy either any-block? series [[]] [""]]
+		fill-val: does [copy either any-block? series [ [] ][ "" ]]
 		add-fill-val: does [append/only res fill-val]
 		case [
-			all [integer? size  skip] [
-				; If the result is too short, i.e., less items than 'size, add
-				; empty items to fill it to 'size.
-				; We loop here, because insert/dup doesn't copy the value inserted.
+			all [integer? size  parts][
+				;-- If the result is too short, i.e., less items than 'size, add
+				;   empty items to fill it to 'size.
+				;   We loop here, because insert/dup doesn't copy the value inserted.
 				if size > length? res [
 					loop (size - length? res) [add-fill-val]
 				]
 			]
-			; integer? dlm [
-			; ]
-			'else [ ; = any [bitset? dlm  any-string? dlm  char? dlm]
-				; If the last thing in the series is a delimiter, there is an
-				; implied empty field after it, which we add here.
+			;-- integer? size
+			;	If they spec'd an integer size, but did not use /parts, there is
+			;	no special filing to be done. The final element may be less than
+			;	size, which is intentional.
+			'else [ ;-- = any [bitset? dlm  any-string? dlm  char? dlm]
+					;-- If the last thing in the series is a delimiter, there is an
+					;   implied empty field after it, which we add here.
 				case [
 					bitset? dlm [
-						; ATTEMPT is here because LAST will return NONE for an
-						; empty series, and finding none in a bitest is not allowed.
-						if attempt [find dlm last series] [add-fill-val]
+						;-- ATTEMPT is here because LAST will return NONE for an 
+						;   empty series, and finding none in a bitest is not allowed.
+						if attempt [find dlm last series][add-fill-val]
 					]
 					char? dlm [
 						if dlm = last series [add-fill-val]
@@ -559,7 +588,7 @@ split: func [
 						if all [
 							find series dlm
 							empty? find/last/tail series dlm
-						] [add-fill-val]
+						][add-fill-val]
 					]
 				]
 			]

src/tests/units/series-test.r3

@@ -1501,13 +1501,13 @@ Rebol [
 --test-- "split block!"
 	;@@ https://github.com/Oldes/Rebol-issues/issues/2051
 	b: [a b c d e f]
-	--assert [[a b c d e f]]              = split/skip b 1
-	--assert [[a b c] [d e f]]            = split/skip b 2
-	--assert [[a b] [c d] [e f]]          = split/skip b 3
-	--assert [[a] [b] [c] [d e f]]        = split/skip b 4
-	--assert [[a] [b] [c] [d] [e f]]      = split/skip b 5
-	--assert [[a] [b] [c] [d] [e] [f]]    = split/skip b 6
-	--assert [[a] [b] [c] [d] [e] [f] []] = split/skip b 7
+	--assert [[a b c d e f]]              = split/parts b 1
+	--assert [[a b c] [d e f]]            = split/parts b 2
+	--assert [[a b] [c d] [e f]]          = split/parts b 3
+	--assert [[a] [b] [c] [d e f]]        = split/parts b 4
+	--assert [[a] [b] [c] [d] [e f]]      = split/parts b 5
+	--assert [[a] [b] [c] [d] [e] [f]]    = split/parts b 6
+	--assert [[a] [b] [c] [d] [e] [f] []] = split/parts b 7
 
 --test-- "split string!"
 	;@@ https://github.com/Oldes/Rebol-issues/issues/1886
@@ -1519,13 +1519,74 @@ Rebol [
 	--assert ["abc" "de" "fghi" "jk"] = split "abc|de/fghi:jk" charset "|/:"
 	--assert ["abc" "de" "fghi" "jk"] = split "abc^M^Jde^Mfghi^Jjk" [crlf | #"^M" | newline]
 	--assert ["abc" "de" "fghi" "jk"] = split "abc     de fghi  jk" [some #" "]
-	--assert ["12345678" "12345678"] = split/skip "1234567812345678" 2
-	--assert ["12345" "67812" "345678"] = split/skip "1234567812345678" 3
-	--assert ["123" "456" "781" "234" "5678"] = split/skip "1234567812345678" 5
+	--assert ["12345678" "12345678"] = split/parts "1234567812345678" 2
+	--assert ["12345" "67812" "345678"] = split/parts "1234567812345678" 3
+	--assert ["123" "456" "781" "234" "5678"] = split/parts "1234567812345678" 5
 	;@@ https://github.com/Oldes/Rebol-issues/issues/573
-	--assert ["c" "c"] = split "c c" " "
-	--assert ["1,2"]   = split "1,2" " "
+	--assert ["c" "c"]  = split "c c" " "
+	--assert ["1,2"]    = split "1,2" " "
 	--assert ["c" "c "] = split "c,c " ","
+--test-- "split gregg 1"
+	;@@ https://gist.github.com/greggirwin/66d7c6892fc310097cd91ab354189542
+	--assert (split "1234567812345678" 4)       = ["1234" "5678" "1234" "5678"]
+	--assert (split "1234567812345678" 3)       = ["123" "456" "781" "234" "567" "8"]
+	--assert (split "1234567812345678" 5)       = ["12345" "67812" "34567" "8"]
+	--assert (split/parts [1 2 3 4 5 6] 2)      = [[1 2 3] [4 5 6]]
+	--assert (split/parts "1234567812345678" 2) = ["12345678" "12345678"]
+	--assert (split/parts "1234567812345678" 3) = ["12345" "67812" "345678"]
+	--assert (split/parts "1234567812345678" 5) = ["123" "456" "781" "234" "5678"]
+
+--test-- "split gregg 2"
+	; Dlm longer than series"
+	--assert (split/parts "123" 6)   =     ["1" "2" "3" "" "" ""] ;or ["1" "2" "3"]
+	--assert (split/parts [1 2 3] 6) =     [[1] [2] [3] [] [] []] ;or [1 2 3]
+
+--test-- "split gregg 3"
+	--assert (split [1 2 3 4 5 6] [2 1 3])                = [[1 2] [3] [4 5 6]]
+	--assert (split "1234567812345678" [4 4 2 2 1 1 1 1]) = ["1234" "5678" "12" "34" "5" "6" "7" "8"]
+	--assert (split first [(1 2 3 4 5 6 7 8 9)] 3)        = [(1 2 3) (4 5 6) (7 8 9)]
+	--assert (split #{0102030405060708090A} [4 3 1 2])    = [#{01020304} #{050607} #{08} #{090A}]
+	--assert (split [1 2 3 4 5 6] [2 1])                  = [[1 2] [3]]
+	--assert (split [1 2 3 4 5 6] [2 1 3 5])              = [[1 2] [3] [4 5 6] []]
+	--assert (split [1 2 3 4 5 6] [2 1 6])                = [[1 2] [3] [4 5 6]]
+
+	; Old design for negative skip vals
+	; --assert (split [1 2 3 4 5 6] [3 2 2 -2 2 -4 3]]    [[1 2 3] [4 5] [6] [5 6] [3 4 5]]
+	; New design for negative skip vals
+	--assert (split [1 2 3 4 5 6] [2 -2 2])               = [[1 2] [5 6]]
+
+--test-- "split gregg 4"
+	--assert (split "abc,de,fghi,jk" #",")                = ["abc" "de" "fghi" "jk"]
+	--assert (split "abc<br>de<br>fghi<br>jk" <br>)       = ["abc" "de" "fghi" "jk"]
+
+	--assert (split "a.b.c" ".")           = ["a" "b" "c"]
+	--assert (split "c c" " ")             = ["c" "c"]
+	--assert (split "1,2,3" " ")           = ["1,2,3"]
+	--assert (split "1,2,3" ",")           = ["1" "2" "3"]
+	--assert (split "1,2,3," ",")          = ["1" "2" "3" ""]
+	--assert (split "1,2,3," charset ",.") = ["1" "2" "3" ""]
+	--assert (split "1.2,3." charset ",.") = ["1" "2" "3" ""]
+
+	--assert (split "-a-a" ["a"])    = ["-" "-"]
+	--assert (split "-a-a'" ["a"])   = ["-" "-" "'"]
+
+--test-- "split gregg 5"
+	--assert (split "abc|de/fghi:jk" charset "|/:")                   = ["abc" "de" "fghi" "jk"]
+	--assert (split "abc^M^Jde^Mfghi^Jjk" [crlf | #"^M" | newline])   = ["abc" "de" "fghi" "jk"]
+	--assert (split "abc     de fghi  jk" [some #" "])                = ["abc" "de" "fghi" "jk"]
+
+--test-- "split gregg 6"
+	--assert (split [1 2 3 4 5 6] :even?)  = [[2 4 6] [1 3 5]]
+	--assert (split [1 2 3 4 5 6] :odd?)   = [[1 3 5] [2 4 6]]
+	--assert (split [1 2.3 /a word "str" #iss x: :y] :refinement?) = [[/a] [1 2.3 word "str" #iss x: :y]]
+	--assert (split [1 2.3 /a word "str" #iss x: :y] :number?)     = [[1 2.3] [/a word "str" #iss x: :y]]
+	--assert (split [1 2.3 /a word "str" #iss x: :y] :any-word?)   = [[/a word #iss x: :y] [1 2.3 "str"]]
+
+--test-- "split gregg 7"
+	--assert (split/at [1 2.3 /a word "str" #iss x: :y] 4) =	[[1 2.3 /a word] ["str" #iss x: :y]]
+	;!! Splitting /at with a non-integer excludes the delimiter from the result
+	--assert (split/at [1 2.3 /a word "str" #iss x: :y] "str") =	[[1 2.3 /a word] [#iss x: :y]]
+	--assert (split/at [1 2.3 /a word "str" #iss x: :y] 'word) =	[[1 2.3 /a] ["str" #iss x: :y]]
 
 ===end-group===