Val[in:out]
{
	out <- in
}

_Map[list,index,worker:out]
{
	newval <- [
		[worker]Do[  
			[()]Append[ [list]Index[index] ]
		]
	]Index[0]
	
	[list]Next[index]
	{
		out <- [_Map[list, ~, worker]]Set[index, newval]
	}{
		out <- [list]Set[index, newval]
	}
}

Map[list,worker:out]
{
	[list]First
	{
		out <- _Map[list, ~, worker]
	}{
		out <- list
	}
}

_SMap[list,index,worker:out]
{
	newval <- [
		[worker]Do[  
			[()]Append[ [list]Index[index] ]
		]
	]Index[0]
	
	[list]Next[index]
	{
		out <- _SMap[[list]Set[index, newval], ~, worker]
	}{
		out <- [list]Set[index, newval]
	}
}

SMap[list,worker:out]
{
	[list]First
	{
		out <- _SMap[list, ~, worker]
	}{
		out <- list
	}
}

_Key Value Map[list,index,newlist,worker:out]
{
	[worker]Do[
		[[()]Append[ [list]Index[index] ]]Append[index]
	]
	{
		newval <- [~]Index[0]
		newkey <- [~]Index[1]
	}
	
	next <- [newlist]Set[newkey, newval]
	
	[list]Next[index]
	{
		out <- _Key Value Map[list, ~, next, worker]
	}{
		out <- Val[next]
	}
}

New Like@List[in:out]
{
	out <- ()
}

New Like@Dictionary[in:out]
{
	out <- Dictionary[]
}

Key Value Map[list,worker:out]
{
	[list]First
	{
		out <- _Key Value Map[list, ~, New Like[list], worker]
	}{
		out <- New Like[list]
	}
}

To String@String[string:out]
{
	out <- string
}

Empty@String[string:out]
{
	out <- ""
}

In[needle,haystack:found?]
{
	[haystack]Get DString[To String[needle]]
	{
		found? <- Yes
	} {} {} {
		found? <- No
	}
}

Left Trim[string,trim:trimmed]
{
	If[ [[string]Length] > [0] ]
	{
		first,rest <- [string]Slice[1]
		If[ [first]In[trim] ]
		{
			trimmed <- Left Trim[rest, trim]
		}{
			trimmed <- string
		}
	}{
		trimmed <- string
	}
}

Right Trim[string,trim:trimmed]
{
	If[ [[string]Length] > [0] ]
	{
		rest,last <- [string]Slice[ [[string]Length] - [1]]
		If[ [last]In[trim] ]
		{
			trimmed <- Right Trim[rest, trim]
		}{
			trimmed <- string
		}
	}{
		trimmed <- string
	}
}

Trim[string,trim:trimmed]
{
	left <- Left Trim[string, trim]
	trimmed <- Right Trim[left, trim]
}

Max[a,b:max]
{
	If[[a] > [b]]
	{
		max <- a
	}{
		max <- b
	}
}

Min[a,b:min]
{
	If[[a] < [b]]
	{
		min <- a
	}{
		min <- b
	}
}

Count Substring[string,substring:out]
{
	out <- Max[[[[string]Split[substring]]Length] - [1], 0]
}

_Key Value Join[dict,key,key sep,val sep,string:out]
{
	new string <- [[[string]Append[key]]Append[key sep]]Append[ [dict]Index[key] ]
	[dict]Next[key]
	{
		out <- _Key Value Join[dict, ~, key sep, val sep, [new string]Append[val sep]]
	}{
		out <- Val[new string]
	}
}

Key Value Join[dict,key sep,val sep:out]
{
	[dict]First
	{
		out <- _Key Value Join[dict, ~, key sep, val sep, ""]
	}{
		out <- ""
	}
}

_Combine[source,dest,key:out]
{
	new dest <- [dest]Set[key, [source]Index[key]]
	[source]Next[key]
	{
		out <- _Combine[source, new dest, ~]
	}{
		out <- Val[new dest]
	}
}

Combine[source,dest:out]
{
	[source]First
	{
		out <- _Combine[source, dest, ~]
	}{
		out <- dest
	}
}

_Fold[list,index,current,worker:out]
{
	newval <- [
		[worker]Do[  
			[[[()]Append[ current ]]Append[ [list]Index[index] ]]Append[index]
		]
	]Index[0]
	
	[list]Next[index]
	{
		out <- _Fold[list, ~, newval, worker]
	}{
		out <- Val[newval]
	}
}

Fold[worker,start,list:out]
{
	[list]First
	{
		out <- _Fold[list, ~, start, worker]
	}{
		out <- start
	}
}

_Zip[left,lindex,right,rindex,outlist:out]
{
	nlist <- [outlist]Append[
		[[()]Append[ [left]Index[lindex] ]]Append[ [right]Index[rindex] ]
	]
	nlindex <- [left]Next[lindex]
	{
		[right]Next[rindex]
		{
			out <- _Zip[left,nlindex,right,~,nlist]
		}{
			out <- Val[nlist]
		}
	}{
		out <- Val[nlist]
	}
}

Zip[left,right:out]
{
	lindex <- [left]First
	{
		Print[~]
		[right]First
		{
			Print[~]
			out <- _Zip[left,lindex,right,~,()]
		}{
			out <- ()
		}
	}{
		out <- ()
	}
}

_Dict Split[dict,entry,index,keydelim:out]
{
	parts <- [entry]Split[keydelim]
	out <- [dict]Set[[parts]Index[0],[parts]Index[1]]
}

Dict Split[string,keydelim,entrydelim:out]
{
	out <- Fold[["_Dict Split"]Set Input[3, keydelim], Dictionary[], [string]Split[entrydelim]] 
}

Previous@List[list,index:prev index,not found]
{
	prev <- [index] - [1]
	If[[prev] < [0]]
	{
		not found <- list
	}{
		[list]Index[prev]
		{
			prev index <- Val[prev]
		}{
			prev index, not found <- [list]Previous[prev]
		}
	}
}

Last@List[list:out,not found]
{
	out, not found <- [list]Previous[[list]Length]
}

_Reverse Fold[list,index,start,worker:out]
{
	newval <- [
		[worker]Do[  
			[[[()]Append[ start ]]Append[ [list]Index[index] ]]Append[index]
		]
	]Index[0]
	
	[list]Previous[index]
	{
		out <- _Reverse Fold[list, ~, newval, worker]
	}{
		out <- Val[newval]
	}
}

Reverse Fold[worker,start,list:out]
{
	[list]Last
	{
		out <- _Reverse Fold[list, ~, start, worker]
	}{
		out <- list
	}
}

_Join[list,delim,current,index:out]
{
	[list]Next[index]
	{
		out <- _Join[list, delim, [[current]Append[delim]]Append[[list]Index[~]], ~]
	}{
		out <- current
	}
}

Join[list,delim:out]
{
	[list]First
	{
		out <- _Join[list, delim, [list]Index[~], ~]
	}{
		out <- ""
	}
}

Replace[string,find,replace:replaced]
{
	replaced <- [[string]Split[find]]Join[replace]
}

Concatenate[left,right:out]
{
	out <- Fold[["Append"]<String@Worker, left, right]
}

Starts With[thing,starts with:out]
{
	out <- [[thing]Slice[[starts with]Length]] = [starts with]
}

Ends With[thing,ends with:out]
{
	,compare <- [thing]Slice[ [[thing]Length] - [[ends with]Length] ]
	out <- [compare] = [ends with]
}

As List@String[string:list]
{
	list <- [()]Append[string]
}

As List@List[in:out]
{
	out <- in
}

_Filter[list,index,worker,destlist:out]
{
	filter? <- [
		[worker]Do[  
			[()]Append[ [list]Index[index] ]
		]
	]Index[0]
	If[filter?]
	{
		newlist <- [destlist]Append[[list]Index[index]]
	}{
		newlist <- destlist
	}
	
	[list]Next[index]
	{
		out <- _Filter[list, ~, worker, newlist]
	}{
		out <- Val[newlist]
	}
}

Filter[list,worker:out]
{
	[list]First
	{
		out <- _Filter[list, ~, worker, ()]
	}{
		out <- list
	}
}

Pop@List[list:out]
{
	[list]Last
	{
		out <- [list]Remove[~]
	}{
		out <- list
	}
}

Peek@List[list:out,empty]
{
	[list]Last
	{
		out <- [list]Index[~]
	}{
		empty <- list
	}
}

Contains[haystack,needle:out]
{
	[haystack]Get DString[needle]
	{
		out <- Yes
	} {} {} {
		out <- No
	}
}

_Find[haystack,needle,index:outindex,notfound]
{
	If[[[haystack]Index[index]] = [needle]]
	{
		outindex <- index
	}{
		[haystack]Next[index]
		{
			outindex,notfound <- _Find[haystack,needle,~]
		}{
			notfound <- needle
		}	
	}
}

Find[haystack,needle:index,not found]
{
	[haystack]First
	{
		index,not found <- _Find[haystack, needle, ~]
	}{
		not found <- needle
	}

}

Get Pretty Print Value[value:print,index,print indent,done,out value]
{
	If[[Type Of[value]] = ["List"]]
	{
		out value <- value
		list <- value
		object <- value
	}{
		If[[Type Of[value]] = ["Dictionary"]]
		{
			out value <- value
			list <- value
			object <- value
		}{
			If[[Type Of[value]] = ["String"]]
			{
				out value <- value
				print <- value
				done <- 1
			}{
				If[[Type Of[value]] = ["Whole Number"]]
				{
					out value <- value
					print <- value
					done <- 1
				}{
					If[[Type Of[value]] = ["Yes No"]]
					{
						out value <- value
						print <- value
						done <- 1
					}{
						If[[Type Of[value]] = ["Real Number"]]
						{
							out value <- value
							print <- value
							done <- 1
						}{
							object <- value
							fieldlist <- [Blueprint Of[value]]Get Fields
							[fieldlist]First
							{
								list <- _Object to Dict[value, fieldlist, ~, Dictionary[]]
								out value <- Val[list]
							}{
								out value <- value
								done <- 1
							}
						}
					}
				}
			}
			
		}
	}
	print <- Type Of[object]
	index <- [list]First {}
	{
		print indent <- "{Empty}"
	}
	
}

Pretty Print Helper[list,tabs,index:out]
{
	newtabs <- [tabs]Append["    "]
	print,new index,indented,done,value <- Get Pretty Print Value[[list]Index[index]]
	Print[ [[[tabs]Append[index]]Append[": "]]Append[print] ]
	{
		done <- Pretty Print Helper[value,newtabs ,new index]
		done <- Print[[newtabs]Append[indented]]
		
		Val[done]
		{
			[list]Next[index]
			{
				out <- Pretty Print Helper[list, tabs, ~]
			}{
				out <- 1
			}
		}
	}
	
}

Pretty Print[toprint,tabs:out]
{
	newtabs <- [tabs]Append["    "]
	,index,indented,,value <- Get Pretty Print Value[toprint]
	{
		Print[[tabs]Append[~]]
		{
			Pretty Print Helper[value,newtabs ,index]
			Print[[newtabs]Append[indented]]
		}
	}
	out <- 1
}

_Object to Dict[object,field list,index,dict:out]
{
	field <- [field list]Index[index]
	[object]Get Field[field]
	{
		nextdict <- [dict]Set[field, ~]
	}{
		nextdict <- dict
	}
	[field list]Next[index]
	{
		out <- _Object to Dict[object, field list, ~, nextdict]
	}{
		out <- Val[nextdict]
	}
}

_Keys[list,val,key:out]
{
	out <- [list]Append[key]
}

Keys[container:out]
{
	out <- Fold["_Keys", (), container]
}

And[left,right:out]
{
	,out <- If[left]
	{
		out,out <- If[right]
	}
}

Or[left,right:out]
{
	out <- If[left] {}
	{
		out,out <- If[right]
	}
}

After[text,prefix:after,not found]
{
	If[[text]Starts With[prefix]]
	{
		,after <- [text]Slice[[prefix]Length]
	}{
		not found <- text
	}
}
 
Blueprint Range
{
	Start
	End
}

Range[start,end:out]
{
	out <- [[Build["Range"]]Start <<[start]]End <<[end]
}

First@Range[range:out,none]
{
	If[[[range]Start >>] < [[range]End >>]]
	{
		out <- [range]Start >>
	}{
		none <- range
	}
}

Next@Range[range,val:out,done]
{
	next <- [val]+[1]
	If[[next] < [[range]End >>]]
	{
		out <- Val[next]
	}{
		done <- range
	}
}

Index@Range[range,index:out,notfound]
{
	If[[index] < [[range]End >>]]
	{
		If[[index] < [[range]Start >>]]
		{
			notfound <- index
		}{
			out <- index
		}
	}{
		notfound <- index
	}
}

Tail[list,start:out]
{
	newlist <- New Like[list]
	[list]Index[start]
	{
		out <- _Fold[list, start, newlist, "Append"]
	}{
		out <- Val[newlist]
	}
}

_Collection =[col1,key1,col2,key2:out]
{
	,out <- If[[key1]=[key2]]
	{
		,out <- If[[[col1]Index[key1]] = [[col2]Index[key2]]]
		{
			nkey1 <- [col1]Next[key1]
			{
				[col2]Next[key2]
				{
					out <- _Collection =[col1,nkey1,col2,~]
				}{
					out <- No
				}
			}{
				[col2]Next[key2]
				{
					out <- No
				}{
					out <- Yes
				}
			}
		}
	}
}

Collection =[col1,col2:out]
{
	first1 <- [col1]First
	{
		[col2]First
		{
			out <- _Collection =[col1, first1, col2, ~]
		}{
			out <- No
		}
	}{
		[col2]First
		{
			out <- No
		}{
			out <- Yes
		}
	}
}

=@List[list1,list2:out]
{
	,out <- If[[[list1]Length >>] = [[list2]Length >>]]
	{
		out <- Collection =[list1,list2]
	}
}

=@Dictionary[list1,list2:out]
{
	,out <- If[[[list1]Length >>] = [[list2]Length >>]]
	{
		out <- Collection =[list1,list2]
	}
}