.toType(implementationType)
            .fromCharSequence(new DependencyStringNotationConverter<>(instantiator, implementationType, stringInterner))
            .converter(new DependencyMapNotationConverter<>(instantiator, implementationType))
            .invalidNotationMessage("Comprehensive documentation on dependency notations is available in DSL reference for DependencyHandler type.")
            .toComposite();
    }

        ProviderNotationConverter providerNotationConverter = new ProviderNotationConverter();

        NotationParser<Object, MavenArtifact> sourceNotationParser = NotationParserBuilder
            .toType(MavenArtifact.class)
            .fromType(Provider.class, Cast.uncheckedCast(providerNotationConverter))
            .fromType(AbstractArchiveTask.class, archiveTaskNotationConverter)

        ProviderNotationConverter providerNotationConverter = new ProviderNotationConverter();

        NotationParser<Object, IvyArtifact> sourceNotationParser = NotationParserBuilder
                .toType(IvyArtifact.class)
                .fromType(Provider.class, Cast.uncheckedCast(providerNotationConverter))
                .converter(archiveTaskNotationConverter)
                .converter(publishArtifactNotationConverter)

	writeMsgSyscallName = "sendmsg"
)

func newFD(sysfd, family, sotype int, net string) (*netFD, error) {
	ret := &netFD{
		pfd: poll.FD{
			Sysfd:         sysfd,
			IsStream:      sotype == syscall.SOCK_STREAM,
			ZeroReadIsEOF: sotype != syscall.SOCK_DGRAM && sotype != syscall.SOCK_RAW,
		},
		family: family,
		sotype: sotype,
		net:    net,
	}
	return ret, nil
}

func (fd *netFD) init() error {

    final ImmutableModuleIdentifierFactory moduleIdentifierFactory = Mock() {
        module(_, _) >> { args ->
            DefaultModuleIdentifier.newId(*args)
        }
    }
    @Subject parser = NotationParserBuilder.toType(ModuleIdentifier).fromCharSequence(new ModuleIdentifierNotationConverter(moduleIdentifierFactory)).toComposite()

    def "parses module identifier notation"() {
        expect:

// Sockets maps a socket descriptor to the status of socket.
type Sockets map[int]Status

func (sw *Switch) sockso(s int) *Status {
	sw.smu.RLock()
	defer sw.smu.RUnlock()
	so, ok := sw.sotab[s]
	if !ok {
		return nil
	}
	return &so
}

// addLocked returns a new Status without locking.
// sw.smu must be held before call.
func (sw *Switch) addLocked(s, family, sotype, proto int) *Status {
	sw.once.Do(sw.init)

import org.gradle.util.internal.WrapUtil
import spock.lang.Specification

class ExcludeRuleNotationConverterTest extends Specification {
    def parser = NotationParserBuilder.toType(ExcludeRule).converter(new ExcludeRuleNotationConverter()).toComposite()

    def "with group"() {
        when:
        ExcludeRule d = parser.parseNotation([group: 'aGroup']);
        then:
        d != null;

                while (param != null && toParam < parameterTypes.length) {
                    Class<?> toType = parameterTypes[toParam];
                    if (toType.isPrimitive()) {
                        toType = JavaReflectionUtil.getWrapperTypeForPrimitiveType(toType);
                    }
                    if (toType.isInstance(param)) {
                        break;
                    }
                    toParam++;

    public static <T> NotationParserBuilder<Object, T> toType(Class<T> resultingType) {
        return new NotationParserBuilder<>(Object.class, new TypeInfo<>(resultingType));
    }

    public static <T> NotationParserBuilder<Object, T> toType(TypeInfo<T> resultingType) {
        return new NotationParserBuilder<>(Object.class, resultingType);
    }

        this.factory = factory;
    }

    public ProjectDependency createFromMap(ProjectFinder projectFinder, Map<? extends String, ?> map) {
        return NotationParserBuilder.toType(ProjectDependency.class)
                .converter(new ProjectDependencyMapNotationConverter(projectFinder, factory)).toComposite().parseNotation(map);
    }