JSONAPI/Sources/JSONAPITesting/Attribute+Literal.swift

import JSONAPI

extension Attribute: ExpressibleByUnicodeScalarLiteral where RawValue: ExpressibleByUnicodeScalarLiteral {
	public typealias UnicodeScalarLiteralType = RawValue.UnicodeScalarLiteralType

	public init(unicodeScalarLiteral value: RawValue.UnicodeScalarLiteralType) {
		self.init(value: RawValue(unicodeScalarLiteral: value))
	}
}

extension Attribute: ExpressibleByExtendedGraphemeClusterLiteral where RawValue: ExpressibleByExtendedGraphemeClusterLiteral {
	public typealias ExtendedGraphemeClusterLiteralType = RawValue.ExtendedGraphemeClusterLiteralType

	public init(extendedGraphemeClusterLiteral value: RawValue.ExtendedGraphemeClusterLiteralType) {
		self.init(value: RawValue(extendedGraphemeClusterLiteral: value))
	}
}

extension Attribute: ExpressibleByStringLiteral where RawValue: ExpressibleByStringLiteral {
	public typealias StringLiteralType = RawValue.StringLiteralType

	public init(stringLiteral value: RawValue.StringLiteralType) {
		self.init(value: RawValue(stringLiteral: value))
	}
}

extension Attribute: ExpressibleByNilLiteral where RawValue: ExpressibleByNilLiteral {
	public init(nilLiteral: ()) {
		self.init(value: RawValue(nilLiteral: ()))
	}
}

extension Attribute: ExpressibleByFloatLiteral where RawValue: ExpressibleByFloatLiteral {
	public typealias FloatLiteralType = RawValue.FloatLiteralType

	public init(floatLiteral value: RawValue.FloatLiteralType) {
		self.init(value: RawValue(floatLiteral: value))
	}
}

extension Optional: ExpressibleByFloatLiteral where Wrapped: ExpressibleByFloatLiteral {
	public typealias FloatLiteralType = Wrapped.FloatLiteralType

	public init(floatLiteral value: FloatLiteralType) {
		self = .some(Wrapped(floatLiteral: value))
	}
}

extension Attribute: ExpressibleByBooleanLiteral where RawValue: ExpressibleByBooleanLiteral {
	public typealias BooleanLiteralType = RawValue.BooleanLiteralType

	public init(booleanLiteral value: BooleanLiteralType) {
		self.init(value: RawValue(booleanLiteral: value))
	}
}

extension Optional: ExpressibleByBooleanLiteral where Wrapped: ExpressibleByBooleanLiteral {
	public typealias BooleanLiteralType = Wrapped.BooleanLiteralType

	public init(booleanLiteral value: BooleanLiteralType) {
		self = .some(Wrapped(booleanLiteral: value))
	}
}

extension Attribute: ExpressibleByIntegerLiteral where RawValue: ExpressibleByIntegerLiteral {
	public typealias IntegerLiteralType = RawValue.IntegerLiteralType

	public init(integerLiteral value: IntegerLiteralType) {
		self.init(value: RawValue(integerLiteral: value))
	}
}

extension Optional: ExpressibleByIntegerLiteral where Wrapped: ExpressibleByIntegerLiteral {
	public typealias IntegerLiteralType = Wrapped.IntegerLiteralType

	public init(integerLiteral value: IntegerLiteralType) {
		self = .some(Wrapped(integerLiteral: value))
	}
}

// regretably, array and dictionary literals are not so easy because Dictionaries and Arrays
// cannot be turned back into variadic arguments to pass onto the RawValue type's constructor.

// we can still provide a case for the Array and Dictionary types, though.
public protocol DictionaryType {
	associatedtype Key: Hashable
	associatedtype Value

	init<S>(_ keysAndValues: S, uniquingKeysWith combine: (Dictionary<Key, Value>.Value, Dictionary<Key, Value>.Value) throws -> Dictionary<Key, Value>.Value) rethrows where S : Sequence, S.Element == (Key, Value)
}
extension Dictionary: DictionaryType {}

extension Attribute: ExpressibleByDictionaryLiteral where RawValue: DictionaryType {
	public typealias Key = RawValue.Key

	public typealias Value = RawValue.Value

	public init(dictionaryLiteral elements: (RawValue.Key, RawValue.Value)...) {

		// we arbitrarily keep the first value if two values are assigned to the same key
		self.init(value: RawValue(elements, uniquingKeysWith: { val, _ in val }))
	}
}

extension Optional: DictionaryType where Wrapped: DictionaryType {
	public typealias Key = Wrapped.Key

	public typealias Value = Wrapped.Value

	public init<S>(_ keysAndValues: S, uniquingKeysWith combine: (Dictionary<Key, Value>.Value, Dictionary<Key, Value>.Value) throws -> Dictionary<Key, Value>.Value) rethrows where S : Sequence, S.Element == (Key, Value) {
		self = try .some(Wrapped(keysAndValues, uniquingKeysWith: combine))
	}
}

public protocol ArrayType {
	associatedtype Element

	init<S>(_ s: S) where Element == S.Element, S : Sequence
}
extension Array: ArrayType {}
extension ArraySlice: ArrayType {}

extension Attribute: ExpressibleByArrayLiteral where RawValue: ArrayType {
	public typealias ArrayLiteralElement = RawValue.Element

	public init(arrayLiteral elements: ArrayLiteralElement...) {
		self.init(value: RawValue(elements))
	}
}

extension Optional: ArrayType where Wrapped: ArrayType {
	public typealias Element = Wrapped.Element

	public init<S>(_ s: S) where Element == S.Element, S : Sequence {
		self = .some(Wrapped(s))
	}
}