Functions for identity and equality checking

[msoeken]

Is your feature request related to a problem? Please describe.
I find myself writing these functions when making use of the array iteration functions such as Mapped and Filtered.

Describe the solution you'd like
I suggest to have functions in the library for Identity<'T>(a), EqualsX(a, b), NotEqualsX(a, b), where X in I, B, D, and L.

Here is an example how these functions can be used for retrieving all bits in an integer that are 1 in their binary expansion:

function IntegerBits(val : Int, bits : Int) : Int[] {
    let id = Id<(Int, Bool)>;
    let pred = Compose(EqualsB(_, true), Snd<Int, Bool>);
    return Mapped(Fst<Int, Bool>, Filtered(pred, MappedByIndex(id, IntAsBoolArray(val, bits))));
}

Describe alternatives you've considered
Writing the functions as local private functions.

Additional context
N/A

[cgranade]

I think something along these lines could make a lot of sense. I know @bettinaheim and I have mulled over before the idea of making operators like a + b be equivalent to functions like AddX(a, b); this enhancement would fit well with that idea and would perhaps even give a transition path forward should we choose to adopt that language change at some point.

Concretely, then, how about adding the following, using X to stand for type suffixes rather than type parameters?

Microsoft.Quantum.Canon.Identity<'T> : 'T -> 'T
Microsoft.Quantum.Operators.NegationX : X -> X
Microsoft.Quantum.Operators.PlusX : (X, X) -> X
// What would be a good type suffix for "array of"?
Microsoft.Quantum.Operators.PlusA<'Element> : ('Element[], 'Element[]) -> 'Element[]
Microsoft.Quantum.Operators.MinusX : (X, X) -> X
Microsoft.Quantum.Operators.TimesX : (X, X) -> X
Microsoft.Quantum.Operators.DividedByX : (X, X) -> X
// Only applicable for I and L
Microsoft.Quantum.Operators.ModX : (X, X) -> X
Microsoft.Quantum.Operators.PowX : (X, Int) -> X
Microsoft.Quantum.Operators.LeftShiftedX : (X, Int) -> X
Microsoft.Quantum.Operators.RightShiftedX : (X, Int) -> X
// Plural or not? Feels weird for this to be singular, but feels NotEqualsX feels weird as plural...
Microsoft.Quantum.Operators.EqualsX : (X, X) -> Bool 
Microsoft.Quantum.Operators.NotEqualsX : (X, X) -> Bool
Microsoft.Quantum.Operators.GreaterThanX : (X, X) -> Bool
Microsoft.Quantum.Operators.LessThanX : (X, X) -> Bool
Microsoft.Quantum.Operators.GreaterThanOrEqualX : (X, X) -> Bool
Microsoft.Quantum.Operators.LessThanOrEqualX : (X, X) -> Bool
Microsoft.Quantum.Operators.Not : Bool -> Bool
Microsoft.Quantum.Operators.And : (Bool, Bool) -> Bool
Microsoft.Quantum.Operators.Or : (Bool, Bool) -> Bool
// Not strictly an operator...
Microsoft.Quantum.Operators.Xor : (Bool, Bool) -> Bool
// Represents ? |.
Microsoft.Quantum.Operators.Conditioned<'T> : (Bool, 'T, 'T) -> Bool
// What would we call the range operator?

The big drawback I can see is that this might feel a bit odd given that some functions backing operators are currently in Microsoft.Quantum.Bitwise, such that it might make sense to move things like PlusX and MinusX into Microsoft.Quantum.Math instead of making a new Microsoft.Quantum.Operators namespace. Similarly, we already have Microsoft.Quantum.Math.PowD and the like, such that Microsoft.Quantum.Operators.PowI would be a bit odd.

[msoeken]

That's a good list of operators and I like the proposal. I think it makes sense to have them in Microsoft.Quantum.Math.

[cgranade]

Revised proposal, then, breaking things into existing namespaces as much as possible:

Microsoft.Quantum.Canon.Identity<'T> : 'T -> 'T
Microsoft.Quantum.Math.NegationX : X -> X
Microsoft.Quantum.Math.PlusX : (X, X) -> X
// What would be a good type suffix for "array of"?
Microsoft.Quantum.Math.PlusA<'Element> : ('Element[], 'Element[]) -> 'Element[]
Microsoft.Quantum.Math.MinusX : (X, X) -> X
Microsoft.Quantum.Math.TimesX : (X, X) -> X
Microsoft.Quantum.Math.DividedByX : (X, X) -> X
// Only applicable for I and L
Microsoft.Quantum.Math.ModX : (X, X) -> X
Microsoft.Quantum.Math.PowX : (X, Int) -> X
Microsoft.Quantum.Bitwise.LeftShiftedX : (X, Int) -> X
Microsoft.Quantum.Btiwise.RightShiftedX : (X, Int) -> X
// Plural or not? Feels weird for this to be singular, but feels NotEqualsX feels weird as plural...
// Should =, ≠, >, <, ≥ and ≤ be in Logical or Math?
Microsoft.Quantum.Logical.EqualsX : (X, X) -> Bool 
Microsoft.Quantum.Logical.NotEqualsX : (X, X) -> Bool
Microsoft.Quantum.Logical.GreaterThanX : (X, X) -> Bool
Microsoft.Quantum.Logical.LessThanX : (X, X) -> Bool
Microsoft.Quantum.Logical.GreaterThanOrEqualX : (X, X) -> Bool
Microsoft.Quantum.Logical.LessThanOrEqualX : (X, X) -> Bool
Microsoft.Quantum.Logical.Not : Bool -> Bool
Microsoft.Quantum.Logical.And : (Bool, Bool) -> Bool
Microsoft.Quantum.Logical.Or : (Bool, Bool) -> Bool
Microsoft.Quantum.Logical.Xor : (Bool, Bool) -> Bool
// Represents ? |.
Microsoft.Quantum.Logical.Conditioned<'T> : (Bool, 'T, 'T) -> Bool
// What would we call the range operator?

This does still introduce a new namespace (namely Microsoft.Quantum.Logical), but this at least parallels the existing Microsoft.Quantum.Bitwise namespace.

[emzatos]

Looks like this issue has been solved

[msoeken]

Issue has been resolved in #152.