MATLAB dictionary comprehension

Question

List comprehensions are mostly recreated with arrayfun/cellfun, but there's no dictionaryfun. What's a good way to port the following Python syntax?

{2*i: x-1 for i, x in enumerate([1, 2, 3]) if (x != 2 and i > 0)}
# {4: 2}

{i: ("a", x**2) for i, x in enumerate([1, np.array([2, 3])])}
# {0: ('a', 1), 1: ('a', array([4, 9]))}

{k: v**2 for k, v in dict(a=1, b=-2).items() if v > 0}
# {'a': 1}

So something nearly fully general, sparing nested comprehensions, value-dependent keys, key-dependent values, and ternary-conditional keys/values (v if v > 0 else v**2). Indexing is to remain 1-indexed.

Answer 1

I implemented dictionary comprehensions in MATLAB using the latest dictionary. Typical syntax is

out = py_dictcomp(@(i)i, @(x)x - 1, [1 2 3], @(i, x)x ~= 2)

  dictionary (double ⟼ double) with 2 entries:
    1 ⟼ 0
    3 ⟼ 2

out = py_dictcomp(@(k)k, @(v)v^2, dictionary(a=1, b=-2))

  dictionary (string ⟼ double) with 2 entries:
    "a" ⟼ 1
    "b" ⟼ 4

It also fully supports ternary conditionals:

{("we have" if i == 0 else i - 1): 
 ((x + "ogs") if isinstance(x, str) else (x + 1))
 for i, x in enumerate([2, "d", 3.5])
 if not isinstance(x, float)}
# {'we have': 3, 0: 'dogs'}

via ifelse(a, cond, b), implemented separately. Code & validation below.

If there's better ways to do this, feel free to share.

py_dictcomp

function out = py_dictcomp(fn_k, fn_v, iterable, cond, cell_values)
    % py_dictcomp
    % Mimics Python's
    %
    %     {f(k): g(v) for k, v in dict.items() if cond(k, v)}
    %
    % where [f(k), g(v)] = fn(k, v)
    %
    % or, if `iterable` isn't `dictionary`,
    %
    %     {k: v for i, x in enumerate(iterable) if cond(i, x)}
    %
    % where `[k, v] = f(i, x)`.
    %
    % `cell_values=true` makes `out` like `dictionary(a={1})`. By default,
    % `false` is attempted first. Has no effect if `iterable` is `dictionary`. 
    %
    % Default `cond = @(a, b) true`.
    %
    if nargin == 3
        cond = @(a, b) true;
    end
    if nargin <= 4
        cell_values = false;
    end
    user_set_cell_values = (nargin == 5);

    out = dictionary();
    if strcmp(class(iterable), "dictionary")
        cell_values = strcmp(iterable.values, "cell");
        keys = iterable.keys;
        values = iterable.values;

        for l=1:iterable.numEntries
            k = keys{l};
            if cell_values
                v = values{l};
            else
                v = values(l);
            end
            if cond(k, v)
                k = fn_k(k);
                v = fn_v(v);
                if cell_values
                    out{k} = v;
                else
                    out(k) = v;
                end
            end
        end
    else
        is_cell = iscell(iterable);
        for i=1:numel(iterable)
            if is_cell
                x = iterable{i};
            else
                x = iterable(i);
            end
            
            if cond(i, x)
                k = fn_k(i);
                v = fn_v(x);

                if cell_values
                    out{k} = v;
                else
                    try
                        out(k) = v;w
                        % e.g. first populate with `double` values, then
                        % `string`, the `string` becomes `NaN` unless cell
                        if isnan(out(k)) && ~isnan(v)
                            error("NaN `out(k)` without NaN `v`")
                        end
                    catch e
                        if user_set_cell_values
                            throw(e)
                        else
                            out = py_dictcomp(fn_k, fn_v, iterable, cond, true);
                        end
                    end
                end
            end
        end
    end
end

ifelse & validation

Available at Github.