/**
 * Register a binding with the container.
 * Register a binding with the container.
 * @param  string|array  $abstract
 * @param  \Closure|string|null  $concrete
 * @param  bool  $shared
 * @return void
 */
public function bind($abstract, $concrete = null, $shared = false)
{// bind abstract con
    $abstract = $this->normalize($abstract);// get the right normalize

    $concrete = $this->normalize($concrete);// get the right concrete

    // If the given types are actually an array, we will assume an alias is being
    // defined and will grab this "real" abstract class name and register this
    // alias with the container so that it can be used as a shortcut for it.

 // now i say,if they give us a array use a types.
 // so we need do something for it,
 // if the "real" abstract class name is too long,
 // we can use alias to defined the real class name as a shortcut name.

    if (is_array($abstract)) {// check the abstract name is a array
        list($abstract, $alias) = $this->extractAlias($abstract);// a array one is abstract , other is alias

        $this->alias($abstract, $alias);// return the result to the alias.
    }

    // If no concrete type was given, we will simply set the concrete type to the
    // abstract type. This will allow concrete type to be registered as shared
    // without being forced to state their classes in both of the parameter.

 // i coming ,if never give us a concrete type class, we will use a abstract type.
 // so they will be registered as shared .
 // no forced to state their classes in both of the parameter
    $this->dropStaleInstances($abstract);// then can drop the state Instances.

    if (is_null($concrete)) {
        $concrete = $abstract;
    }// if the concrete is null

    // If the factory is not a Closure, it means it is just a class name which is
    // bound into this container to the abstract type and we will just wrap it
    // up inside its own Closure to give us more convenience when extending.

 // if the instance of concrete not a Closure.
 // so it means it just a class name be used bound to a container.
 // may be it is a abstract type .
 // so we can use that self own Closure to wrap it.
 // to give us more function when it extending
    if (! $concrete instanceof Closure) {
        $concrete = $this->getClosure($abstract, $concrete);
    }// get the Closure, more like hook

    $this->bindings[$abstract] = compact('concrete', 'shared');// a shared

    // If the abstract type was already resolved in this container we'll fire the
    // rebound listener so that any objects which have already gotten resolved
    // can have their copy of the object updated via the listener callbacks.

 // if the class name is ready resolved in the container.
 // so we will fire the rebound listener .
 // so that any objects which have already gotten resolved can have their copy
 // via the listener callbacks
    if ($this->resolved($abstract)) {// has the resolved
        $this->rebound($abstract);// set the rebound
    }
}// too long too not simple