code: function isConstructorLike(func){
  	/* jshint unused: false */
  	// if you can new it ... it's a constructor
  	var value = func[canSymbol.for("can.new")];
  	if(value !== undefined) {
  		return value;
  	}
  
  	if(typeof func !== "function") {
  		return false;
  	}
  	// If there are any properties on the prototype that don't match
  	// what is normally there, assume it's a constructor
  	var prototype = func.prototype;
  	if(!prototype) {
  		return false;
  	}
  	// Check if the prototype's proto doesn't point to what it normally would.
  	// If it does, it means someone is messing with proto chains
  	if( plainFunctionPrototypeProto !== Object.getPrototypeOf( prototype ) ) {
  		return true;
  	}
  
  	var propertyNames = Object.getOwnPropertyNames(prototype);
  	if(propertyNames.length === plainFunctionPrototypePropertyNames.length) {
  		for(var i = 0, len = propertyNames.length; i < len; i++) {
  			if(propertyNames[i] !== plainFunctionPrototypePropertyNames[i]) {
  				return true;
  			}
  		}
  		return false;
  	} else {
  		return true;
  	}
  }
docs: @function can-reflect.isConstructorLike isConstructorLike
  @parent can-reflect/type
  
  @description Test if a value looks like a constructor function.
  
  @signature `isConstructorLike(func)`
  
  Return `true` if `func` is a function and has a non-empty prototype, or implements
  [can-symbol/symbols/new `@@@@can.new`]; `false` otherwise.
  
  ```js
  canReflect.isConstructorLike(function() {}); // -> false
  
  function Construct() {}
  Construct.prototype = { foo: "bar" };
  canReflect.isConstructorLike(Construct); // -> true
  
  canReflect.isConstructorLike({}); // -> false
  !!canReflect.isConstructorLike({ [canSymbol.for("can.new")]: function() {} }); // -> true
  ```
  
  @param  {*}  func maybe a function
  @return {Boolean} `true` if a constructor; `false` if otherwise.