Separate this function into another utils library.
171294
function (ent) {
    if (ent.constructor.name === 'Array') {
      serializeArray()
    } else {
      profile.default[ent.constructor.name] = ent
    }
  }
301479
def separation(self,ra,dec):
        """"""

        import ephem
        return ephem.separation((self.ra,self.dec),(ra,dec))
378514
def declallvars(self):
        """"""
        for f in self.body:
            if (hasattr(f, '_ctype')
                    and not isinstance(f._ctype, FuncType)):
                yield f
332525
def copy_from(self, other):
        """"""
        self.verbose, self.quiet, self.path, self.name, self.tracing = other.verbose, other.quiet, other.path, other.name, other.tracing
989280
def include_original(dec):
    """"""
    def meta_decorator(method):
        """Yo dawg, I heard you like decorators..."""
        # pylint: disable=protected-access
        decorator = dec(method)
        decorator._original = method
        return decorator
    return meta_decorator
755974
protected void simplifyLibrary(INode module)
	{
		List<PDefinition> defs = null;

		if (module instanceof SClassDefinition)
		{
			defs = ((SClassDefinition) module).getDefinitions();
		} else if (module instanceof AModuleModules)
		{
			defs = ((AModuleModules) module).getDefs();
		} else
		{
			// Nothing to do
			return;
		}

		for (PDefinition def : defs)
		{
			if (def instanceof SOperationDefinition)
			{
				SOperationDefinition op = (SOperationDefinition) def;

				op.setBody(new ANotYetSpecifiedStm());
				op.setPrecondition(null);
				op.setPostcondition(null);
			} else if (def instanceof SFunctionDefinition)
			{
				SFunctionDefinition func = (SFunctionDefinition) def;

				func.setBody(new ANotYetSpecifiedExp());
				func.setPrecondition(null);
				func.setPostcondition(null);
			}
		}
	}
215207
def compose(*funcs):
    """"""
    return lambda x: reduce(lambda v, f: f(v), reversed(funcs), x)
523523
def separate_resources(self):
        # type: () -> None
        
        self._separate_hdxobjects(self.resources, 'resources', 'name', hdx.data.resource.Resource)
59182
static Function<Optional<Descriptor>, String> concat(
      final Function<? super Optional<Descriptor>, String> function1,
      final Function<? super Optional<Descriptor>, String> function2) {
    return new Function<Optional<Descriptor>, String>() {
      @Override
      public String apply(Optional<Descriptor> optDescriptor) {
        return function1.apply(optDescriptor) + function2.apply(optDescriptor);
      }
    };
  }
816332
function wrappedOrigCall(orgFunc, newFunc) {
    return function() {
        var args = [].slice.call(arguments);
        try { orgFunc.apply(WinConsole, args); } catch (e) {}
        try { newFunc.apply(console,    args); } catch (e) {}
    };
}
50501
public FunctionList union(FunctionList that) {
        Set<Function> combined = new LinkedHashSet<Function>();
        combined.addAll(Arrays.asList(this.functions));
        combined.addAll(Arrays.asList(that.functions));
        return new FunctionList(combined);
    }
189848
def unbare_repo(func):
    """"""

    @wraps(func)
    def wrapper(self, *args, **kwargs):
        if self.repo.bare:
            raise InvalidGitRepositoryError("Method '%s' cannot operate on bare repositories" % func.__name__)
        # END bare method
        return func(self, *args, **kwargs)
    # END wrapper
    return wrapper
489304
def split_interface(intf_name):
    """"""
    head = intf_name.rstrip(r"/\0123456789. ")
    tail = intf_name[len(head) :].lstrip()
    return (head, tail)
481548
def copydoc(fromfunc, sep="\n"):
    
    def _decorator(func):
        sourcedoc = fromfunc.__doc__
        if func.__doc__ is None:
            func.__doc__ = sourcedoc
        else:
            func.__doc__ = sep.join([sourcedoc, func.__doc__])
        return func
    return _decorator
1048150
function copyLess() {
  return gulp.src(['./src/app/**/*.less'].concat(globalExcludes))
    .pipe(rename({dirname: ''}))
    .pipe(gulp.dest(libraryDist + '/dist/less'));
}
973404
def separate(self):
        '''

        '''
        collections = []
        start = None
        end = None

        for index in self.indexes:
            if start is None:
                start = index
                end = start
                continue

            if index != (end + 1):
                collections.append(
                    Collection(self.head, self.tail, self.padding,
                               indexes=set(range(start, end + 1)))
                )
                start = index

            end = index

        if start is None:
            collections.append(
                Collection(self.head, self.tail, self.padding)
            )
        else:
            collections.append(
                Collection(self.head, self.tail, self.padding,
                           indexes=range(start, end + 1))
            )

        return collections
1164693
def bust_self(self, obj):
        
        if self.func.__name__ in obj.__dict__:
            delattr(obj, self.func.__name__)