 }
 
 /// Loads the Cartfile for the given dependency, at the given version.
-private func cartfileForDependency(dependency: Dependency<PinnedVersion>) -> ColdSignal<Cartfile> {
+private func cartfileForDependency(dependency: Dependency<PinnedVersion>) -> SignalProducer<Cartfile, CarthageError> {
 	let repositoryURL = repositoryFileURLForProject(dependency.project)
 
 	return contentsOfFileInRepository(repositoryURL, CarthageProjectCartfilePath, revision: dependency.version.commitish)
-		.catch { _ in .empty() }
-		.tryMap { Cartfile.fromString($0) }
+		|> catch { _ in .empty }
+		|> tryMap { Cartfile.fromString($0) }
 }
 
 /// Returns the URL that the project's remote repository exists at.

	///
	/// This will automatically clone or fetch the project's repository as
	/// necessary.
	private func versionsForProject(project: ProjectIdentifier) -> ColdSignal<PinnedVersion> {
		let fetchVersions = cloneOrFetchDependency(project)
			.map { repositoryURL in listTags(repositoryURL) }
			.merge(identity)
			.map { PinnedVersion($0) }
			.on(next: { self.addCachedVersion($0, forProject: project) })

		return readCachedVersions()
			.map { versionsByProject -> ColdSignal<PinnedVersion> in
				if let versions = versionsByProject[project] {
					return .fromValues(versions)
				} else {
					return fetchVersions
				}
			}
			.merge(identity)
	}

	/// Attempts to resolve a Git reference to a version.
	private func resolvedGitReference(project: ProjectIdentifier, reference: String) -> ColdSignal<PinnedVersion> {
		// We don't need the version list, but this takes care of
		// cloning/fetching for us, while avoiding duplication.
		return versionsForProject(project)
			.then(resolveReferenceInRepository(repositoryFileURLForProject(project), reference))
			.map { PinnedVersion($0) }
	}

	/// Attempts to determine the latest satisfiable version of the project's


	/// Runs the given Git operation, blocking the `gitOperationScheduler` until
	/// it has completed.
	private func runGitOperation<T, Error>(operation: SignalProducer<T, Error>) -> SignalProducer<T, Error> {
		return SignalProducer { observer, disposable in
				let schedulerDisposable = self.gitOperationScheduler.schedule {
					let results = operation
						|> reduce([]) { $0 + [ $1 ] }
						|> single
					
					if disposable.disposed {
						return
					}

					switch results! {
					case let .Success(values):
						for value in values.unbox {
							sendNext(observer, value)
						}
						
						sendCompleted(observer)

					case let .Failure(error):
						sendError(observer, error.unbox)
					}
				}

				disposable.addDisposable(schedulerDisposable)
			}
			|> observeOn(QueueScheduler())
	}

	/// Clones the given dependency to the global repositories folder, or fetches
