// instead of this:
  myType t(getMyType); // pick/move
  myType t(getMyType, 1); // copy

// Should do one of these for copy:
  myType t(copy(getMyType));
    // possibly renamed from copy,
    // but a single argument, copy should do nothing but return
    // something like _copy<myType> that just contains a
    // reference, yes, reference to MyType, which would call a
    // constructor specialized on that _copy<myType> type or so.

// Or this way:
  myType t(getmyTpe(), COPY);
    // where COPY is just a struct _COPY{}; static _COPY COPY;
    // or so, empty, etc...

mytype t(move(getMyType()));

  upp::Vector<int> vi;
  upp::String s("1,2,3,42");
  boost::spirit::parse(start(s), end(s), int_%',', vi);
  // vi now contains {1, 2, 3, 42}
  // And spirit expressions can be complex enough that there is
  // even one that can parse a C-style language and more.

  template<typename cbType> void mapInts(Vector<int> &v, cbType cb)
  { // assuming foreach exists
    foreach(int &i, v) cb(i);
  }

  // Hmm, lets make one for something else too
  struct myType {int i; float f;} // assume this is properly exposed to Boost too
  typename boost::fusion::vector<int,float> myTuple;

  template<typename T, typename cbType> void map(Vector<T> &v, cbType cb)
  { // assuming foreach exists
    foreach(T &i, v) cb(i);
  }

  // And how to use Phoenix in a situation like this,
  // and Phoenix is *very* generically useful:
  Vector<int> v = {1,2,3,4,5}; // assuming this supports C++1x init lists for ease of reading
  Vector<int> v1(v,1); // copy
  Vector<int> v2(v,1); // copy
  Vector<int> v3(v,1); // copy
  mapInts(v1, arg1*=2);
  mapInts(v2, if_(!(arg1%2))[arg1/=2].else[arg1=0]);
  mapInts(v3, let(_a=arg1)[
                while_(--arg1)[
                  _a+=arg1
                ]
                ,arg1=_a
              ]);
  assert(v1 == {2,4,6,8,10});
  assert(v2 == {0,1,0,2,0};
  assert(v3 == {1,3,6,10,15};

  myType ty(42,3.14);
  myTuple tu(2,3.4);
  map(ty, arg1*=2);
  map(tu, arg1/=2);
  assert(ty == myType(84, 6.28)); // assuming the floats compare equally
  assert(tu == myTuple(1, 1.95)); // assuming the floats compare equally

  std::function<void(int&)> f1(arg1*=2);
  std::function<int(int)> f2(arg1*2);
  std::function<int(int,float,std::string)> f3(((COUT()<<arg3<<arg2<<arg1<<"\n"),arg1*arg2));
  
  auto myFun = arg1*2;
  std::function<int(int)> f4(myFun);
  std::function<float(float)> f5(myFun);

  int i=2;
  f1(i); // `i` become 4
  f2(3); // returns 6
  f3(2,3.5, "hi!"); // prints "hi!3.52\n" to COUT(), then returns 2*3.5, which
                    // is promoted to 2.0*3.5, which is 7.0, which is returned as int 7
  f4(4); // return 8
  f5(5.5); // returns 11.0

  struct myType { int i; void operator*(int i){COUT()<< "i=" << i << "\n";}};
  myType t;

  myFun(3); // returns 6
  myFun(3.3); // returns 6.6
  myFun(string("hi")); // returns "hihi" as a string is the string type support repeating
                       // by multiplated amount
  myFun(t); // prints "i=2", returns void
  int j=myFun(t); // does not compile because myFun returns void here
  int k=myFun(2); // k is set to 4