I have the different types listed below:
type OrBranch = {
or: Branch[]
}
type AndBranch = {
and: Branch[]
}
I need a type called Branch that can either be an OrBranch or an AndBranch. I initially attempted this:
type Branch = AndBrand | OrBranch
This works well, unless I want to perform something like:
let branch: Branch = ...
let andOr = 'and'; // or 'or'
let nodes = branch[andOr]
In this case, I receive an error stating that branch is not indexable. So, I then tried using an indexable type:
type AndOr = 'and' | 'or';
type Branch = Record<AndOr, Branch[]>;
However, this approach demands that both and and or must exist, preventing me from casting an AndBranch to Branch in certain scenarios.
Similarly,
type Branch = Record<AndOr, Branch[]> | AndBranch | OrBranch
This solution also doesn't work for the same reason.
Although I could utilize type guards to determine the type, I have lengthy functions that manipulate these objects where they can essentially be treated the same except for the property. Hence, I wanted to minimize redundant code by leveraging the andOr variable, which type guards do not fully prevent. For example:
let retval = {} as Branch;
if (isAnd(branch)) {
(retval as AndBranch).and = [] as Branch[];
set = (retval as AndBranch).and;
} else {
(retval as OrBranch).or = [] as Branch[];
set = (retval as OrBranch).or;
}
set = _.reduce(set, (all, item: Branch)=> {
if (isAnd(branch) && isAnd(item))
return _.union(all, item.and);
else if (isOr(branch) && isOr(item))
return _.union(all, item.or);
else
return all;
}, [] as Branch[]);
in comparison to:
andOr = isAnd(branch) ? 'and' : 'or';
let retval = {} as Branch;
retval[andOr] = _.reduce(set, (all, item: Branch) => {
if (item[andOr])
return _.union(all, item[andOr]);
else
return all;
}, [] as Branch[]);
I am aware of a method to mandate exactly one of and and or (similar to the solution provided in Enforce Typescript object has exactly one key from a set). However, that type cannot be indexed.
Is there a way to achieve both effects?