A little "infile" Asynchronous Module Definition I like the modular aspect of AMDs (Asynchronous Module Definition; see this Stack Overflow reply) and it's quite neat to structure JS.

But I typically compile all my JS files into one JS file. Therefore I don't really need the asynchronous part. So I thought I could quickly write such "infile" Module Loader.

var load=(function()
{
  var modules={};
  return function(moduleName,dependencies,module)
  {
    if(moduleName.constructor===Array)
    {
      module=dependencies;
      dependencies=moduleName;
      moduleName=undefined;
    }
    if(!((moduleName&amp;&amp;moduleName.constructor===String||moduleName===undefined)
         &amp;&amp; dependencies&amp;&amp;dependencies.constructor===Array
         &amp;&amp; module&amp;&amp;module.constructor===Function))
      throw "wrong usage";
    var ret = module.apply(null,
      dependencies.map(function(d){return modules[d]||(function(){throw "no module "+d})()})
    );
    if(moduleName)
    {
      if(!ret||ret.constructor!==Object) throw "module should be an object";
      modules[moduleName]=ret;
    }
  }
})();

load('utils',[],function(){return {veryUseful:function(){alert('hey')}}});
load(['utils'],function(utils){utils.veryUseful()});


load is used on one way to define a module and on an other way to call a function with the required modules passed as function arguments.

Demo

The goal here is to allow one to have two pieces of code written in the same file that are guaranteed to be independent.

I'm curious if you have any suggestions on any level. From the concept of such "infile" Module Loader to a hidden neat little JS feature.
I re-read your code several things, I can't say I would want to use it.


Requiring the parameters to be modules seems neat with 1 module or 2. For larger applications, that would become silly.
The most common use case with require is var xxx = load("Xxx") but you do not provide anything of the sort, in fact, load does not return anything
Having load being called in 2 different ways with 2 different ways of execution is wrong, I would suggest to simply use 2 different functions.
Consider rewriting the if block for "wrong usage" with falsey values and/or add some comment, it is pretty much unreadable now


At the very least I would modify the apply call to a call call, so that this has all the modules :

var ret = module.call(modules);

which makes for 

load('utils',[],function(){return {veryUseful:function(){alert('hey')}}});
load(['utils'],function(){this.utils.veryUseful()});


and return ret in case the caller wants to work with the module directly.