This is indeed inconsistent.

Both cases use Map()

immutable-js/src/Map.js

Lines 42 to 55 in 751082f

    
           export class Map extends KeyedCollection { 
        
             // @pragma Construction 
        
             constructor(value) { 
        
               return value === null || value === undefined 
        
                 ? emptyMap() 
        
                 : isMap(value) && !isOrdered(value) 
        
                   ? value 
        
                   : emptyMap().withMutations(map => { 
        
                       const iter = KeyedCollection(value); 
        
                       assertNotInfinite(iter.size); 
        
                       iter.forEach((v, k) => map.set(k, v)); 
        
                     }); 
        
             }

then this invokes KeyedCollection()

immutable-js/src/Collection.js

Lines 20 to 24 in 751082f

    
           export class KeyedCollection extends Collection { 
        
             constructor(value) { 
        
               return isKeyed(value) ? value : KeyedSeq(value); 
        
             } 
        
           }

then KeyedSeq()

immutable-js/src/Seq.js

Lines 91 to 102 in 751082f

    
           export class KeyedSeq extends Seq { 
        
             constructor(value) { 
        
               return value === null || value === undefined 
        
                 ? emptySequence().toKeyedSeq() 
        
                 : isCollection(value) 
        
                   ? isKeyed(value) 
        
                     ? value.toSeq() 
        
                     : value.fromEntrySeq() 
        
                   : isRecord(value) 
        
                     ? value.toSeq() 
        
                     : keyedSeqFromValue(value); 
        
             }

then keyedSeqFromValue()

immutable-js/src/Seq.js

Lines 296 to 312 in 751082f

    
           export function keyedSeqFromValue(value) { 
        
             const seq = Array.isArray(value) 
        
               ? new ArraySeq(value) 
        
               : hasIterator(value) 
        
                 ? new CollectionSeq(value) 
        
                 : undefined; 
        
             if (seq) { 
        
               return seq.fromEntrySeq(); 
        
             } 
        
             if (typeof value === 'object') { 
        
               return new ObjectSeq(value); 
        
             } 
        
             throw new TypeError( 
        
               'Expected Array or collection object of [k, v] entries, or keyed object: ' + 
        
                 value 
        
             ); 
        
           }

Here is the difference between the two cases:

object argument is handled in ObjectSeq()
array argument is handled in ArraySeq()

ObjectSeq() uses Object.keys() to select keys in the collection, which effectively selects own, enumerable, string keys -- Symbol keys are always ignored.

immutable-js/src/Seq.js

Lines 198 to 204 in 751082f

    
           class ObjectSeq extends KeyedSeq { 
        
             constructor(object) { 
        
               const keys = Object.keys(object); 
        
               this._object = object; 
        
               this._keys = keys; 
        
               this.size = keys.length; 
        
             }

ArraySeq() takes the supplied array without filtering, thus uses any key supplied.

Whether the two should both consider Symbol keys is a question. Symbols are not quite supported by immutable js consistently, as can be seen from the documentation https://immutable-js.github.io/immutable-js/docs/#/Map/Map

Keep in mind, when using JS objects to construct Immutable Maps, that JavaScript Object properties are always strings, [...]

This is obviously false since Symbols have been introduced, so the documentation predates Symbols.

Uh oh!

Map constructor ignores symbols #1731

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions