**Use case**

To be able run arrayCompact with deduplication based on some function from input value.

**Describe the solution you'd like**
```
SELECT
    [(1, 'a'), (2, 'b'), (3, 'b'), (4, 'c')] AS arr,
    arrayCompact((x)-> x.2, arr)
```
**Describe alternatives you've considered**

```
SELECT
    [(1, 'a'), (2, 'b'), (3, 'b'), (4, 'c')] AS arr,
    arrayFilter((x, y) -> ((x.2) != y), arr, arrayPushFront(arrayPopBack(arr.2), '')) AS x

Query id: ae74a2c7-5bc5-4b77-8fc4-85fd7e6bca25

┌─arr───────────────────────────────┬─x─────────────────────────┐
│ [(1,'a'),(2,'b'),(3,'b'),(4,'c')] │ [(1,'a'),(2,'b'),(4,'c')] │
└───────────────────────────────────┴───────────────────────────┘
```


size_t src_offsets_size = src_offsets.size();
        auto res_offsets_column = ColumnArray::ColumnOffsets::create(src_offsets_size);
        IColumn::Offsets & res_offsets = res_offsets_column->getData();
        size_t res_pos = 0;
        size_t src_pos = 0;
        for (size_t i = 0; i < src_offsets_size; ++i)
        {
            auto src_offset = src_offsets[i];
            
            if (src_pos < src_offset)
            {
                
                res_values_column->insertFrom(*mapped, src_pos);
                
                ++src_pos;
                ++res_pos;
                for (; src_pos < src_offset; ++src_pos)
                {
                    if (mapped->compareAt(src_pos - 1, src_pos, *mapped, 1))
                    {
                        res_values_column->insertFrom(*mapped, src_pos);
                        ++res_pos;
                    }
                }
            }
            res_offsets[i] = res_pos;
        }
        res_ptr = ColumnArray::create(std::move(res_values_column), std::move(res_offsets_column));
    }
    static ColumnPtr execute(const ColumnArray & array, ColumnPtr mapped)