Using mongodb aggregate, how to turn field values into array literal

It probably would be better to use another technique in order to get the distinct results by making the "text" the actual "grouping key" of the $group pipeline. There is a trick to doing that reasonably efficiently in odern MongoDB versions like you have, being version 2.6 or greater:

db.collection.aggregate([
    { "$match": {
        "$or":[
            { "description.position":/s/i },
            { "employer.name":/s/i},
            { "hiringManager.profile.name":/s/i }
        ]
    }},
    { "$project": {
        "_id": { 
            "$setDifference": [
                { "$map": {
                    "input": { "$literal": ["A","B","C" ] },
                     "as": "type",
                    "in": { "$cond": [
                        { "$eq": [ "$$type", "A" ] },
                        "$description.position",
                        { "$cond": [
                            { "$eq": [ "$$type", "B" ] },
                            "$employer.name",
                            "$hiringManager.profile.name"
                        ]}
                    ]}
                }},
                [null] 
            ]
        }
    }},
    { "$unwind": "$_id" },
    { "$group": { "_id": "$_id" } }
])

So $map is used as the basis to trigger a "switch" by processing the $literal array of ["A","B","C"] sent to it. So for each of those elements the appropriate field is chosen as the output value.

Just in case any of those values were null or possibly even a duplicate in the same document the $setDifference operator will sort that out.

The resulting array in each document is processed with $unwind so that it's elements can then be passed as the grouping key to $group which results in distinct documents for each "text" term.

Of course the trade-off here is that the documents in the pipeline would be a multiple of the documents in the collection by up to three possible values as from each field, so more documents in the pipeline than the query matches until distinctly grouped. So there is a cost involved when using $unwind.

The benefit is separate documents in the results, which can grow beyond 16MB of individual "texts" by using a cursor to output. Of course, that's a lot of text to begin with.

The other note to your existing aggregation operation is considering that you are already accepting $setUnion to combine the fields and get distinct values you may as well even "reduce" the input arrays by using $addToSet instead. This avoids growing the arrays with duplicates that you would end up removing anyway.

The same $setDifference operation should also be considered since your $or condition does not guarantee that "all" of the fields contain a valid string or are even present. Where not all fields are valid then you would also receive an distinct result of null along with the other text terms.

So it's about weighing up which is more important to you. The present operation is likely to be faster and less resource intensive ( with the modifications mentioned ), but the alternate caters for larger and possibly more palatable responses. It also allows you to "limit" and maybe even do things like "count" the occurrences of those "text" values.

@Neil's answer is close, but it seemed like another match was needed to ensure the results matched the original regex. I'm not sure if this is a good solution, but here's a new working aggregate. It seemed to work without setDifferennce, so I'm not sure if that's needed or not.

Basically, I run another match on the unwind result to ensure they match the original regex.

aggregate([

  { '$match': {
        '$or':[
            { 'description.position':/s/i },
            { 'employer.name':/s/i},
            { 'hiringManager.profile.name':/s/i }
        ]
    }},
    { '$project': {
        '_id':  
                { '$map': {
                    'input': { '$literal': ['A','B','C' ] },
                     'as': 'type',
                     'in': { '$cond': [
                        { '$eq': [ '$$type', 'A' ] },
                        '$description.position',
                        { '$cond': [
                            { '$eq': [ '$$type', 'B' ] },
                            '$employer.name',
                            '$hiringManager.profile.name'
                        ]}
                    ]}
                },
        }
    }},
    { '$unwind': '$_id' },
    { '$match': { '_id':/s/i }},
{ '$group': { '_id': '$_id' } }
]);
});