injective-function

According to this course , all constructors (for inductive types) are injective and disjoint: ...Similar principles apply to all inductively defined types: all constructors are injective, and the values built from distinct constructors are never equal. For lists, the cons constructor is injective and nil is different from every non-empty list. For booleans, true and false are unequal. (And the inversion tactic based on this assumption) I am just wondering how do we know this assumption holds? How do we know that, e.g., we cannot define natural numbers based on 1) a Successor and maybe a

All of the following work: {-# LANGUAGE TypeFamilies #-} type family TF a type instance TF Int = String type instance TF Bool = Char data family DF a data instance DF Int = DFInt String data instance DF Bool = DFBool Char type family CTF a where CTF Int = String CTF Bool = Char CTF a = Double -- Overlap OK! ...but this doesn't (as of GHC-8.2): data family CDF a where CDF Int = CDFInt String CDF Bool = CDFBool Char CDF a = CDFOther Double wtmpf-file24527.hs:16:19: error: parse error on input ‘where’ | 16 | data family CDF a where | ^^^^^ Is it just that nobody has bothered to implement this yet

This question already has an answer here: Two way/reverse map 13 answers I often deal with mappings which are injective . In programming terminology, this can be expressed as a dictionary where all values are unique as well as, of course, all keys. Is there a memory-efficient data structure for injective mappings with all the time-complexity properties you expect from dictionaries? For example: d = {1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'} d.get(2) = 'b' # this works with a normal dictionary d.get('b', reverse=True) = 2 # but this is not possible All the solutions in Two way/reverse map seem to