# STATUS: Unfinished

# Type = require "./Type"
# ArrayOf = require "./ArrayOf"

# # Example:
# # 	merge = Merger { unsafe: true }
# # 	merge target, source1, source2, source3

# Merger = Type

# 	name: "Merger"

# 	kind: Function

# 	init: (options) ->
# 		return @merge

# 	options:
		
# 		types:
# 			unsafe: Boolean
# 			recursive: Boolean
# 			include: ArrayOf String
# 			exclude: ArrayOf String
		
# 		defaults:
# 			unsafe: false
# 			recursive: true

# 	internal:
		
# 		merge: (sources...) ->
# 			target = sources.shift()
# 			@mergeInto target, source for source in sources
# 			return target

# 		mergeInto: (target, source) ->
# 			# Handle arguments being sources
# 			if Object.isTypeOf source
# 				if @recursive then mergeDeep target, source
# 				else transfer target, key, value for key, value of source
# 			# Handle arguments being Arrays of sources
# 			else if Array.isTypeOf source
# 				@merge target, source for source in (sources = source)

# 		mergeDeep: (target, source) ->
# 			for key, val of source
# 				if Type.of(val).is(Object) and Type.of(target[key]).is(Object)
# 					_deepMerge write, target, key, val
# 				else 
# 					write target, key, val

# 		transfer: (target, key, value) ->
# 			target[key] = val if @unsafe


# _createMergeStrategy = (options) ->
# 	write = if options.safe then _safeWrite else _unsafeWrite
# 	return if options.deep then _deepMerge.bind(null, write) else write

# _createIgnoreStrategy = (options) ->


# _safeWrite = (target, key, val) ->
# 	target[key] = val if target[key] is undefined

# _unsafeWrite = (target, key, val) ->
# 	target[key] = val

# _shallowMerge = (write, target, key, val) ->
# 	write target, key, val

# _deepMerge = (write, target, key, val) ->
# 	if Type.of(val).is(Object) and Type.of(target[key]).is(Object)
# 		_deepMerge write, target, key, val
# 	else 
# 		write target, key, val