Small tinkerings and additions.

composite.red

@@ -17,7 +17,10 @@ composite-ctx: context [
 		ctx [none! object!] "Evaluate expr in the given context; none means use global context"
 		/local res
 	][
-		expr: load expr
+		if error? set/any 'res try [expr: load expr][
+			;return any [err-val  form reduce [" *** Error: Invalid expression Where:" expr "*** "]]
+			cause-error 'syntax 'invalid [arg1: 'composite-expression arg2: expr]
+		]
 		; If expression evaluates to a non-block value that is anything other than a 
 		; word, we can't bind it.
 		if all [ctx  any [block? :expr  word? :expr]][bind expr ctx]
@@ -34,12 +37,23 @@ composite-ctx: context [
 	; with a refinement, and then just have to choose the default.
 	; Putting the colons on the outside gives you a clean paren expression
 	; on the inside.
+	; `Compose` could be extended, to work as-is for blocks, but add support for
+	; this behavior for strings. The extra refinements are an issue, though.
+	; They don't conflict with the existing `compose` refinements, but we
+	; have to see how they might cause confusion given the different behaviors.
 	set 'composite func [
-		"Replace :( ... ): sections in a string with their evaluated results."
+		"Returns a copy of a string, evaluating :( ... ): sections"
+		;"Replace :( ... ): sections in a string with their evaluated results"
+		;"Returns a copy of a string, replacing :( ... ): sections with their evaluated results"
 		data [string! file! url!]
 		/marks markers [block!] "Use custom expression markers in place of :( and ):"
 		/with ctx [object!] "Evaluate the expressions in the given context"
 		/err-val e "Use instead of formed error info from eval error"
+		; /into might be useful, but it also complicates things, given the current implementation.
+		; Need to weigh the value. If we always create or use the out buffer, rather than changing
+		; the input data in place, it won't add much complexity.
+		;/into "Put results in `out`, instead of creating a new string"
+		;	out [string!] "Target for results, when /into is used"
 		/local expr expr-beg= expr-end= pos
 	][
 		if all [marks  not parse markers [2 [char! | string! | tag!]]][

format-date-time.red

@@ -362,6 +362,10 @@ date-time-formatting: context [
 		case [
 			string? fmt [format-date-time-via-mask value fmt]
 			block? fmt [format-date-time-via-accessors value fmt]
+			;!! If we check for named formats first, and just set the format
+			;	to the string format associated with the name, we eliminate
+			;	the recursive call. There are a few exception cases, where we
+			;	just FORM the value, and where we force it to be a UTC time.
 			'else [
 				; named formats
 				switch/default fmt [

format.red

@@ -17,6 +17,11 @@ Red [
 		- mold-logic (DONE)
 		- Composite (DONE)
 		- as-ordinal (DONE)
+
+		- block interpolation
+		- string interpolation
+		- date format
+		- format-number-via-masks
 	}
 	TBD: {
 		- Determine exact format-by-width/short-form+prec behavior! It seems like the
@@ -565,6 +570,7 @@ formatting: context [
 			rejoin [round/to size scale  any [ch ""]  units/1]
 		]
 	]
+
 	; Should this also support integers, so format-number doesn't have to call this 
 	; func? Really, it could support any value that can be converted to logic, but
 	; is that more helpful to the user, or will it make things more confusing for
@@ -984,8 +990,7 @@ formatting: context [
 			C-hex    [join "0x" to-hex to integer! n]
 			;VB-hex   [join "&H" to-hex to integer! n]
 			;octal    [] ; maybe useful for things like `chmod 755` viz	; no enbase for octal yet
-			bin      [num-to-bin-str n]
-			binary   [num-to-bin-str n]
+			bin binary [num-to-bin-str n]
 			min-bin  [							; No leading zeros
 				either zero? n [""] [
 					form find num-to-bin-str n complement charset "0"

formatting-functions.adoc

@@ -64,7 +64,7 @@ details start to pop up.
 - Format a block of values
 - Support formats suited to each datatype
 - Interpolate formatted values into a block
-- Interpolate values in a string
+- Interpolate formatted values in a string
 - Create a formatted row
 - Create a formatted column
 - Create a table

short-format.red

@@ -215,6 +215,7 @@ short-format-ctx: context [
 		value: case [												; Reassign 'value to string result for later padding
 			spec/style [apply-format-style value spec/style]		; A named format style was used
 			not number? :value [form any [:value ""]]				; Coerce none to ""; form to prevent arg modifcation
+																	; ?? What about FALSE?
 			'else [
 				suffix: either all [integer? value  flag? spec #"º"] [ordinal-suffix value][""]
 				append mold absolute value suffix					; Note: absolute; no sign here
@@ -274,10 +275,10 @@ short-format-ctx: context [
 			; then want a way to skip to a new index in the values.
 			case [
 				none?    spec/key [if series? data [take data]]	; unkeyed field, take sequentially from data
-				integer? spec/key [pick-val data spec/key]			; index key
-				paren?   spec/key [do-paren spec/key]				; expression to evaluate
-				path?    spec/key [get-path-key data spec/key]		; deep key
-				'else [												; simple key name
+				integer? spec/key [pick-val data spec/key]		; index key
+				paren?   spec/key [do-paren spec/key]			; expression to evaluate
+				path?    spec/key [get-path-key data spec/key]	; deep key
+				'else [											; simple key name
 					;?? Do we want to allow functions? I'm not so sure.
 					val: select data spec/key
 					either any-function? :val [val][val]

test-composite.red

@@ -57,6 +57,8 @@ foreach val [
 	")::("
 	":(1):beg):"
 	"asdf:(1):beg):"
+	":(1/a/b/c):"
+	":(2abc):"
 ][test-bad-composite val]
 
 print "^/Composite/Marks"
@@ -83,6 +85,8 @@ foreach val [
 	"a:(a + b):b"
 ][test-composite-with val o]
 
+
+
 print ""
 
 halt

test-format.red

@@ -2,6 +2,7 @@
 
 do %format.red
 do %short-format.red
+do %format-date-time.red
 
 ;-------------------------------------------------------------------------------