private final Class<R> type;
    private final BiFunction<? super A, ? super B, ? extends R> combiner;
    private final ProviderInternal<A> left;
    private final ProviderInternal<B> right;

    public BiProvider(@Nullable Class<R> type, Provider<A> left, Provider<B> right, BiFunction<? super A, ? super B, ? extends R> combiner) {
        this.type = type;
        this.combiner = combiner;

            Value<? extends V> value = providerOfValue.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            collector.add(key, value.getWithoutSideEffect(), dest);
            return Value.present().withSideEffect(SideEffect.fixedFrom(value));
        }

        @Override

   license that can be found in the LICENSE file.  */

/* A trivial example of wrapping a C library using SWIG.  */

%{
#include <stdio.h>
#include <stdlib.h>
%}

%typemap(gotype) const char * "string"
%typemap(in) const char * %{
	$1 = malloc($input.n + 1);
	memcpy($1, $input.p, $input.n);
	$1[$input.n] = '\0';
%}
%typemap(freearg) const char * %{
	free($1);
%}

                            final Map<String, String> indexObj = dataObj.get("index");
                            if (indexObj != null) {
                                if (indexObj.containsKey("_type")) {
                                    indexObj.remove("_type");
                                }
                                final String index = indexObj.get("_index");
                                if (index != null) {

        static <T> Value<T> ofNullable(@Nullable T value) {
            if (value == null) {
                return MISSING.asType();
            }
            return new Present<>(value);
        }

        static <T> Value<T> missing() {
            return MISSING.asType();
        }

        static <T> Value<T> of(T value) {
            if (value == null) {

// A typeSwitch walks a type switch.
type typeSwitch struct {
	// Temporary variables (i.e., ONAMEs) used by type switch dispatch logic:
	srcName  ir.Node // value being type-switched on
	hashName ir.Node // type hash of the value being type-switched on
	okName   ir.Node // boolean used for comma-ok type assertions
	itabName ir.Node // itab value to use for first word of non-empty interface
}

type typeClause struct {
	hash uint32

Benjamin Bentmann <******@****.***> 1243457293 +0000

			if pname, ptype := extractName(x, p.tok == _Comma); pname != nil && (ptype != nil || p.tok != _Rbrack) {
				// d.Name "[" pname ...
				// d.Name "[" pname ptype ...
				// d.Name "[" pname ptype "," ...
				d.TParamList = p.paramList(pname, ptype, _Rbrack, true) // ptype may be nil
				d.Alias = p.gotAssign()
				d.Type = p.typeOrNil()
			} else {
				// d.Name "[" pname "]" ...
				// d.Name "[" x ...

        try (EvaluationContext.ScopeContext context = openScope()) {
            Value<? extends T> value = provider.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            return doMapValue(context, value).calculateValue(consumer);
        }
    }

                throw new IllegalArgumentException(String.format("Cannot set the %s of a property of type %s with key type %s and value type %s " +
                        "using a provider with key type %s and value type %s.", valueKind, Map.class.getName(), keyType.getName(), valueType.getName(),
                    providerKeyType.getName(), providerValueType.getName()));
            }