 
   # Reject arrays as objects
   isOnlyObject: (o) -> return _.isObject(o) and not _.isArray(o)
+
+  # Create new array with the value of these arrays
+  concatenate: (rest...) -> _.flatten(rest, true)
 
   # Logging functions could be used later 
   logError: (x) -> console.error(x)

      paramValue.set(evaluatedParams[paramName])

    # return result and patches, if any
    return [result, model.makePatches(modelData)]

  calculateBindingSet: (modelData, assets, oldBindings, bindingLayout) ->
    bindingSet = []

    # TODO: multiply from values together in order to make every combination
    if "from" of bindingLayout
      for bindingName, bindingExpression of bindingLayout.from
        # Evaluate values of the "from" clauses
        # TODO: in the case of models, get reference to model rather than evaluate the data here
        bindingValues = GE.compileParameter(modelData, assets, oldBindings, bindingExpression).get()
        for bindingIndex in [0..bindingValues.length - 1]
          # Avoid polluting old object, and avoid creating new properties
          newBindings = Object.create(oldBindings)

          layoutParameter = "#{bindingKey}#{layoutParameter.slice(endChar)}" 
        else
          # WRONG: This is a hack, but will not work for more complex expressions
          return GE.makeConstantEvaluator(constants, bindingKey)

      if layoutParameter[0] == "@"
        # The argument is optional
        # TODO: include multiple arguments? As list or map?
        [matcherName, argument] = layoutParameter.slice(1).split(":")
        if not matcherName of GE.parameterEvaluators
          throw new Error("Cannot handle evaluator #{matcherName}")
        return GE.parameterEvaluators[matcherName](constants, argument)

    # Return as a constant value
    return GE.makeConstantEvaluator(layoutParameter)
