def runtimeFailure = new RuntimeException("Runtime exception")

        expect:
        Try.ofFailable { throw failure } == Try.failure(failure)
        Try.ofFailable { throw runtimeFailure } == Try.failure(runtimeFailure)
    }

    def "captures result"() {
        expect:
        Try.ofFailable { result } == Try.successful(result)

        where:
        result << [['a', 'b', 'c'], "Some string", 5]
    }

        }

        @Override
        public T get() {
            return result().get();
        }

        private Try<T> result() {
            if (result == null) {
                result = Try.ofFailable(computation);
                computation = null;
            }
            return result;
        }

        private Object writeReplace() {
            return new Fixed<>(result());
        }
    }

     * If the callable returns null, then the returned Try instance will hold null as its value.
     */
    public static <U> Try<U> ofFailable(Callable<U> failable) {
        try {
            return Try.successful(failable.call());
        } catch (Exception e) {
            return Try.failure(e);
        }
    }

    /**
     * Construct a {@code Try} representing a successful execution.

                    return;
                }
                done = true;

                // Attach result and discard calculation state
                owner.result = Try.ofFailable(() -> {
                    NodeExecutionContext effectiveContext = context;
                    if (effectiveContext == null) {
                        effectiveContext = new GlobalContext(defaultContext);

    private List<Try<ProjectReportModel>> computeProjectModels() {
        List<Try<ProjectReportModel>> result = new ArrayList<>();
        for (Project project : new TreeSet<>(getProjects())) {
            result.add(Try.ofFailable(() -> projectReportModelFor(project)));
        }
        return result;
    }

    private static class TaskReportModel {
        final List<Try<ProjectReportModel>> projects;

        CacheableWork cacheableWork = new CacheableWork(context.getIdentity().getUniqueId(), context.getWorkspace(), work);
        return Try.ofFailable(() -> work.isAllowedToLoadFromCache()
                ? tryLoadingFromCache(cacheKey, cacheableWork)
                : Optional.<BuildCacheLoadResult>empty()
            )
            .map(successfulLoad -> successfulLoad

            ? new InputState.ComponentMissing(publicationName())
            : new InputState.Ready(moduleMetadataSpec());
    }

    private Try<ModuleMetadataSpec> moduleMetadataSpec() {
        return Try.ofFailable(this::computeModuleMetadataSpec);
    }

    private ModuleMetadataSpec computeModuleMetadataSpec() {
        PublicationInternal<?> publication = publication();

        given:
        def provider = registerService("failed", BrokenServiceImpl)
        Consumer<Object> action = Mock()
        provider.beforeStopping(action)

        Try.ofFailable { provider.get() }

        when:
        buildFinished()

        then:
        1 * action.accept(provider)
    }

        return createNestedBuildTree("$path:${projectDir.name}", startParameter, services).run { controller ->
            controller.withEmptyBuild { settings ->
                Try.ofFailable {
                    val gradle = settings.gradle
                    val baseScope = classLoaderScopeRegistry.coreAndPluginsScope.createChild("accessors-classpath", null).apply {

  LogicalResult matchAndRewrite(FakeQuantOp op,
                                PatternRewriter &rewriter) const override {
    // TODO: If this pattern comes up more frequently, consider adding core
    // support for failable rewrites.
    if (failableRewrite(op, rewriter)) {
      *hadFailure = true;
      return failure();
    }
    return success();
  }

 private:
  bool *hadFailure;